From aa63aa30d3ccd4759d83d549f67ba1cc86f4c7ce Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Fri, 3 Jan 2025 08:35:35 +0000 Subject: [PATCH] Go Dependency: Bump github.com/vmware/govmomi from 0.46.3 to 0.47.0 Bumps [github.com/vmware/govmomi](https://github.com/vmware/govmomi) from 0.46.3 to 0.47.0. - [Release notes](https://github.com/vmware/govmomi/releases) - [Changelog](https://github.com/vmware/govmomi/blob/main/CHANGELOG.md) - [Commits](https://github.com/vmware/govmomi/compare/v0.46.3...v0.47.0) --- updated-dependencies: - dependency-name: github.com/vmware/govmomi dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] --- go.mod | 2 +- go.sum | 4 +- .../github.com/vmware/govmomi/.goreleaser.yml | 8 +- vendor/github.com/vmware/govmomi/Makefile | 18 +- vendor/github.com/vmware/govmomi/client.go | 18 +- .../vmware/govmomi/internal/helpers.go | 31 + .../vmware/govmomi/internal/methods.go | 25 + .../vmware/govmomi/internal/types.go | 63 +- .../govmomi/internal/version/version.go | 2 +- .../govmomi/object/virtual_device_list.go | 19 +- .../govmomi/object/virtual_disk_manager.go | 2 +- .../object/virtual_disk_manager_internal.go | 60 +- .../github.com/vmware/govmomi/vim25/client.go | 2 +- .../vmware/govmomi/vim25/methods/methods.go | 258 ++- .../github.com/vmware/govmomi/vim25/mo/mo.go | 18 +- .../vmware/govmomi/vim25/soap/client.go | 32 +- .../vmware/govmomi/vim25/soap/json_client.go | 14 +- .../vmware/govmomi/vim25/soap/soap.go | 18 +- .../vmware/govmomi/vim25/types/deep_copy.go | 65 + .../vmware/govmomi/vim25/types/enum.go | 697 +++++- .../vmware/govmomi/vim25/types/helpers.go | 4 + .../vmware/govmomi/vim25/types/if.go | 142 +- .../vmware/govmomi/vim25/types/types.go | 1973 ++++++++++++++++- .../vmware/govmomi/vim25/types/unreleased.go | 28 - vendor/modules.txt | 4 +- 25 files changed, 3259 insertions(+), 248 deletions(-) create mode 100644 vendor/github.com/vmware/govmomi/vim25/types/deep_copy.go diff --git a/go.mod b/go.mod index 1e048574..a7aa8b0e 100644 --- a/go.mod +++ b/go.mod @@ -13,7 +13,7 @@ require ( github.com/atc0005/go-nagios v0.19.0 github.com/google/go-cmp v0.6.0 github.com/rs/zerolog v1.33.0 - github.com/vmware/govmomi v0.46.3 + github.com/vmware/govmomi v0.47.0 ) require ( diff --git a/go.sum b/go.sum index c9348a33..efa3607d 100644 --- a/go.sum +++ b/go.sum @@ -22,8 +22,8 @@ github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8= github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss= github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= -github.com/vmware/govmomi v0.46.3 h1:zBn42Rl0WZBFhGao8Dy0MFRkbE4YNPqOu0OBd+ww6VM= -github.com/vmware/govmomi v0.46.3/go.mod h1:uoLVU9zlXC4p4GmLVG+ZJmBC0Gn3Q7mytOJvi39OhxA= +github.com/vmware/govmomi v0.47.0 h1:yFDYALpyuyZfN9L0oZ2wP+Pk9e3++Ak57dW8xuuiJ44= +github.com/vmware/govmomi v0.47.0/go.mod h1:bYwUHpGpisE4AOlDl5eph90T+cjJMIcKx/kaa5v5rQM= golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= diff --git a/vendor/github.com/vmware/govmomi/.goreleaser.yml b/vendor/github.com/vmware/govmomi/.goreleaser.yml index de6ced25..e1cb5289 100644 --- a/vendor/github.com/vmware/govmomi/.goreleaser.yml +++ b/vendor/github.com/vmware/govmomi/.goreleaser.yml @@ -17,8 +17,9 @@ builds: - s390x env: - CGO_ENABLED=0 - - PKGPATH=github.com/vmware/govmomi/govc/flags - main: ./govc/main.go + - PKGPATH=github.com/vmware/govmomi/cli/flags + dir: ./govc + main: . binary: govc ldflags: - "-X {{.Env.PKGPATH}}.BuildVersion={{.Version}} -X {{.Env.PKGPATH}}.BuildCommit={{.ShortCommit}} -X {{.Env.PKGPATH}}.BuildDate={{.Date}}" @@ -28,7 +29,8 @@ builds: goarch: *goarch-defs env: - CGO_ENABLED=0 - main: ./vcsim/main.go + dir: ./vcsim + main: . binary: vcsim ldflags: - "-X main.buildVersion={{.Version}} -X main.buildCommit={{.ShortCommit}} -X main.buildDate={{.Date}}" diff --git a/vendor/github.com/vmware/govmomi/Makefile b/vendor/github.com/vmware/govmomi/Makefile index 0f31649a..2d13dc99 100644 --- a/vendor/github.com/vmware/govmomi/Makefile +++ b/vendor/github.com/vmware/govmomi/Makefile @@ -94,13 +94,21 @@ install: ## Install govc and vcsim ## Generate ## -------------------------------------- +GO_MOD_FILES := $(filter-out ./hack/tools/go.mod,$(shell find . -name go.mod)) +GO_MOD_OP := tidy + +.PHONY: $(GO_MOD_FILES) +$(GO_MOD_FILES): + go -C $(@D) mod $(GO_MOD_OP) + .PHONY: mod -mod: ## Runs go mod tidy to validate modules - go mod tidy -v +mod: $(GO_MOD_FILES) +mod: ## Validates the modules -.PHONY: mod-get -mod-get: ## Downloads and caches the modules - go mod download +.PHONY: modules-download +mod-download: GO_MOD_OP=download +mod-download: $(GO_MOD_FILES) +mod-download: ## Downloads and caches the modules .PHONY: doc doc: install diff --git a/vendor/github.com/vmware/govmomi/client.go b/vendor/github.com/vmware/govmomi/client.go index 5becedd4..c67e74b0 100644 --- a/vendor/github.com/vmware/govmomi/client.go +++ b/vendor/github.com/vmware/govmomi/client.go @@ -1,18 +1,6 @@ -/* -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. -*/ +// © Broadcom. All Rights Reserved. +// The term “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. +// SPDX-License-Identifier: Apache-2.0 /* This package is the root package of the govmomi library. diff --git a/vendor/github.com/vmware/govmomi/internal/helpers.go b/vendor/github.com/vmware/govmomi/internal/helpers.go index 859469a0..f547c25d 100644 --- a/vendor/github.com/vmware/govmomi/internal/helpers.go +++ b/vendor/github.com/vmware/govmomi/internal/helpers.go @@ -18,13 +18,16 @@ package internal import ( "context" + "encoding/xml" "fmt" + "io" "net" "net/http" "net/url" "os" "path" "slices" + "strings" "github.com/vmware/govmomi/vim25" "github.com/vmware/govmomi/vim25/mo" @@ -149,3 +152,31 @@ func HostGatewayTransferURL(u *url.URL, hostMoref types.ManagedObjectReference) turl.Path = fmt.Sprintf("/hgw/%s%s", hostMoref.Value, oldPath) return &turl } + +func (arg ReflectManagedMethodExecuterSoapArgument) Value() []string { + if arg.Val == "" { + return nil + } + + d := xml.NewDecoder(strings.NewReader(arg.Val)) + var val []string + + for { + t, err := d.Token() + if err != nil { + if err == io.EOF { + break + } + panic(err) + } + if c, ok := t.(xml.CharData); ok { + val = append(val, string(c)) + } + } + + return val +} + +func EsxcliName(name string) string { + return strings.ReplaceAll(strings.Title(name), ".", "") +} diff --git a/vendor/github.com/vmware/govmomi/internal/methods.go b/vendor/github.com/vmware/govmomi/internal/methods.go index 95ccee8d..b59770c0 100644 --- a/vendor/github.com/vmware/govmomi/internal/methods.go +++ b/vendor/github.com/vmware/govmomi/internal/methods.go @@ -121,3 +121,28 @@ func ExecuteSoap(ctx context.Context, r soap.RoundTripper, req *ExecuteSoapReque return resBody.Res, nil } + +type QueryVirtualDiskInfoTaskBody struct { + Req *QueryVirtualDiskInfoTaskRequest `xml:"urn:internalvim25 QueryVirtualDiskInfo_Task,omitempty"` + Res *QueryVirtualDiskInfo_TaskResponse `xml:"urn:vim25 QueryVirtualDiskInfo_TaskResponse,omitempty"` + InternalRes *QueryVirtualDiskInfo_TaskResponse `xml:"urn:internalvim25 QueryVirtualDiskInfo_TaskResponse,omitempty"` + Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` +} + +func (b *QueryVirtualDiskInfoTaskBody) Fault() *soap.Fault { return b.Fault_ } + +func QueryVirtualDiskInfoTask(ctx context.Context, r soap.RoundTripper, req *QueryVirtualDiskInfoTaskRequest) (*QueryVirtualDiskInfo_TaskResponse, error) { + var reqBody, resBody QueryVirtualDiskInfoTaskBody + + reqBody.Req = req + + if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { + return nil, err + } + + if resBody.Res != nil { + return resBody.Res, nil + } + + return resBody.InternalRes, nil +} diff --git a/vendor/github.com/vmware/govmomi/internal/types.go b/vendor/github.com/vmware/govmomi/internal/types.go index b84103b8..cada7a90 100644 --- a/vendor/github.com/vmware/govmomi/internal/types.go +++ b/vendor/github.com/vmware/govmomi/internal/types.go @@ -1,11 +1,11 @@ /* -Copyright (c) 2014 VMware, Inc. All Rights Reserved. +Copyright (c) 2017-2024 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 +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, @@ -22,11 +22,25 @@ import ( "github.com/vmware/govmomi/vim25/types" ) +type VimEsxCLICLIFault struct { + types.MethodFault + + ErrMsg []string `xml:"errMsg"` +} + +func init() { + types.Add("VimEsxCLICLIFault", reflect.TypeOf((*VimEsxCLICLIFault)(nil)).Elem()) +} + type DynamicTypeMgrQueryMoInstancesRequest struct { This types.ManagedObjectReference `xml:"_this"` FilterSpec BaseDynamicTypeMgrFilterSpec `xml:"filterSpec,omitempty,typeattr"` } +func init() { + types.Add("DynamicTypeMgrQueryMoInstances", reflect.TypeOf((*DynamicTypeMgrQueryMoInstancesRequest)(nil)).Elem()) +} + type DynamicTypeMgrQueryMoInstancesResponse struct { Returnval []DynamicTypeMgrMoInstance `xml:"urn:vim25 returnval"` } @@ -45,7 +59,7 @@ func init() { types.Add("DynamicTypeEnumTypeInfo", reflect.TypeOf((*DynamicTypeEnumTypeInfo)(nil)).Elem()) } -type DynamicTypeMgrAllTypeInfoRequest struct { +type DynamicTypeMgrAllTypeInfo struct { types.DynamicData ManagedTypeInfo []DynamicTypeMgrManagedTypeInfo `xml:"managedTypeInfo,omitempty"` @@ -54,7 +68,7 @@ type DynamicTypeMgrAllTypeInfoRequest struct { } func init() { - types.Add("DynamicTypeMgrAllTypeInfo", reflect.TypeOf((*DynamicTypeMgrAllTypeInfoRequest)(nil)).Elem()) + types.Add("DynamicTypeMgrAllTypeInfo", reflect.TypeOf((*DynamicTypeMgrAllTypeInfo)(nil)).Elem()) } type DynamicTypeMgrAnnotation struct { @@ -182,8 +196,12 @@ type DynamicTypeMgrQueryTypeInfoRequest struct { FilterSpec BaseDynamicTypeMgrFilterSpec `xml:"filterSpec,omitempty,typeattr"` } +func init() { + types.Add("DynamicTypeMgrQueryTypeInfo", reflect.TypeOf((*DynamicTypeMgrQueryTypeInfoRequest)(nil)).Elem()) +} + type DynamicTypeMgrQueryTypeInfoResponse struct { - Returnval DynamicTypeMgrAllTypeInfoRequest `xml:"urn:vim25 returnval"` + Returnval DynamicTypeMgrAllTypeInfo `xml:"urn:vim25 returnval"` } func init() { @@ -237,6 +255,10 @@ type RetrieveDynamicTypeManagerResponse struct { Returnval *InternalDynamicTypeManager `xml:"urn:vim25 returnval"` } +func init() { + types.Add("RetrieveDynamicTypeManager", reflect.TypeOf((*RetrieveDynamicTypeManagerRequest)(nil)).Elem()) +} + type RetrieveManagedMethodExecuterRequest struct { This types.ManagedObjectReference `xml:"_this"` } @@ -268,3 +290,34 @@ type ExecuteSoapRequest struct { type ExecuteSoapResponse struct { Returnval *ReflectManagedMethodExecuterSoapResult `xml:"urn:vim25 returnval"` } + +func init() { + types.Add("ExecuteSoap", reflect.TypeOf((*ExecuteSoapRequest)(nil)).Elem()) + + types.Add("ArrayOfVirtualDiskInfo", reflect.TypeOf((*ArrayOfVirtualDiskInfo)(nil)).Elem()) + + types.Add("VirtualDiskInfo", reflect.TypeOf((*VirtualDiskInfo)(nil)).Elem()) + + types.Add("QueryVirtualDiskInfo_Task", reflect.TypeOf((*QueryVirtualDiskInfoTaskRequest)(nil)).Elem()) +} + +type VirtualDiskInfo struct { + Name string `xml:"unit>name"` + DiskType string `xml:"diskType"` + Parent string `xml:"parent,omitempty"` +} + +type ArrayOfVirtualDiskInfo struct { + VirtualDiskInfo []VirtualDiskInfo `xml:"VirtualDiskInfo,omitempty"` +} + +type QueryVirtualDiskInfoTaskRequest struct { + This types.ManagedObjectReference `xml:"_this"` + Name string `xml:"name"` + Datacenter *types.ManagedObjectReference `xml:"datacenter,omitempty"` + IncludeParents bool `xml:"includeParents"` +} + +type QueryVirtualDiskInfo_TaskResponse struct { + Returnval types.ManagedObjectReference `xml:"returnval"` +} diff --git a/vendor/github.com/vmware/govmomi/internal/version/version.go b/vendor/github.com/vmware/govmomi/internal/version/version.go index fe355ec2..95d9bb6d 100644 --- a/vendor/github.com/vmware/govmomi/internal/version/version.go +++ b/vendor/github.com/vmware/govmomi/internal/version/version.go @@ -21,5 +21,5 @@ const ( ClientName = "govmomi" // ClientVersion is the version of this SDK - ClientVersion = "0.46.3" + ClientVersion = "0.47.0" ) diff --git a/vendor/github.com/vmware/govmomi/object/virtual_device_list.go b/vendor/github.com/vmware/govmomi/object/virtual_device_list.go index 32b738a2..32cd4c2a 100644 --- a/vendor/github.com/vmware/govmomi/object/virtual_device_list.go +++ b/vendor/github.com/vmware/govmomi/object/virtual_device_list.go @@ -573,15 +573,20 @@ func (l VirtualDeviceList) CreateDisk(c types.BaseVirtualController, ds types.Ma name += ".vmdk" } + bi := types.VirtualDeviceFileBackingInfo{ + FileName: name, + } + + if ds.Value != "" { + bi.Datastore = &ds + } + device := &types.VirtualDisk{ VirtualDevice: types.VirtualDevice{ Backing: &types.VirtualDiskFlatVer2BackingInfo{ - DiskMode: string(types.VirtualDiskModePersistent), - ThinProvisioned: types.NewBool(true), - VirtualDeviceFileBackingInfo: types.VirtualDeviceFileBackingInfo{ - FileName: name, - Datastore: &ds, - }, + DiskMode: string(types.VirtualDiskModePersistent), + ThinProvisioned: types.NewBool(true), + VirtualDeviceFileBackingInfo: bi, }, }, } @@ -656,7 +661,7 @@ func (l VirtualDeviceList) FindCdrom(name string) (*types.VirtualCdrom, error) { } // CreateCdrom creates a new VirtualCdrom device which can be added to a VM. -func (l VirtualDeviceList) CreateCdrom(c *types.VirtualIDEController) (*types.VirtualCdrom, error) { +func (l VirtualDeviceList) CreateCdrom(c types.BaseVirtualController) (*types.VirtualCdrom, error) { device := &types.VirtualCdrom{} l.AssignController(device, c) diff --git a/vendor/github.com/vmware/govmomi/object/virtual_disk_manager.go b/vendor/github.com/vmware/govmomi/object/virtual_disk_manager.go index 6724843e..0b1a6c5f 100644 --- a/vendor/github.com/vmware/govmomi/object/virtual_disk_manager.go +++ b/vendor/github.com/vmware/govmomi/object/virtual_disk_manager.go @@ -41,7 +41,7 @@ func (m VirtualDiskManager) CopyVirtualDisk( ctx context.Context, sourceName string, sourceDatacenter *Datacenter, destName string, destDatacenter *Datacenter, - destSpec *types.VirtualDiskSpec, force bool) (*Task, error) { + destSpec types.BaseVirtualDiskSpec, force bool) (*Task, error) { req := types.CopyVirtualDisk_Task{ This: m.Reference(), diff --git a/vendor/github.com/vmware/govmomi/object/virtual_disk_manager_internal.go b/vendor/github.com/vmware/govmomi/object/virtual_disk_manager_internal.go index faa9ecad..92967788 100644 --- a/vendor/github.com/vmware/govmomi/object/virtual_disk_manager_internal.go +++ b/vendor/github.com/vmware/govmomi/object/virtual_disk_manager_internal.go @@ -18,66 +18,16 @@ package object import ( "context" - "reflect" + "github.com/vmware/govmomi/internal" "github.com/vmware/govmomi/vim25/soap" "github.com/vmware/govmomi/vim25/types" ) -func init() { - types.Add("ArrayOfVirtualDiskInfo", reflect.TypeOf((*arrayOfVirtualDiskInfo)(nil)).Elem()) - - types.Add("VirtualDiskInfo", reflect.TypeOf((*VirtualDiskInfo)(nil)).Elem()) -} - -type arrayOfVirtualDiskInfo struct { - VirtualDiskInfo []VirtualDiskInfo `xml:"VirtualDiskInfo,omitempty"` -} - -type queryVirtualDiskInfoTaskRequest struct { - This types.ManagedObjectReference `xml:"_this"` - Name string `xml:"name"` - Datacenter *types.ManagedObjectReference `xml:"datacenter,omitempty"` - IncludeParents bool `xml:"includeParents"` -} - -type queryVirtualDiskInfoTaskResponse struct { - Returnval types.ManagedObjectReference `xml:"returnval"` -} - -type queryVirtualDiskInfoTaskBody struct { - Req *queryVirtualDiskInfoTaskRequest `xml:"urn:internalvim25 QueryVirtualDiskInfo_Task,omitempty"` - Res *queryVirtualDiskInfoTaskResponse `xml:"urn:vim25 QueryVirtualDiskInfo_TaskResponse,omitempty"` - InternalRes *queryVirtualDiskInfoTaskResponse `xml:"urn:internalvim25 QueryVirtualDiskInfo_TaskResponse,omitempty"` - Err *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` -} - -func (b *queryVirtualDiskInfoTaskBody) Fault() *soap.Fault { return b.Err } - -func queryVirtualDiskInfoTask(ctx context.Context, r soap.RoundTripper, req *queryVirtualDiskInfoTaskRequest) (*queryVirtualDiskInfoTaskResponse, error) { - var reqBody, resBody queryVirtualDiskInfoTaskBody - - reqBody.Req = req - - if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { - return nil, err - } - - if resBody.Res != nil { - return resBody.Res, nil - } - - return resBody.InternalRes, nil -} - -type VirtualDiskInfo struct { - Name string `xml:"unit>name"` - DiskType string `xml:"diskType"` - Parent string `xml:"parent,omitempty"` -} +type VirtualDiskInfo = internal.VirtualDiskInfo func (m VirtualDiskManager) QueryVirtualDiskInfo(ctx context.Context, name string, dc *Datacenter, includeParents bool) ([]VirtualDiskInfo, error) { - req := queryVirtualDiskInfoTaskRequest{ + req := internal.QueryVirtualDiskInfoTaskRequest{ This: m.Reference(), Name: name, IncludeParents: includeParents, @@ -88,7 +38,7 @@ func (m VirtualDiskManager) QueryVirtualDiskInfo(ctx context.Context, name strin req.Datacenter = &ref } - res, err := queryVirtualDiskInfoTask(ctx, m.Client(), &req) + res, err := internal.QueryVirtualDiskInfoTask(ctx, m.Client(), &req) if err != nil { return nil, err } @@ -98,7 +48,7 @@ func (m VirtualDiskManager) QueryVirtualDiskInfo(ctx context.Context, name strin return nil, err } - return info.Result.(arrayOfVirtualDiskInfo).VirtualDiskInfo, nil + return info.Result.(internal.ArrayOfVirtualDiskInfo).VirtualDiskInfo, nil } type createChildDiskTaskRequest struct { diff --git a/vendor/github.com/vmware/govmomi/vim25/client.go b/vendor/github.com/vmware/govmomi/vim25/client.go index 3daaf131..855bc160 100644 --- a/vendor/github.com/vmware/govmomi/vim25/client.go +++ b/vendor/github.com/vmware/govmomi/vim25/client.go @@ -28,7 +28,7 @@ import ( const ( Namespace = "vim25" - Version = "8.0.3.0" + Version = "9.0.0.0" Path = "/sdk" ) diff --git a/vendor/github.com/vmware/govmomi/vim25/methods/methods.go b/vendor/github.com/vmware/govmomi/vim25/methods/methods.go index 2bc99d21..153e9707 100644 --- a/vendor/github.com/vmware/govmomi/vim25/methods/methods.go +++ b/vendor/github.com/vmware/govmomi/vim25/methods/methods.go @@ -1,18 +1,6 @@ -/* -Copyright (c) 2014-2024 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. -*/ +// © Broadcom. All Rights Reserved. +// The term “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. +// SPDX-License-Identifier: Apache-2.0 package methods @@ -4603,6 +4591,106 @@ func DetachTagFromVStorageObject(ctx context.Context, r soap.RoundTripper, req * return resBody.Res, nil } +type DirectPathProfileManagerCreateBody struct { + Req *types.DirectPathProfileManagerCreate `xml:"urn:vim25 DirectPathProfileManagerCreate,omitempty"` + Res *types.DirectPathProfileManagerCreateResponse `xml:"DirectPathProfileManagerCreateResponse,omitempty"` + Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` +} + +func (b *DirectPathProfileManagerCreateBody) Fault() *soap.Fault { return b.Fault_ } + +func DirectPathProfileManagerCreate(ctx context.Context, r soap.RoundTripper, req *types.DirectPathProfileManagerCreate) (*types.DirectPathProfileManagerCreateResponse, error) { + var reqBody, resBody DirectPathProfileManagerCreateBody + + reqBody.Req = req + + if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { + return nil, err + } + + return resBody.Res, nil +} + +type DirectPathProfileManagerDeleteBody struct { + Req *types.DirectPathProfileManagerDelete `xml:"urn:vim25 DirectPathProfileManagerDelete,omitempty"` + Res *types.DirectPathProfileManagerDeleteResponse `xml:"DirectPathProfileManagerDeleteResponse,omitempty"` + Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` +} + +func (b *DirectPathProfileManagerDeleteBody) Fault() *soap.Fault { return b.Fault_ } + +func DirectPathProfileManagerDelete(ctx context.Context, r soap.RoundTripper, req *types.DirectPathProfileManagerDelete) (*types.DirectPathProfileManagerDeleteResponse, error) { + var reqBody, resBody DirectPathProfileManagerDeleteBody + + reqBody.Req = req + + if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { + return nil, err + } + + return resBody.Res, nil +} + +type DirectPathProfileManagerListBody struct { + Req *types.DirectPathProfileManagerList `xml:"urn:vim25 DirectPathProfileManagerList,omitempty"` + Res *types.DirectPathProfileManagerListResponse `xml:"DirectPathProfileManagerListResponse,omitempty"` + Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` +} + +func (b *DirectPathProfileManagerListBody) Fault() *soap.Fault { return b.Fault_ } + +func DirectPathProfileManagerList(ctx context.Context, r soap.RoundTripper, req *types.DirectPathProfileManagerList) (*types.DirectPathProfileManagerListResponse, error) { + var reqBody, resBody DirectPathProfileManagerListBody + + reqBody.Req = req + + if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { + return nil, err + } + + return resBody.Res, nil +} + +type DirectPathProfileManagerQueryCapacityBody struct { + Req *types.DirectPathProfileManagerQueryCapacity `xml:"urn:vim25 DirectPathProfileManagerQueryCapacity,omitempty"` + Res *types.DirectPathProfileManagerQueryCapacityResponse `xml:"DirectPathProfileManagerQueryCapacityResponse,omitempty"` + Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` +} + +func (b *DirectPathProfileManagerQueryCapacityBody) Fault() *soap.Fault { return b.Fault_ } + +func DirectPathProfileManagerQueryCapacity(ctx context.Context, r soap.RoundTripper, req *types.DirectPathProfileManagerQueryCapacity) (*types.DirectPathProfileManagerQueryCapacityResponse, error) { + var reqBody, resBody DirectPathProfileManagerQueryCapacityBody + + reqBody.Req = req + + if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { + return nil, err + } + + return resBody.Res, nil +} + +type DirectPathProfileManagerUpdateBody struct { + Req *types.DirectPathProfileManagerUpdate `xml:"urn:vim25 DirectPathProfileManagerUpdate,omitempty"` + Res *types.DirectPathProfileManagerUpdateResponse `xml:"DirectPathProfileManagerUpdateResponse,omitempty"` + Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` +} + +func (b *DirectPathProfileManagerUpdateBody) Fault() *soap.Fault { return b.Fault_ } + +func DirectPathProfileManagerUpdate(ctx context.Context, r soap.RoundTripper, req *types.DirectPathProfileManagerUpdate) (*types.DirectPathProfileManagerUpdateResponse, error) { + var reqBody, resBody DirectPathProfileManagerUpdateBody + + reqBody.Req = req + + if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { + return nil, err + } + + return resBody.Res, nil +} + type DisableAlarmBody struct { Req *types.DisableAlarm `xml:"urn:vim25 DisableAlarm,omitempty"` Res *types.DisableAlarmResponse `xml:"DisableAlarmResponse,omitempty"` @@ -4723,6 +4811,26 @@ func DisableMultipathPath(ctx context.Context, r soap.RoundTripper, req *types.D return resBody.Res, nil } +type DisableNetworkBoot_TaskBody struct { + Req *types.DisableNetworkBoot_Task `xml:"urn:vim25 DisableNetworkBoot_Task,omitempty"` + Res *types.DisableNetworkBoot_TaskResponse `xml:"DisableNetworkBoot_TaskResponse,omitempty"` + Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` +} + +func (b *DisableNetworkBoot_TaskBody) Fault() *soap.Fault { return b.Fault_ } + +func DisableNetworkBoot_Task(ctx context.Context, r soap.RoundTripper, req *types.DisableNetworkBoot_Task) (*types.DisableNetworkBoot_TaskResponse, error) { + var reqBody, resBody DisableNetworkBoot_TaskBody + + reqBody.Req = req + + if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { + return nil, err + } + + return resBody.Res, nil +} + type DisableRulesetBody struct { Req *types.DisableRuleset `xml:"urn:vim25 DisableRuleset,omitempty"` Res *types.DisableRulesetResponse `xml:"DisableRulesetResponse,omitempty"` @@ -5183,6 +5291,26 @@ func EnableMultipathPath(ctx context.Context, r soap.RoundTripper, req *types.En return resBody.Res, nil } +type EnableNetworkBoot_TaskBody struct { + Req *types.EnableNetworkBoot_Task `xml:"urn:vim25 EnableNetworkBoot_Task,omitempty"` + Res *types.EnableNetworkBoot_TaskResponse `xml:"EnableNetworkBoot_TaskResponse,omitempty"` + Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` +} + +func (b *EnableNetworkBoot_TaskBody) Fault() *soap.Fault { return b.Fault_ } + +func EnableNetworkBoot_Task(ctx context.Context, r soap.RoundTripper, req *types.EnableNetworkBoot_Task) (*types.EnableNetworkBoot_TaskResponse, error) { + var reqBody, resBody EnableNetworkBoot_TaskBody + + reqBody.Req = req + + if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { + return nil, err + } + + return resBody.Res, nil +} + type EnableNetworkResourceManagementBody struct { Req *types.EnableNetworkResourceManagement `xml:"urn:vim25 EnableNetworkResourceManagement,omitempty"` Res *types.EnableNetworkResourceManagementResponse `xml:"EnableNetworkResourceManagementResponse,omitempty"` @@ -7683,6 +7811,26 @@ func InitiateFileTransferToGuest(ctx context.Context, r soap.RoundTripper, req * return resBody.Res, nil } +type InitiateTransitionToVLCM_TaskBody struct { + Req *types.InitiateTransitionToVLCM_Task `xml:"urn:vim25 InitiateTransitionToVLCM_Task,omitempty"` + Res *types.InitiateTransitionToVLCM_TaskResponse `xml:"InitiateTransitionToVLCM_TaskResponse,omitempty"` + Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` +} + +func (b *InitiateTransitionToVLCM_TaskBody) Fault() *soap.Fault { return b.Fault_ } + +func InitiateTransitionToVLCM_Task(ctx context.Context, r soap.RoundTripper, req *types.InitiateTransitionToVLCM_Task) (*types.InitiateTransitionToVLCM_TaskResponse, error) { + var reqBody, resBody InitiateTransitionToVLCM_TaskBody + + reqBody.Req = req + + if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { + return nil, err + } + + return resBody.Res, nil +} + type InstallHostPatchV2_TaskBody struct { Req *types.InstallHostPatchV2_Task `xml:"urn:vim25 InstallHostPatchV2_Task,omitempty"` Res *types.InstallHostPatchV2_TaskResponse `xml:"InstallHostPatchV2_TaskResponse,omitempty"` @@ -7823,6 +7971,26 @@ func IsClusteredVmdkEnabled(ctx context.Context, r soap.RoundTripper, req *types return resBody.Res, nil } +type IsGuestOsCustomizableBody struct { + Req *types.IsGuestOsCustomizable `xml:"urn:vim25 IsGuestOsCustomizable,omitempty"` + Res *types.IsGuestOsCustomizableResponse `xml:"IsGuestOsCustomizableResponse,omitempty"` + Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` +} + +func (b *IsGuestOsCustomizableBody) Fault() *soap.Fault { return b.Fault_ } + +func IsGuestOsCustomizable(ctx context.Context, r soap.RoundTripper, req *types.IsGuestOsCustomizable) (*types.IsGuestOsCustomizableResponse, error) { + var reqBody, resBody IsGuestOsCustomizableBody + + reqBody.Req = req + + if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { + return nil, err + } + + return resBody.Res, nil +} + type IsKmsClusterActiveBody struct { Req *types.IsKmsClusterActive `xml:"urn:vim25 IsKmsClusterActive,omitempty"` Res *types.IsKmsClusterActiveResponse `xml:"IsKmsClusterActiveResponse,omitempty"` @@ -11883,6 +12051,26 @@ func ReadNextTasks(ctx context.Context, r soap.RoundTripper, req *types.ReadNext return resBody.Res, nil } +type ReadNextTasksByViewSpecBody struct { + Req *types.ReadNextTasksByViewSpec `xml:"urn:vim25 ReadNextTasksByViewSpec,omitempty"` + Res *types.ReadNextTasksByViewSpecResponse `xml:"ReadNextTasksByViewSpecResponse,omitempty"` + Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` +} + +func (b *ReadNextTasksByViewSpecBody) Fault() *soap.Fault { return b.Fault_ } + +func ReadNextTasksByViewSpec(ctx context.Context, r soap.RoundTripper, req *types.ReadNextTasksByViewSpec) (*types.ReadNextTasksByViewSpecResponse, error) { + var reqBody, resBody ReadNextTasksByViewSpecBody + + reqBody.Req = req + + if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { + return nil, err + } + + return resBody.Res, nil +} + type ReadPreviousEventsBody struct { Req *types.ReadPreviousEvents `xml:"urn:vim25 ReadPreviousEvents,omitempty"` Res *types.ReadPreviousEventsResponse `xml:"ReadPreviousEventsResponse,omitempty"` @@ -12023,6 +12211,26 @@ func RecommissionVsanNode_Task(ctx context.Context, r soap.RoundTripper, req *ty return resBody.Res, nil } +type ReconcileDatastoreInventoryEx_TaskBody struct { + Req *types.ReconcileDatastoreInventoryEx_Task `xml:"urn:vim25 ReconcileDatastoreInventoryEx_Task,omitempty"` + Res *types.ReconcileDatastoreInventoryEx_TaskResponse `xml:"ReconcileDatastoreInventoryEx_TaskResponse,omitempty"` + Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` +} + +func (b *ReconcileDatastoreInventoryEx_TaskBody) Fault() *soap.Fault { return b.Fault_ } + +func ReconcileDatastoreInventoryEx_Task(ctx context.Context, r soap.RoundTripper, req *types.ReconcileDatastoreInventoryEx_Task) (*types.ReconcileDatastoreInventoryEx_TaskResponse, error) { + var reqBody, resBody ReconcileDatastoreInventoryEx_TaskBody + + reqBody.Req = req + + if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { + return nil, err + } + + return resBody.Res, nil +} + type ReconcileDatastoreInventory_TaskBody struct { Req *types.ReconcileDatastoreInventory_Task `xml:"urn:vim25 ReconcileDatastoreInventory_Task,omitempty"` Res *types.ReconcileDatastoreInventory_TaskResponse `xml:"ReconcileDatastoreInventory_TaskResponse,omitempty"` @@ -13623,6 +13831,26 @@ func RemoveSmartCardTrustAnchorByFingerprint(ctx context.Context, r soap.RoundTr return resBody.Res, nil } +type RemoveSmartCardTrustAnchorCertificateBody struct { + Req *types.RemoveSmartCardTrustAnchorCertificate `xml:"urn:vim25 RemoveSmartCardTrustAnchorCertificate,omitempty"` + Res *types.RemoveSmartCardTrustAnchorCertificateResponse `xml:"RemoveSmartCardTrustAnchorCertificateResponse,omitempty"` + Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` +} + +func (b *RemoveSmartCardTrustAnchorCertificateBody) Fault() *soap.Fault { return b.Fault_ } + +func RemoveSmartCardTrustAnchorCertificate(ctx context.Context, r soap.RoundTripper, req *types.RemoveSmartCardTrustAnchorCertificate) (*types.RemoveSmartCardTrustAnchorCertificateResponse, error) { + var reqBody, resBody RemoveSmartCardTrustAnchorCertificateBody + + reqBody.Req = req + + if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { + return nil, err + } + + return resBody.Res, nil +} + type RemoveSnapshot_TaskBody struct { Req *types.RemoveSnapshot_Task `xml:"urn:vim25 RemoveSnapshot_Task,omitempty"` Res *types.RemoveSnapshot_TaskResponse `xml:"RemoveSnapshot_TaskResponse,omitempty"` diff --git a/vendor/github.com/vmware/govmomi/vim25/mo/mo.go b/vendor/github.com/vmware/govmomi/vim25/mo/mo.go index 5b91ae47..3559e8aa 100644 --- a/vendor/github.com/vmware/govmomi/vim25/mo/mo.go +++ b/vendor/github.com/vmware/govmomi/vim25/mo/mo.go @@ -1,18 +1,6 @@ -/* -Copyright (c) 2014-2024 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. -*/ +// © Broadcom. All Rights Reserved. +// The term “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. +// SPDX-License-Identifier: Apache-2.0 package mo diff --git a/vendor/github.com/vmware/govmomi/vim25/soap/client.go b/vendor/github.com/vmware/govmomi/vim25/soap/client.go index d3e9e093..7b4b26ab 100644 --- a/vendor/github.com/vmware/govmomi/vim25/soap/client.go +++ b/vendor/github.com/vmware/govmomi/vim25/soap/client.go @@ -1,5 +1,5 @@ /* -Copyright (c) 2014-2023 VMware, Inc. All Rights Reserved. +Copyright (c) 2014-2024 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. @@ -86,7 +86,11 @@ type Client struct { Types types.Func `json:"types"` UserAgent string `json:"userAgent"` - cookie string + // Cookie returns a value for the SOAP Header.Cookie. + // This SOAP request header is used for authentication by + // API endpoints such as pbm, vslm and sms. + // When nil, no SOAP Header.Cookie is set. + Cookie func() *HeaderElement insecureCookies bool useJSON bool @@ -210,6 +214,16 @@ func (c *Client) NewServiceClient(path string, namespace string) *Client { return c.newServiceClientWithTransport(path, namespace, c.t) } +// SessionCookie returns a SessionCookie with value of the vmware_soap_session http.Cookie. +func (c *Client) SessionCookie() *HeaderElement { + for _, cookie := range c.Jar.Cookies(c.URL()) { + if cookie.Name == SessionCookieName { + return &HeaderElement{Value: cookie.Value} + } + } + return nil +} + func (c *Client) newServiceClientWithTransport(path string, namespace string, t *http.Transport) *Client { vc := c.URL() u, err := url.Parse(path) @@ -234,14 +248,6 @@ func (c *Client) newServiceClientWithTransport(path string, namespace string, t // Copy the cookies client.Client.Jar.SetCookies(u, c.Client.Jar.Cookies(u)) - // Set SOAP Header cookie - for _, cookie := range client.Jar.Cookies(u) { - if cookie.Name == SessionCookieName { - client.cookie = cookie.Value - break - } - } - // Copy any query params (e.g. GOVMOMI_TUNNEL_PROXY_PORT used in testing) client.u.RawQuery = vc.RawQuery @@ -718,8 +724,10 @@ func (c *Client) soapRoundTrip(ctx context.Context, reqBody, resBody HasFault) e h.ID = id } - h.Cookie = c.cookie - if h.Cookie != "" || h.ID != "" || h.Security != nil { + if c.Cookie != nil { + h.Cookie = c.Cookie() + } + if h.Cookie != nil || h.ID != "" || h.Security != nil { reqEnv.Header = &h // XML marshal header only if a field is set } diff --git a/vendor/github.com/vmware/govmomi/vim25/soap/json_client.go b/vendor/github.com/vmware/govmomi/vim25/soap/json_client.go index ca5075de..b5d25b59 100644 --- a/vendor/github.com/vmware/govmomi/vim25/soap/json_client.go +++ b/vendor/github.com/vmware/govmomi/vim25/soap/json_client.go @@ -1,5 +1,5 @@ /* -Copyright (c) 2023-2023 VMware, Inc. All Rights Reserved. +Copyright (c) 2023-2024 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. @@ -71,8 +71,10 @@ func (c *Client) invoke(ctx context.Context, this types.ManagedObjectReference, return err } - if len(c.cookie) != 0 { - req.Header.Add(sessionHeader, c.cookie) + if c.Cookie != nil { + if cookie := c.Cookie(); cookie != nil { + req.Header.Add(sessionHeader, cookie.Value) + } } result, err := getSOAPResultPtr(res) @@ -156,8 +158,10 @@ func isError(statusCode int) bool { // session header. func (c *Client) checkForSessionHeader(resp *http.Response) { sessionKey := resp.Header.Get(sessionHeader) - if len(sessionKey) > 0 { - c.cookie = sessionKey + if sessionKey != "" { + c.Cookie = func() *HeaderElement { + return &HeaderElement{Value: sessionKey} + } } } diff --git a/vendor/github.com/vmware/govmomi/vim25/soap/soap.go b/vendor/github.com/vmware/govmomi/vim25/soap/soap.go index a8dc121b..d7703ae8 100644 --- a/vendor/github.com/vmware/govmomi/vim25/soap/soap.go +++ b/vendor/github.com/vmware/govmomi/vim25/soap/soap.go @@ -1,11 +1,11 @@ /* -Copyright (c) 2014-2018 VMware, Inc. All Rights Reserved. +Copyright (c) 2014-2024 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 +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, @@ -21,12 +21,18 @@ import ( "github.com/vmware/govmomi/vim25/xml" ) +// HeaderElement allows changing the default XMLName (e.g. Cookie's default of vcSessionCookie) +type HeaderElement struct { + XMLName xml.Name + Value string `xml:",chardata"` +} + // Header includes optional soap Header fields. type Header struct { - Action string `xml:"-"` // Action is the 'SOAPAction' HTTP header value. Defaults to "Client.Namespace/Client.Version". - Cookie string `xml:"vcSessionCookie,omitempty"` // Cookie is a vCenter session cookie that can be used with other SDK endpoints (e.g. pbm). - ID string `xml:"operationID,omitempty"` // ID is the operationID used by ESX/vCenter logging for correlation. - Security interface{} `xml:",omitempty"` // Security is used for SAML token authentication and request signing. + Action string `xml:"-"` // Action is the 'SOAPAction' HTTP header value. Defaults to "Client.Namespace/Client.Version". + Cookie *HeaderElement `xml:"vcSessionCookie,omitempty"` // Cookie is a vCenter session cookie that can be used with other SDK endpoints (e.g. pbm, vslm). + ID string `xml:"operationID,omitempty"` // ID is the operationID used by ESX/vCenter logging for correlation. + Security interface{} `xml:",omitempty"` // Security is used for SAML token authentication and request signing. } type Envelope struct { diff --git a/vendor/github.com/vmware/govmomi/vim25/types/deep_copy.go b/vendor/github.com/vmware/govmomi/vim25/types/deep_copy.go new file mode 100644 index 00000000..ca5d99ab --- /dev/null +++ b/vendor/github.com/vmware/govmomi/vim25/types/deep_copy.go @@ -0,0 +1,65 @@ +/* +Copyright (c) 2024-2024 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 ( + "bytes" +) + +// DeepCopyInto creates a deep-copy of src by encoding it to JSON and then +// decoding that into dst. +// Please note, empty slices or maps in src that are set to omitempty will be +// nil in the copied object. +func DeepCopyInto[T AnyType](dst *T, src T) error { + var w bytes.Buffer + e := NewJSONEncoder(&w) + if err := e.Encode(src); err != nil { + return err + } + d := NewJSONDecoder(&w) + if err := d.Decode(dst); err != nil { + return err + } + return nil +} + +// MustDeepCopyInto panics if DeepCopyInto returns an error. +func MustDeepCopyInto[T AnyType](dst *T, src T) error { + if err := DeepCopyInto(dst, src); err != nil { + panic(err) + } + return nil +} + +// DeepCopy creates a deep-copy of src by encoding it to JSON and then decoding +// that into a new instance of T. +// Please note, empty slices or maps in src that are set to omitempty will be +// nil in the copied object. +func DeepCopy[T AnyType](src T) (T, error) { + var dst T + err := DeepCopyInto(&dst, src) + return dst, err +} + +// MustDeepCopy panics if DeepCopy returns an error. +func MustDeepCopy[T AnyType](src T) T { + dst, err := DeepCopy(src) + if err != nil { + panic(err) + } + return dst +} diff --git a/vendor/github.com/vmware/govmomi/vim25/types/enum.go b/vendor/github.com/vmware/govmomi/vim25/types/enum.go index ea07f156..e5cd5799 100644 --- a/vendor/github.com/vmware/govmomi/vim25/types/enum.go +++ b/vendor/github.com/vmware/govmomi/vim25/types/enum.go @@ -1,18 +1,6 @@ -/* -Copyright (c) 2014-2024 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. -*/ +// © Broadcom. All Rights Reserved. +// The term “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. +// SPDX-License-Identifier: Apache-2.0 package types @@ -588,6 +576,8 @@ const ( CannotUseNetworkReasonNetworkUnderMaintenance = CannotUseNetworkReason("NetworkUnderMaintenance") // Source and destination networks do not have same ENS(Enhanced Network Stack) mode CannotUseNetworkReasonMismatchedEnsMode = CannotUseNetworkReason("MismatchedEnsMode") + // Source and destination networks do not have the same real-time flag + CannotUseNetworkReasonMismatchedRealTimeDvs = CannotUseNetworkReason("MismatchedRealTimeDvs") ) func (e CannotUseNetworkReason) Values() []CannotUseNetworkReason { @@ -598,6 +588,7 @@ func (e CannotUseNetworkReason) Values() []CannotUseNetworkReason { CannotUseNetworkReasonVMotionToUnsupportedNetworkType, CannotUseNetworkReasonNetworkUnderMaintenance, CannotUseNetworkReasonMismatchedEnsMode, + CannotUseNetworkReasonMismatchedRealTimeDvs, } } @@ -607,6 +598,9 @@ func (e CannotUseNetworkReason) Strings() []string { func init() { t["CannotUseNetworkReason"] = reflect.TypeOf((*CannotUseNetworkReason)(nil)).Elem() + minAPIVersionForEnumValue["CannotUseNetworkReason"] = map[string]string{ + "MismatchedRealTimeDvs": "8.0.3.1", + } } // The types of tests which can requested by any of the methods in either @@ -1578,6 +1572,29 @@ func init() { t["ComputeResourceHostSPBMLicenseInfoHostSPBMLicenseState"] = reflect.TypeOf((*ComputeResourceHostSPBMLicenseInfoHostSPBMLicenseState)(nil)).Elem() } +type ComputeResourceNetworkBootMode string + +const ( + ComputeResourceNetworkBootModeBootstrap = ComputeResourceNetworkBootMode("bootstrap") + ComputeResourceNetworkBootModeStateless = ComputeResourceNetworkBootMode("stateless") +) + +func (e ComputeResourceNetworkBootMode) Values() []ComputeResourceNetworkBootMode { + return []ComputeResourceNetworkBootMode{ + ComputeResourceNetworkBootModeBootstrap, + ComputeResourceNetworkBootModeStateless, + } +} + +func (e ComputeResourceNetworkBootMode) Strings() []string { + return EnumValuesAsStrings(e.Values()) +} + +func init() { + t["ComputeResourceNetworkBootMode"] = reflect.TypeOf((*ComputeResourceNetworkBootMode)(nil)).Elem() + minAPIVersionForType["ComputeResourceNetworkBootMode"] = "9.0.0.0" +} + // Config spec operation type. type ConfigSpecOperation string @@ -1650,6 +1667,10 @@ const ( CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonKeyStateManagedByNKP = CryptoManagerKmipCryptoKeyStatusKeyUnavailableReason("KeyStateManagedByNKP") // No permission to access key provider CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonNoPermissionToAccessKeyProvider = CryptoManagerKmipCryptoKeyStatusKeyUnavailableReason("NoPermissionToAccessKeyProvider") + // Wrapping Key not found in KMS + CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonWrappingKeyMissingInKMS = CryptoManagerKmipCryptoKeyStatusKeyUnavailableReason("WrappingKeyMissingInKMS") + // Wrapping Key not active or enabled + CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonWrappingKeyNotActiveOrEnabled = CryptoManagerKmipCryptoKeyStatusKeyUnavailableReason("WrappingKeyNotActiveOrEnabled") ) func (e CryptoManagerKmipCryptoKeyStatusKeyUnavailableReason) Values() []CryptoManagerKmipCryptoKeyStatusKeyUnavailableReason { @@ -1662,6 +1683,8 @@ func (e CryptoManagerKmipCryptoKeyStatusKeyUnavailableReason) Values() []CryptoM CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonKeyStateManagedByTrustAuthority, CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonKeyStateManagedByNKP, CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonNoPermissionToAccessKeyProvider, + CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonWrappingKeyMissingInKMS, + CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonWrappingKeyNotActiveOrEnabled, } } @@ -1674,6 +1697,8 @@ func init() { minAPIVersionForEnumValue["CryptoManagerKmipCryptoKeyStatusKeyUnavailableReason"] = map[string]string{ "KeyStateManagedByNKP": "8.0.3.0", "NoPermissionToAccessKeyProvider": "8.0.3.0", + "WrappingKeyMissingInKMS": "9.0.0.0", + "WrappingKeyNotActiveOrEnabled": "9.0.0.0", } } @@ -2075,6 +2100,35 @@ func init() { t["DatastoreAccessible"] = reflect.TypeOf((*DatastoreAccessible)(nil)).Elem() } +// The type of the sector size, such as, datastore and virtual disk, +type DatastoreSectorFormat string + +const ( + // 512 native sector size disk. + DatastoreSectorFormatNative_512 = DatastoreSectorFormat("native_512") + // 4K sector size disk in 512 emulation mode. + DatastoreSectorFormatEmulated_512 = DatastoreSectorFormat("emulated_512") + // 4K native sector size disk. + DatastoreSectorFormatNative_4k = DatastoreSectorFormat("native_4k") +) + +func (e DatastoreSectorFormat) Values() []DatastoreSectorFormat { + return []DatastoreSectorFormat{ + DatastoreSectorFormatNative_512, + DatastoreSectorFormatEmulated_512, + DatastoreSectorFormatNative_4k, + } +} + +func (e DatastoreSectorFormat) Strings() []string { + return EnumValuesAsStrings(e.Values()) +} + +func init() { + t["DatastoreSectorFormat"] = reflect.TypeOf((*DatastoreSectorFormat)(nil)).Elem() + minAPIVersionForType["DatastoreSectorFormat"] = "9.0.0.0" +} + // Defines the current maintenance mode state of the datastore. type DatastoreSummaryMaintenanceModeState string @@ -2471,6 +2525,8 @@ const ( DistributedVirtualSwitchHostInfrastructureTrafficClassBackupNfc = DistributedVirtualSwitchHostInfrastructureTrafficClass("backupNfc") // vSphere NVMETCP Traffic DistributedVirtualSwitchHostInfrastructureTrafficClassNvmetcp = DistributedVirtualSwitchHostInfrastructureTrafficClass("nvmetcp") + // vSphere Provisioning Traffic + DistributedVirtualSwitchHostInfrastructureTrafficClassProvisioning = DistributedVirtualSwitchHostInfrastructureTrafficClass("provisioning") ) func (e DistributedVirtualSwitchHostInfrastructureTrafficClass) Values() []DistributedVirtualSwitchHostInfrastructureTrafficClass { @@ -2486,6 +2542,7 @@ func (e DistributedVirtualSwitchHostInfrastructureTrafficClass) Values() []Distr DistributedVirtualSwitchHostInfrastructureTrafficClassVdp, DistributedVirtualSwitchHostInfrastructureTrafficClassBackupNfc, DistributedVirtualSwitchHostInfrastructureTrafficClassNvmetcp, + DistributedVirtualSwitchHostInfrastructureTrafficClassProvisioning, } } @@ -2496,8 +2553,9 @@ func (e DistributedVirtualSwitchHostInfrastructureTrafficClass) Strings() []stri func init() { t["DistributedVirtualSwitchHostInfrastructureTrafficClass"] = reflect.TypeOf((*DistributedVirtualSwitchHostInfrastructureTrafficClass)(nil)).Elem() minAPIVersionForEnumValue["DistributedVirtualSwitchHostInfrastructureTrafficClass"] = map[string]string{ - "backupNfc": "7.0.1.0", - "nvmetcp": "7.0.3.0", + "backupNfc": "7.0.1.0", + "nvmetcp": "7.0.3.0", + "provisioning": "9.0.0.0", } } @@ -3288,6 +3346,89 @@ func init() { t["FolderDesiredHostState"] = reflect.TypeOf((*FolderDesiredHostState)(nil)).Elem() } +// Supported types of externally managed folder. +// +// NSX Virtual Private Clouds(VPCs) is an abstraction layer that simplifies +// setting up self-contained virtual private cloud networks within an NSX +// project to consume networking and security services in a self-service +// consumption model. It contains multiple subnets which represents an +// independent layer 2 broadcast domain. +// vCenter users can manage (create, update, delete) VPC and subnet under +// `VPC_ROOT` folder. Requests are forwarded to NSX, and the VPCs +// and subnets in NSX are realized as `VPC` and `SUBNET` folder +// in vCenter. +// A project in NSX is analogous to a tenant. NSX user can create VPC, segment, +// and subnet within a project. These objects are represented as +// `PROJECT`, `VPC`, `SEGMENT`, and `SUBNET` folder +type FolderExternallyManagedFolderType string + +const ( + // The root folder of `PROJECT` folders. + // + // It is a child of the network folder of a data center and + // may contain multiple `PROJECT` folders. + FolderExternallyManagedFolderTypePROJECT_ROOT = FolderExternallyManagedFolderType("PROJECT_ROOT") + // The folder representing a project in NSX. + // + // It is a child of the `PROJECT_ROOT` folder. + // A project folder can contain multiple `VPC`, + // and `SEGMENT` folders. + FolderExternallyManagedFolderTypePROJECT = FolderExternallyManagedFolderType("PROJECT") + // The folder containing VPC and subnet that can be managed by vCenter. + // + // It is a child of the network folder of a data center. + // It may contain multiple `VPC` folders. + FolderExternallyManagedFolderTypeVPC_ROOT = FolderExternallyManagedFolderType("VPC_ROOT") + // The folder representing a VPC in NSX. + // + // It is a child of the `VPC_ROOT` folder or the `PROJECT` + // folder. + // It may contain multiple `SUBNET` folders. + FolderExternallyManagedFolderTypeVPC = FolderExternallyManagedFolderType("VPC") + // The folder representing a subnet in NSX. + // + // It is a child of the `VPC` folder. + FolderExternallyManagedFolderTypeSUBNET = FolderExternallyManagedFolderType("SUBNET") + // The folder representing a segment in NSX. + // + // It is a child of the `PROJECT` folder. + FolderExternallyManagedFolderTypeSEGMENT = FolderExternallyManagedFolderType("SEGMENT") + // The folder representing a vSphere IaaS Control Plane Supervisor. + // + // It is a VM\_TYPE folder and child of vSphere Namespaces Root folder. + // It may contain multiple namespace associated folder, i.e., folder with + // `Folder.namespace` property set and vSphere IaaS Control Plane + // Virtual Machines. + FolderExternallyManagedFolderTypeSUPERVISOR = FolderExternallyManagedFolderType("SUPERVISOR") + // The folder containing vSphere Pods. + // + // It is a child of namespace associated folder, i.e., folder with + // `Folder.namespace` property set and may contain vSphere Pods. + FolderExternallyManagedFolderTypeVSPHERE_POD = FolderExternallyManagedFolderType("VSPHERE_POD") +) + +func (e FolderExternallyManagedFolderType) Values() []FolderExternallyManagedFolderType { + return []FolderExternallyManagedFolderType{ + FolderExternallyManagedFolderTypePROJECT_ROOT, + FolderExternallyManagedFolderTypePROJECT, + FolderExternallyManagedFolderTypeVPC_ROOT, + FolderExternallyManagedFolderTypeVPC, + FolderExternallyManagedFolderTypeSUBNET, + FolderExternallyManagedFolderTypeSEGMENT, + FolderExternallyManagedFolderTypeSUPERVISOR, + FolderExternallyManagedFolderTypeVSPHERE_POD, + } +} + +func (e FolderExternallyManagedFolderType) Strings() []string { + return EnumValuesAsStrings(e.Values()) +} + +func init() { + t["FolderExternallyManagedFolderType"] = reflect.TypeOf((*FolderExternallyManagedFolderType)(nil)).Elem() + minAPIVersionForType["FolderExternallyManagedFolderType"] = "9.0.0.0" +} + // HostSelectionType defines how the host was selected type FtIssuesOnHostHostSelectionType string @@ -3980,6 +4121,31 @@ func init() { t["HostConfigChangeOperation"] = reflect.TypeOf((*HostConfigChangeOperation)(nil)).Elem() } +type HostConfigChangeOwner string + +const ( + // The owner is NSX (Network Virtualization and Security). + HostConfigChangeOwnerNSX = HostConfigChangeOwner("NSX") + // The owner is vSAN (VMware Virtual Storage Area Network). + HostConfigChangeOwnerVSAN = HostConfigChangeOwner("VSAN") +) + +func (e HostConfigChangeOwner) Values() []HostConfigChangeOwner { + return []HostConfigChangeOwner{ + HostConfigChangeOwnerNSX, + HostConfigChangeOwnerVSAN, + } +} + +func (e HostConfigChangeOwner) Strings() []string { + return EnumValuesAsStrings(e.Values()) +} + +func init() { + t["HostConfigChangeOwner"] = reflect.TypeOf((*HostConfigChangeOwner)(nil)).Elem() + minAPIVersionForType["HostConfigChangeOwner"] = "9.0.0.0" +} + type HostCpuPackageVendor string const ( @@ -5654,6 +5820,13 @@ const ( // This // ensures the integrity of the NFS file data. HostNasVolumeSecurityTypeSEC_KRB5I = HostNasVolumeSecurityType("SEC_KRB5I") + // Extends `SEC_KRB5I` to send and receive encrypted NFS packets over + // the wire. + // + // `SEC_KRB5P` provides data privacy in addition to data + // integrity for NFS files. To date, SEC\_KRB5P provides the highest form of + // security for NFS payload. + HostNasVolumeSecurityTypeSEC_KRB5P = HostNasVolumeSecurityType("SEC_KRB5P") ) func (e HostNasVolumeSecurityType) Values() []HostNasVolumeSecurityType { @@ -5661,6 +5834,7 @@ func (e HostNasVolumeSecurityType) Values() []HostNasVolumeSecurityType { HostNasVolumeSecurityTypeAUTH_SYS, HostNasVolumeSecurityTypeSEC_KRB5, HostNasVolumeSecurityTypeSEC_KRB5I, + HostNasVolumeSecurityTypeSEC_KRB5P, } } @@ -5670,6 +5844,9 @@ func (e HostNasVolumeSecurityType) Strings() []string { func init() { t["HostNasVolumeSecurityType"] = reflect.TypeOf((*HostNasVolumeSecurityType)(nil)).Elem() + minAPIVersionForEnumValue["HostNasVolumeSecurityType"] = map[string]string{ + "SEC_KRB5P": "9.0.0.0", + } } // Define TCP congestion control algorithm used by an instance @@ -7111,6 +7288,33 @@ func init() { t["HostSystemRemediationStateState"] = reflect.TypeOf((*HostSystemRemediationStateState)(nil)).Elem() } +type HostTdxInfoTdxState string + +const ( + HostTdxInfoTdxStateInitializing = HostTdxInfoTdxState("initializing") + HostTdxInfoTdxStateInitialized = HostTdxInfoTdxState("initialized") + HostTdxInfoTdxStateConfigured = HostTdxInfoTdxState("configured") + HostTdxInfoTdxStateReady = HostTdxInfoTdxState("ready") +) + +func (e HostTdxInfoTdxState) Values() []HostTdxInfoTdxState { + return []HostTdxInfoTdxState{ + HostTdxInfoTdxStateInitializing, + HostTdxInfoTdxStateInitialized, + HostTdxInfoTdxStateConfigured, + HostTdxInfoTdxStateReady, + } +} + +func (e HostTdxInfoTdxState) Strings() []string { + return EnumValuesAsStrings(e.Values()) +} + +func init() { + t["HostTdxInfoTdxState"] = reflect.TypeOf((*HostTdxInfoTdxState)(nil)).Elem() + minAPIVersionForType["HostTdxInfoTdxState"] = "9.0.0.0" +} + // Status constants of TPM attestation. type HostTpmAttestationInfoAcceptanceStatus string @@ -7280,6 +7484,8 @@ const ( HostVirtualNicManagerNicTypeNvmeTcp = HostVirtualNicManagerNicType("nvmeTcp") // The VirtualNic is used for NVMe over RDMA traffic. HostVirtualNicManagerNicTypeNvmeRdma = HostVirtualNicManagerNicType("nvmeRdma") + // The VirtualNic is used for external vSAN traffic. + HostVirtualNicManagerNicTypeVsanExternal = HostVirtualNicManagerNicType("vsanExternal") ) func (e HostVirtualNicManagerNicType) Values() []HostVirtualNicManagerNicType { @@ -7296,6 +7502,7 @@ func (e HostVirtualNicManagerNicType) Values() []HostVirtualNicManagerNicType { HostVirtualNicManagerNicTypePtp, HostVirtualNicManagerNicTypeNvmeTcp, HostVirtualNicManagerNicTypeNvmeRdma, + HostVirtualNicManagerNicTypeVsanExternal, } } @@ -7306,8 +7513,9 @@ func (e HostVirtualNicManagerNicType) Strings() []string { func init() { t["HostVirtualNicManagerNicType"] = reflect.TypeOf((*HostVirtualNicManagerNicType)(nil)).Elem() minAPIVersionForEnumValue["HostVirtualNicManagerNicType"] = map[string]string{ - "nvmeTcp": "7.0.3.0", - "nvmeRdma": "7.0.3.0", + "nvmeTcp": "7.0.3.0", + "nvmeRdma": "7.0.3.0", + "vsanExternal": "9.0.0.0", } } @@ -7689,6 +7897,36 @@ func init() { t["IscsiPortInfoPathStatus"] = reflect.TypeOf((*IscsiPortInfoPathStatus)(nil)).Elem() } +type KmipClusterInfoKeyType string + +const ( + // Key is fetched directly from KMS. + KmipClusterInfoKeyTypeRawKey = KmipClusterInfoKeyType("rawKey") + // Key is wrapped by a wrapping key from KMS. + // + // The wrapping key details are specified in + // `KmipClusterInfoWrappingKeyIdKeyInfo` + // or + // `KmipClusterInfoWrappingRotationIntervalKeyInfo`. + KmipClusterInfoKeyTypeWrappedKey = KmipClusterInfoKeyType("wrappedKey") +) + +func (e KmipClusterInfoKeyType) Values() []KmipClusterInfoKeyType { + return []KmipClusterInfoKeyType{ + KmipClusterInfoKeyTypeRawKey, + KmipClusterInfoKeyTypeWrappedKey, + } +} + +func (e KmipClusterInfoKeyType) Strings() []string { + return EnumValuesAsStrings(e.Values()) +} + +func init() { + t["KmipClusterInfoKeyType"] = reflect.TypeOf((*KmipClusterInfoKeyType)(nil)).Elem() + minAPIVersionForType["KmipClusterInfoKeyType"] = "9.0.0.0" +} + // Key provider management type. type KmipClusterInfoKmsManagementType string @@ -8180,6 +8418,302 @@ func init() { t["ManagedEntityStatus"] = reflect.TypeOf((*ManagedEntityStatus)(nil)).Elem() } +type ManagedObjectTypes string + +const ( + ManagedObjectTypesPropertyCollector = ManagedObjectTypes("PropertyCollector") + ManagedObjectTypesPropertyFilter = ManagedObjectTypes("PropertyFilter") + ManagedObjectTypesAuthorizationManager = ManagedObjectTypes("AuthorizationManager") + ManagedObjectTypesCertificateManager = ManagedObjectTypes("CertificateManager") + ManagedObjectTypesClusterComputeResource = ManagedObjectTypes("ClusterComputeResource") + ManagedObjectTypesComputeResource = ManagedObjectTypes("ComputeResource") + ManagedObjectTypesCustomFieldsManager = ManagedObjectTypes("CustomFieldsManager") + ManagedObjectTypesCustomizationSpecManager = ManagedObjectTypes("CustomizationSpecManager") + ManagedObjectTypesDatacenter = ManagedObjectTypes("Datacenter") + ManagedObjectTypesDatastore = ManagedObjectTypes("Datastore") + ManagedObjectTypesDatastoreNamespaceManager = ManagedObjectTypes("DatastoreNamespaceManager") + ManagedObjectTypesDiagnosticManager = ManagedObjectTypes("DiagnosticManager") + ManagedObjectTypesDirectPathProfileManager = ManagedObjectTypes("DirectPathProfileManager") + ManagedObjectTypesDistributedVirtualSwitch = ManagedObjectTypes("DistributedVirtualSwitch") + ManagedObjectTypesEnvironmentBrowser = ManagedObjectTypes("EnvironmentBrowser") + ManagedObjectTypesExtensibleManagedObject = ManagedObjectTypes("ExtensibleManagedObject") + ManagedObjectTypesExtensionManager = ManagedObjectTypes("ExtensionManager") + ManagedObjectTypesFileManager = ManagedObjectTypes("FileManager") + ManagedObjectTypesFolder = ManagedObjectTypes("Folder") + ManagedObjectTypesHealthUpdateManager = ManagedObjectTypes("HealthUpdateManager") + ManagedObjectTypesHistoryCollector = ManagedObjectTypes("HistoryCollector") + ManagedObjectTypesHostSystem = ManagedObjectTypes("HostSystem") + ManagedObjectTypesHttpNfcLease = ManagedObjectTypes("HttpNfcLease") + ManagedObjectTypesIoFilterManager = ManagedObjectTypes("IoFilterManager") + ManagedObjectTypesIpPoolManager = ManagedObjectTypes("IpPoolManager") + ManagedObjectTypesLicenseAssignmentManager = ManagedObjectTypes("LicenseAssignmentManager") + ManagedObjectTypesLicenseManager = ManagedObjectTypes("LicenseManager") + ManagedObjectTypesLocalizationManager = ManagedObjectTypes("LocalizationManager") + ManagedObjectTypesManagedEntity = ManagedObjectTypes("ManagedEntity") + ManagedObjectTypesNetwork = ManagedObjectTypes("Network") + ManagedObjectTypesOpaqueNetwork = ManagedObjectTypes("OpaqueNetwork") + ManagedObjectTypesOverheadMemoryManager = ManagedObjectTypes("OverheadMemoryManager") + ManagedObjectTypesOvfManager = ManagedObjectTypes("OvfManager") + ManagedObjectTypesPerformanceManager = ManagedObjectTypes("PerformanceManager") + ManagedObjectTypesResourcePlanningManager = ManagedObjectTypes("ResourcePlanningManager") + ManagedObjectTypesResourcePool = ManagedObjectTypes("ResourcePool") + ManagedObjectTypesSearchIndex = ManagedObjectTypes("SearchIndex") + ManagedObjectTypesServiceInstance = ManagedObjectTypes("ServiceInstance") + ManagedObjectTypesServiceManager = ManagedObjectTypes("ServiceManager") + ManagedObjectTypesSessionManager = ManagedObjectTypes("SessionManager") + ManagedObjectTypesSimpleCommand = ManagedObjectTypes("SimpleCommand") + ManagedObjectTypesSiteInfoManager = ManagedObjectTypes("SiteInfoManager") + ManagedObjectTypesStoragePod = ManagedObjectTypes("StoragePod") + ManagedObjectTypesStorageQueryManager = ManagedObjectTypes("StorageQueryManager") + ManagedObjectTypesStorageResourceManager = ManagedObjectTypes("StorageResourceManager") + ManagedObjectTypesTask = ManagedObjectTypes("Task") + ManagedObjectTypesTaskHistoryCollector = ManagedObjectTypes("TaskHistoryCollector") + ManagedObjectTypesTaskManager = ManagedObjectTypes("TaskManager") + ManagedObjectTypesUserDirectory = ManagedObjectTypes("UserDirectory") + ManagedObjectTypesVirtualApp = ManagedObjectTypes("VirtualApp") + ManagedObjectTypesVirtualDiskManager = ManagedObjectTypes("VirtualDiskManager") + ManagedObjectTypesVirtualMachine = ManagedObjectTypes("VirtualMachine") + ManagedObjectTypesVirtualizationManager = ManagedObjectTypes("VirtualizationManager") + ManagedObjectTypesVsanUpgradeSystem = ManagedObjectTypes("VsanUpgradeSystem") + ManagedObjectTypesAlarm = ManagedObjectTypes("Alarm") + ManagedObjectTypesAlarmManager = ManagedObjectTypes("AlarmManager") + ManagedObjectTypesClusterEVCManager = ManagedObjectTypes("ClusterEVCManager") + ManagedObjectTypesDistributedVirtualPortgroup = ManagedObjectTypes("DistributedVirtualPortgroup") + ManagedObjectTypesDistributedVirtualSwitchManager = ManagedObjectTypes("DistributedVirtualSwitchManager") + ManagedObjectTypesVmwareDistributedVirtualSwitch = ManagedObjectTypes("VmwareDistributedVirtualSwitch") + ManagedObjectTypesCryptoManager = ManagedObjectTypes("CryptoManager") + ManagedObjectTypesCryptoManagerHost = ManagedObjectTypes("CryptoManagerHost") + ManagedObjectTypesCryptoManagerHostKMS = ManagedObjectTypes("CryptoManagerHostKMS") + ManagedObjectTypesCryptoManagerKmip = ManagedObjectTypes("CryptoManagerKmip") + ManagedObjectTypesEventHistoryCollector = ManagedObjectTypes("EventHistoryCollector") + ManagedObjectTypesEventManager = ManagedObjectTypes("EventManager") + ManagedObjectTypesHostActiveDirectoryAuthentication = ManagedObjectTypes("HostActiveDirectoryAuthentication") + ManagedObjectTypesHostAssignableHardwareManager = ManagedObjectTypes("HostAssignableHardwareManager") + ManagedObjectTypesHostAuthenticationManager = ManagedObjectTypes("HostAuthenticationManager") + ManagedObjectTypesHostAuthenticationStore = ManagedObjectTypes("HostAuthenticationStore") + ManagedObjectTypesHostAutoStartManager = ManagedObjectTypes("HostAutoStartManager") + ManagedObjectTypesHostBootDeviceSystem = ManagedObjectTypes("HostBootDeviceSystem") + ManagedObjectTypesHostCacheConfigurationManager = ManagedObjectTypes("HostCacheConfigurationManager") + ManagedObjectTypesHostCertificateManager = ManagedObjectTypes("HostCertificateManager") + ManagedObjectTypesHostCpuSchedulerSystem = ManagedObjectTypes("HostCpuSchedulerSystem") + ManagedObjectTypesHostDatastoreBrowser = ManagedObjectTypes("HostDatastoreBrowser") + ManagedObjectTypesHostDatastoreSystem = ManagedObjectTypes("HostDatastoreSystem") + ManagedObjectTypesHostDateTimeSystem = ManagedObjectTypes("HostDateTimeSystem") + ManagedObjectTypesHostDiagnosticSystem = ManagedObjectTypes("HostDiagnosticSystem") + ManagedObjectTypesHostDirectoryStore = ManagedObjectTypes("HostDirectoryStore") + ManagedObjectTypesHostEsxAgentHostManager = ManagedObjectTypes("HostEsxAgentHostManager") + ManagedObjectTypesHostFirewallSystem = ManagedObjectTypes("HostFirewallSystem") + ManagedObjectTypesHostFirmwareSystem = ManagedObjectTypes("HostFirmwareSystem") + ManagedObjectTypesHostGraphicsManager = ManagedObjectTypes("HostGraphicsManager") + ManagedObjectTypesHostHealthStatusSystem = ManagedObjectTypes("HostHealthStatusSystem") + ManagedObjectTypesHostAccessManager = ManagedObjectTypes("HostAccessManager") + ManagedObjectTypesHostImageConfigManager = ManagedObjectTypes("HostImageConfigManager") + ManagedObjectTypesIscsiManager = ManagedObjectTypes("IscsiManager") + ManagedObjectTypesHostKernelModuleSystem = ManagedObjectTypes("HostKernelModuleSystem") + ManagedObjectTypesHostLocalAccountManager = ManagedObjectTypes("HostLocalAccountManager") + ManagedObjectTypesHostLocalAuthentication = ManagedObjectTypes("HostLocalAuthentication") + ManagedObjectTypesHostMemorySystem = ManagedObjectTypes("HostMemorySystem") + ManagedObjectTypesMessageBusProxy = ManagedObjectTypes("MessageBusProxy") + ManagedObjectTypesHostNetworkSystem = ManagedObjectTypes("HostNetworkSystem") + ManagedObjectTypesHostNvdimmSystem = ManagedObjectTypes("HostNvdimmSystem") + ManagedObjectTypesHostPatchManager = ManagedObjectTypes("HostPatchManager") + ManagedObjectTypesHostPciPassthruSystem = ManagedObjectTypes("HostPciPassthruSystem") + ManagedObjectTypesHostPowerSystem = ManagedObjectTypes("HostPowerSystem") + ManagedObjectTypesHostServiceSystem = ManagedObjectTypes("HostServiceSystem") + ManagedObjectTypesHostSnmpSystem = ManagedObjectTypes("HostSnmpSystem") + ManagedObjectTypesHostStorageSystem = ManagedObjectTypes("HostStorageSystem") + ManagedObjectTypesHostVFlashManager = ManagedObjectTypes("HostVFlashManager") + ManagedObjectTypesHostVMotionSystem = ManagedObjectTypes("HostVMotionSystem") + ManagedObjectTypesHostVirtualNicManager = ManagedObjectTypes("HostVirtualNicManager") + ManagedObjectTypesHostVsanInternalSystem = ManagedObjectTypes("HostVsanInternalSystem") + ManagedObjectTypesHostVsanSystem = ManagedObjectTypes("HostVsanSystem") + ManagedObjectTypesOptionManager = ManagedObjectTypes("OptionManager") + ManagedObjectTypesProfileComplianceManager = ManagedObjectTypes("ProfileComplianceManager") + ManagedObjectTypesProfile = ManagedObjectTypes("Profile") + ManagedObjectTypesProfileManager = ManagedObjectTypes("ProfileManager") + ManagedObjectTypesClusterProfile = ManagedObjectTypes("ClusterProfile") + ManagedObjectTypesClusterProfileManager = ManagedObjectTypes("ClusterProfileManager") + ManagedObjectTypesHostProfile = ManagedObjectTypes("HostProfile") + ManagedObjectTypesHostSpecificationManager = ManagedObjectTypes("HostSpecificationManager") + ManagedObjectTypesHostProfileManager = ManagedObjectTypes("HostProfileManager") + ManagedObjectTypesScheduledTask = ManagedObjectTypes("ScheduledTask") + ManagedObjectTypesScheduledTaskManager = ManagedObjectTypes("ScheduledTaskManager") + ManagedObjectTypesTenantTenantManager = ManagedObjectTypes("TenantTenantManager") + ManagedObjectTypesFailoverClusterConfigurator = ManagedObjectTypes("FailoverClusterConfigurator") + ManagedObjectTypesFailoverClusterManager = ManagedObjectTypes("FailoverClusterManager") + ManagedObjectTypesContainerView = ManagedObjectTypes("ContainerView") + ManagedObjectTypesInventoryView = ManagedObjectTypes("InventoryView") + ManagedObjectTypesListView = ManagedObjectTypes("ListView") + ManagedObjectTypesManagedObjectView = ManagedObjectTypes("ManagedObjectView") + ManagedObjectTypesView = ManagedObjectTypes("View") + ManagedObjectTypesViewManager = ManagedObjectTypes("ViewManager") + ManagedObjectTypesVirtualMachineGuestCustomizationManager = ManagedObjectTypes("VirtualMachineGuestCustomizationManager") + ManagedObjectTypesVirtualMachineSnapshot = ManagedObjectTypes("VirtualMachineSnapshot") + ManagedObjectTypesVirtualMachineCompatibilityChecker = ManagedObjectTypes("VirtualMachineCompatibilityChecker") + ManagedObjectTypesVirtualMachineProvisioningChecker = ManagedObjectTypes("VirtualMachineProvisioningChecker") + ManagedObjectTypesGuestAliasManager = ManagedObjectTypes("GuestAliasManager") + ManagedObjectTypesGuestAuthManager = ManagedObjectTypes("GuestAuthManager") + ManagedObjectTypesGuestFileManager = ManagedObjectTypes("GuestFileManager") + ManagedObjectTypesGuestOperationsManager = ManagedObjectTypes("GuestOperationsManager") + ManagedObjectTypesGuestProcessManager = ManagedObjectTypes("GuestProcessManager") + ManagedObjectTypesGuestWindowsRegistryManager = ManagedObjectTypes("GuestWindowsRegistryManager") + ManagedObjectTypesVStorageObjectManagerBase = ManagedObjectTypes("VStorageObjectManagerBase") + ManagedObjectTypesHostVStorageObjectManager = ManagedObjectTypes("HostVStorageObjectManager") + ManagedObjectTypesVcenterVStorageObjectManager = ManagedObjectTypes("VcenterVStorageObjectManager") +) + +func (e ManagedObjectTypes) Values() []ManagedObjectTypes { + return []ManagedObjectTypes{ + ManagedObjectTypesPropertyCollector, + ManagedObjectTypesPropertyFilter, + ManagedObjectTypesAuthorizationManager, + ManagedObjectTypesCertificateManager, + ManagedObjectTypesClusterComputeResource, + ManagedObjectTypesComputeResource, + ManagedObjectTypesCustomFieldsManager, + ManagedObjectTypesCustomizationSpecManager, + ManagedObjectTypesDatacenter, + ManagedObjectTypesDatastore, + ManagedObjectTypesDatastoreNamespaceManager, + ManagedObjectTypesDiagnosticManager, + ManagedObjectTypesDirectPathProfileManager, + ManagedObjectTypesDistributedVirtualSwitch, + ManagedObjectTypesEnvironmentBrowser, + ManagedObjectTypesExtensibleManagedObject, + ManagedObjectTypesExtensionManager, + ManagedObjectTypesFileManager, + ManagedObjectTypesFolder, + ManagedObjectTypesHealthUpdateManager, + ManagedObjectTypesHistoryCollector, + ManagedObjectTypesHostSystem, + ManagedObjectTypesHttpNfcLease, + ManagedObjectTypesIoFilterManager, + ManagedObjectTypesIpPoolManager, + ManagedObjectTypesLicenseAssignmentManager, + ManagedObjectTypesLicenseManager, + ManagedObjectTypesLocalizationManager, + ManagedObjectTypesManagedEntity, + ManagedObjectTypesNetwork, + ManagedObjectTypesOpaqueNetwork, + ManagedObjectTypesOverheadMemoryManager, + ManagedObjectTypesOvfManager, + ManagedObjectTypesPerformanceManager, + ManagedObjectTypesResourcePlanningManager, + ManagedObjectTypesResourcePool, + ManagedObjectTypesSearchIndex, + ManagedObjectTypesServiceInstance, + ManagedObjectTypesServiceManager, + ManagedObjectTypesSessionManager, + ManagedObjectTypesSimpleCommand, + ManagedObjectTypesSiteInfoManager, + ManagedObjectTypesStoragePod, + ManagedObjectTypesStorageQueryManager, + ManagedObjectTypesStorageResourceManager, + ManagedObjectTypesTask, + ManagedObjectTypesTaskHistoryCollector, + ManagedObjectTypesTaskManager, + ManagedObjectTypesUserDirectory, + ManagedObjectTypesVirtualApp, + ManagedObjectTypesVirtualDiskManager, + ManagedObjectTypesVirtualMachine, + ManagedObjectTypesVirtualizationManager, + ManagedObjectTypesVsanUpgradeSystem, + ManagedObjectTypesAlarm, + ManagedObjectTypesAlarmManager, + ManagedObjectTypesClusterEVCManager, + ManagedObjectTypesDistributedVirtualPortgroup, + ManagedObjectTypesDistributedVirtualSwitchManager, + ManagedObjectTypesVmwareDistributedVirtualSwitch, + ManagedObjectTypesCryptoManager, + ManagedObjectTypesCryptoManagerHost, + ManagedObjectTypesCryptoManagerHostKMS, + ManagedObjectTypesCryptoManagerKmip, + ManagedObjectTypesEventHistoryCollector, + ManagedObjectTypesEventManager, + ManagedObjectTypesHostActiveDirectoryAuthentication, + ManagedObjectTypesHostAssignableHardwareManager, + ManagedObjectTypesHostAuthenticationManager, + ManagedObjectTypesHostAuthenticationStore, + ManagedObjectTypesHostAutoStartManager, + ManagedObjectTypesHostBootDeviceSystem, + ManagedObjectTypesHostCacheConfigurationManager, + ManagedObjectTypesHostCertificateManager, + ManagedObjectTypesHostCpuSchedulerSystem, + ManagedObjectTypesHostDatastoreBrowser, + ManagedObjectTypesHostDatastoreSystem, + ManagedObjectTypesHostDateTimeSystem, + ManagedObjectTypesHostDiagnosticSystem, + ManagedObjectTypesHostDirectoryStore, + ManagedObjectTypesHostEsxAgentHostManager, + ManagedObjectTypesHostFirewallSystem, + ManagedObjectTypesHostFirmwareSystem, + ManagedObjectTypesHostGraphicsManager, + ManagedObjectTypesHostHealthStatusSystem, + ManagedObjectTypesHostAccessManager, + ManagedObjectTypesHostImageConfigManager, + ManagedObjectTypesIscsiManager, + ManagedObjectTypesHostKernelModuleSystem, + ManagedObjectTypesHostLocalAccountManager, + ManagedObjectTypesHostLocalAuthentication, + ManagedObjectTypesHostMemorySystem, + ManagedObjectTypesMessageBusProxy, + ManagedObjectTypesHostNetworkSystem, + ManagedObjectTypesHostNvdimmSystem, + ManagedObjectTypesHostPatchManager, + ManagedObjectTypesHostPciPassthruSystem, + ManagedObjectTypesHostPowerSystem, + ManagedObjectTypesHostServiceSystem, + ManagedObjectTypesHostSnmpSystem, + ManagedObjectTypesHostStorageSystem, + ManagedObjectTypesHostVFlashManager, + ManagedObjectTypesHostVMotionSystem, + ManagedObjectTypesHostVirtualNicManager, + ManagedObjectTypesHostVsanInternalSystem, + ManagedObjectTypesHostVsanSystem, + ManagedObjectTypesOptionManager, + ManagedObjectTypesProfileComplianceManager, + ManagedObjectTypesProfile, + ManagedObjectTypesProfileManager, + ManagedObjectTypesClusterProfile, + ManagedObjectTypesClusterProfileManager, + ManagedObjectTypesHostProfile, + ManagedObjectTypesHostSpecificationManager, + ManagedObjectTypesHostProfileManager, + ManagedObjectTypesScheduledTask, + ManagedObjectTypesScheduledTaskManager, + ManagedObjectTypesTenantTenantManager, + ManagedObjectTypesFailoverClusterConfigurator, + ManagedObjectTypesFailoverClusterManager, + ManagedObjectTypesContainerView, + ManagedObjectTypesInventoryView, + ManagedObjectTypesListView, + ManagedObjectTypesManagedObjectView, + ManagedObjectTypesView, + ManagedObjectTypesViewManager, + ManagedObjectTypesVirtualMachineGuestCustomizationManager, + ManagedObjectTypesVirtualMachineSnapshot, + ManagedObjectTypesVirtualMachineCompatibilityChecker, + ManagedObjectTypesVirtualMachineProvisioningChecker, + ManagedObjectTypesGuestAliasManager, + ManagedObjectTypesGuestAuthManager, + ManagedObjectTypesGuestFileManager, + ManagedObjectTypesGuestOperationsManager, + ManagedObjectTypesGuestProcessManager, + ManagedObjectTypesGuestWindowsRegistryManager, + ManagedObjectTypesVStorageObjectManagerBase, + ManagedObjectTypesHostVStorageObjectManager, + ManagedObjectTypesVcenterVStorageObjectManager, + } +} + +func (e ManagedObjectTypes) Strings() []string { + return EnumValuesAsStrings(e.Values()) +} + +func init() { + t["ManagedObjectTypes"] = reflect.TypeOf((*ManagedObjectTypes)(nil)).Elem() +} + // The operation on the target metric item. type MetricAlarmOperator string @@ -9089,6 +9623,34 @@ func init() { t["PhysicalNicVmDirectPathGen2SupportedMode"] = reflect.TypeOf((*PhysicalNicVmDirectPathGen2SupportedMode)(nil)).Elem() } +type PlaceVmsXClusterSpecPlacementType string + +const ( + // Create a new VM that should be powered-on in the near future. + PlaceVmsXClusterSpecPlacementTypeCreateAndPowerOn = PlaceVmsXClusterSpecPlacementType("createAndPowerOn") + // Reconfigure a powered-off or a powered-on VM. + PlaceVmsXClusterSpecPlacementTypeReconfigure = PlaceVmsXClusterSpecPlacementType("reconfigure") + // Relocate a powered-off or a powered-on VM. + PlaceVmsXClusterSpecPlacementTypeRelocate = PlaceVmsXClusterSpecPlacementType("relocate") +) + +func (e PlaceVmsXClusterSpecPlacementType) Values() []PlaceVmsXClusterSpecPlacementType { + return []PlaceVmsXClusterSpecPlacementType{ + PlaceVmsXClusterSpecPlacementTypeCreateAndPowerOn, + PlaceVmsXClusterSpecPlacementTypeReconfigure, + PlaceVmsXClusterSpecPlacementTypeRelocate, + } +} + +func (e PlaceVmsXClusterSpecPlacementType) Strings() []string { + return EnumValuesAsStrings(e.Values()) +} + +func init() { + t["PlaceVmsXClusterSpecPlacementType"] = reflect.TypeOf((*PlaceVmsXClusterSpecPlacementType)(nil)).Elem() + minAPIVersionForType["PlaceVmsXClusterSpecPlacementType"] = "9.0.0.0" +} + // Rule scope determines conditions when an affinity rule is // satisfied. // @@ -13140,6 +13702,10 @@ const ( VirtualMachineGuestOsIdentifierFreebsd14Guest = VirtualMachineGuestOsIdentifier("freebsd14Guest") // FreeBSD 14 x64 VirtualMachineGuestOsIdentifierFreebsd14_64Guest = VirtualMachineGuestOsIdentifier("freebsd14_64Guest") + // FreeBSD 15 + VirtualMachineGuestOsIdentifierFreebsd15Guest = VirtualMachineGuestOsIdentifier("freebsd15Guest") + // FreeBSD 15 x64 + VirtualMachineGuestOsIdentifierFreebsd15_64Guest = VirtualMachineGuestOsIdentifier("freebsd15_64Guest") // Red Hat Linux 2.1 VirtualMachineGuestOsIdentifierRedhatGuest = VirtualMachineGuestOsIdentifier("redhatGuest") // Red Hat Enterprise Linux 2 @@ -13168,6 +13734,8 @@ const ( VirtualMachineGuestOsIdentifierRhel8_64Guest = VirtualMachineGuestOsIdentifier("rhel8_64Guest") // Red Hat Enterprise Linux 9 (64 bit) VirtualMachineGuestOsIdentifierRhel9_64Guest = VirtualMachineGuestOsIdentifier("rhel9_64Guest") + // Red Hat Enterprise Linux 10 (64 bit) + VirtualMachineGuestOsIdentifierRhel10_64Guest = VirtualMachineGuestOsIdentifier("rhel10_64Guest") // CentOS 4/5 VirtualMachineGuestOsIdentifierCentosGuest = VirtualMachineGuestOsIdentifier("centosGuest") // CentOS 4/5 (64-bit) @@ -13200,6 +13768,8 @@ const ( VirtualMachineGuestOsIdentifierOracleLinux8_64Guest = VirtualMachineGuestOsIdentifier("oracleLinux8_64Guest") // Oracle 9 (64-bit) VirtualMachineGuestOsIdentifierOracleLinux9_64Guest = VirtualMachineGuestOsIdentifier("oracleLinux9_64Guest") + // Oracle 10 (64-bit) + VirtualMachineGuestOsIdentifierOracleLinux10_64Guest = VirtualMachineGuestOsIdentifier("oracleLinux10_64Guest") // Suse Linux VirtualMachineGuestOsIdentifierSuseGuest = VirtualMachineGuestOsIdentifier("suseGuest") // Suse Linux (64 bit) @@ -13280,6 +13850,10 @@ const ( VirtualMachineGuestOsIdentifierDebian12Guest = VirtualMachineGuestOsIdentifier("debian12Guest") // Debian GNU/Linux 12 (64 bit) VirtualMachineGuestOsIdentifierDebian12_64Guest = VirtualMachineGuestOsIdentifier("debian12_64Guest") + // Debian GNU/Linux 13 + VirtualMachineGuestOsIdentifierDebian13Guest = VirtualMachineGuestOsIdentifier("debian13Guest") + // Debian GNU/Linux 13 (64 bit) + VirtualMachineGuestOsIdentifierDebian13_64Guest = VirtualMachineGuestOsIdentifier("debian13_64Guest") // Asianux Server 3 VirtualMachineGuestOsIdentifierAsianux3Guest = VirtualMachineGuestOsIdentifier("asianux3Guest") // Asianux Server 3 (64 bit) @@ -13296,6 +13870,10 @@ const ( VirtualMachineGuestOsIdentifierAsianux8_64Guest = VirtualMachineGuestOsIdentifier("asianux8_64Guest") // Asianux Server 9 (64 bit) VirtualMachineGuestOsIdentifierAsianux9_64Guest = VirtualMachineGuestOsIdentifier("asianux9_64Guest") + // MIRACLE LINUX (64-bit) + VirtualMachineGuestOsIdentifierMiraclelinux_64Guest = VirtualMachineGuestOsIdentifier("miraclelinux_64Guest") + // Pardus (64-bit) + VirtualMachineGuestOsIdentifierPardus_64Guest = VirtualMachineGuestOsIdentifier("pardus_64Guest") // OpenSUSE Linux VirtualMachineGuestOsIdentifierOpensuseGuest = VirtualMachineGuestOsIdentifier("opensuseGuest") // OpenSUSE Linux (64 bit) @@ -13322,6 +13900,8 @@ const ( VirtualMachineGuestOsIdentifierOther5xLinuxGuest = VirtualMachineGuestOsIdentifier("other5xLinuxGuest") // Linux 6.x Kernel VirtualMachineGuestOsIdentifierOther6xLinuxGuest = VirtualMachineGuestOsIdentifier("other6xLinuxGuest") + // Linux 7.x Kernel + VirtualMachineGuestOsIdentifierOther7xLinuxGuest = VirtualMachineGuestOsIdentifier("other7xLinuxGuest") // Other Linux VirtualMachineGuestOsIdentifierGenericLinuxGuest = VirtualMachineGuestOsIdentifier("genericLinuxGuest") // Linux 2.4.x Kernel (64 bit) @@ -13336,6 +13916,8 @@ const ( VirtualMachineGuestOsIdentifierOther5xLinux64Guest = VirtualMachineGuestOsIdentifier("other5xLinux64Guest") // Linux 6.x Kernel (64 bit) VirtualMachineGuestOsIdentifierOther6xLinux64Guest = VirtualMachineGuestOsIdentifier("other6xLinux64Guest") + // Linux 7.x Kernel (64 bit) + VirtualMachineGuestOsIdentifierOther7xLinux64Guest = VirtualMachineGuestOsIdentifier("other7xLinux64Guest") // Linux (64 bit) VirtualMachineGuestOsIdentifierOtherLinux64Guest = VirtualMachineGuestOsIdentifier("otherLinux64Guest") // Solaris 6 @@ -13352,6 +13934,12 @@ const ( VirtualMachineGuestOsIdentifierSolaris10_64Guest = VirtualMachineGuestOsIdentifier("solaris10_64Guest") // Solaris 11 (64 bit) VirtualMachineGuestOsIdentifierSolaris11_64Guest = VirtualMachineGuestOsIdentifier("solaris11_64Guest") + // FusionOS (64 bit) + VirtualMachineGuestOsIdentifierFusionos_64Guest = VirtualMachineGuestOsIdentifier("fusionos_64Guest") + // ProLinux (64 bit) + VirtualMachineGuestOsIdentifierProlinux_64Guest = VirtualMachineGuestOsIdentifier("prolinux_64Guest") + // Kylinlinux (64 bit) + VirtualMachineGuestOsIdentifierKylinlinux_64Guest = VirtualMachineGuestOsIdentifier("kylinlinux_64Guest") // OS/2 VirtualMachineGuestOsIdentifierOs2Guest = VirtualMachineGuestOsIdentifier("os2Guest") // eComStation 1.x @@ -13418,6 +14006,8 @@ const ( VirtualMachineGuestOsIdentifierVmkernel7Guest = VirtualMachineGuestOsIdentifier("vmkernel7Guest") // VMware ESX 8 VirtualMachineGuestOsIdentifierVmkernel8Guest = VirtualMachineGuestOsIdentifier("vmkernel8Guest") + // VMware ESX 9 + VirtualMachineGuestOsIdentifierVmkernel9Guest = VirtualMachineGuestOsIdentifier("vmkernel9Guest") // Amazon Linux 2 (64 bit) VirtualMachineGuestOsIdentifierAmazonlinux2_64Guest = VirtualMachineGuestOsIdentifier("amazonlinux2_64Guest") // Amazon Linux 3 (64 bit) @@ -13487,6 +14077,8 @@ func (e VirtualMachineGuestOsIdentifier) Values() []VirtualMachineGuestOsIdentif VirtualMachineGuestOsIdentifierFreebsd13_64Guest, VirtualMachineGuestOsIdentifierFreebsd14Guest, VirtualMachineGuestOsIdentifierFreebsd14_64Guest, + VirtualMachineGuestOsIdentifierFreebsd15Guest, + VirtualMachineGuestOsIdentifierFreebsd15_64Guest, VirtualMachineGuestOsIdentifierRedhatGuest, VirtualMachineGuestOsIdentifierRhel2Guest, VirtualMachineGuestOsIdentifierRhel3Guest, @@ -13501,6 +14093,7 @@ func (e VirtualMachineGuestOsIdentifier) Values() []VirtualMachineGuestOsIdentif VirtualMachineGuestOsIdentifierRhel7_64Guest, VirtualMachineGuestOsIdentifierRhel8_64Guest, VirtualMachineGuestOsIdentifierRhel9_64Guest, + VirtualMachineGuestOsIdentifierRhel10_64Guest, VirtualMachineGuestOsIdentifierCentosGuest, VirtualMachineGuestOsIdentifierCentos64Guest, VirtualMachineGuestOsIdentifierCentos6Guest, @@ -13517,6 +14110,7 @@ func (e VirtualMachineGuestOsIdentifier) Values() []VirtualMachineGuestOsIdentif VirtualMachineGuestOsIdentifierOracleLinux7_64Guest, VirtualMachineGuestOsIdentifierOracleLinux8_64Guest, VirtualMachineGuestOsIdentifierOracleLinux9_64Guest, + VirtualMachineGuestOsIdentifierOracleLinux10_64Guest, VirtualMachineGuestOsIdentifierSuseGuest, VirtualMachineGuestOsIdentifierSuse64Guest, VirtualMachineGuestOsIdentifierSlesGuest, @@ -13557,6 +14151,8 @@ func (e VirtualMachineGuestOsIdentifier) Values() []VirtualMachineGuestOsIdentif VirtualMachineGuestOsIdentifierDebian11_64Guest, VirtualMachineGuestOsIdentifierDebian12Guest, VirtualMachineGuestOsIdentifierDebian12_64Guest, + VirtualMachineGuestOsIdentifierDebian13Guest, + VirtualMachineGuestOsIdentifierDebian13_64Guest, VirtualMachineGuestOsIdentifierAsianux3Guest, VirtualMachineGuestOsIdentifierAsianux3_64Guest, VirtualMachineGuestOsIdentifierAsianux4Guest, @@ -13565,6 +14161,8 @@ func (e VirtualMachineGuestOsIdentifier) Values() []VirtualMachineGuestOsIdentif VirtualMachineGuestOsIdentifierAsianux7_64Guest, VirtualMachineGuestOsIdentifierAsianux8_64Guest, VirtualMachineGuestOsIdentifierAsianux9_64Guest, + VirtualMachineGuestOsIdentifierMiraclelinux_64Guest, + VirtualMachineGuestOsIdentifierPardus_64Guest, VirtualMachineGuestOsIdentifierOpensuseGuest, VirtualMachineGuestOsIdentifierOpensuse64Guest, VirtualMachineGuestOsIdentifierFedoraGuest, @@ -13578,6 +14176,7 @@ func (e VirtualMachineGuestOsIdentifier) Values() []VirtualMachineGuestOsIdentif VirtualMachineGuestOsIdentifierOther4xLinuxGuest, VirtualMachineGuestOsIdentifierOther5xLinuxGuest, VirtualMachineGuestOsIdentifierOther6xLinuxGuest, + VirtualMachineGuestOsIdentifierOther7xLinuxGuest, VirtualMachineGuestOsIdentifierGenericLinuxGuest, VirtualMachineGuestOsIdentifierOther24xLinux64Guest, VirtualMachineGuestOsIdentifierOther26xLinux64Guest, @@ -13585,6 +14184,7 @@ func (e VirtualMachineGuestOsIdentifier) Values() []VirtualMachineGuestOsIdentif VirtualMachineGuestOsIdentifierOther4xLinux64Guest, VirtualMachineGuestOsIdentifierOther5xLinux64Guest, VirtualMachineGuestOsIdentifierOther6xLinux64Guest, + VirtualMachineGuestOsIdentifierOther7xLinux64Guest, VirtualMachineGuestOsIdentifierOtherLinux64Guest, VirtualMachineGuestOsIdentifierSolaris6Guest, VirtualMachineGuestOsIdentifierSolaris7Guest, @@ -13593,6 +14193,9 @@ func (e VirtualMachineGuestOsIdentifier) Values() []VirtualMachineGuestOsIdentif VirtualMachineGuestOsIdentifierSolaris10Guest, VirtualMachineGuestOsIdentifierSolaris10_64Guest, VirtualMachineGuestOsIdentifierSolaris11_64Guest, + VirtualMachineGuestOsIdentifierFusionos_64Guest, + VirtualMachineGuestOsIdentifierProlinux_64Guest, + VirtualMachineGuestOsIdentifierKylinlinux_64Guest, VirtualMachineGuestOsIdentifierOs2Guest, VirtualMachineGuestOsIdentifierEComStationGuest, VirtualMachineGuestOsIdentifierEComStation2Guest, @@ -13626,6 +14229,7 @@ func (e VirtualMachineGuestOsIdentifier) Values() []VirtualMachineGuestOsIdentif VirtualMachineGuestOsIdentifierVmkernel65Guest, VirtualMachineGuestOsIdentifierVmkernel7Guest, VirtualMachineGuestOsIdentifierVmkernel8Guest, + VirtualMachineGuestOsIdentifierVmkernel9Guest, VirtualMachineGuestOsIdentifierAmazonlinux2_64Guest, VirtualMachineGuestOsIdentifierAmazonlinux3_64Guest, VirtualMachineGuestOsIdentifierCrxPod1Guest, @@ -13652,22 +14256,36 @@ func init() { "freebsd13_64Guest": "7.0.1.0", "freebsd14Guest": "8.0.0.1", "freebsd14_64Guest": "8.0.0.1", + "freebsd15Guest": "9.0.0.0", + "freebsd15_64Guest": "9.0.0.0", "rhel9_64Guest": "7.0.1.0", + "rhel10_64Guest": "9.0.0.0", "centos9_64Guest": "7.0.1.0", "oracleLinux9_64Guest": "7.0.1.0", + "oracleLinux10_64Guest": "9.0.0.0", "sles16_64Guest": "7.0.1.0", "debian12Guest": "8.0.0.1", "debian12_64Guest": "8.0.0.1", + "debian13Guest": "9.0.0.0", + "debian13_64Guest": "9.0.0.0", "asianux9_64Guest": "7.0.1.0", + "miraclelinux_64Guest": "9.0.0.0", + "pardus_64Guest": "9.0.0.0", "other5xLinuxGuest": "7.0.1.0", "other6xLinuxGuest": "8.0.0.1", + "other7xLinuxGuest": "9.0.0.0", "other5xLinux64Guest": "7.0.1.0", "other6xLinux64Guest": "8.0.0.1", + "other7xLinux64Guest": "9.0.0.0", + "fusionos_64Guest": "9.0.0.0", + "prolinux_64Guest": "9.0.0.0", + "kylinlinux_64Guest": "9.0.0.0", "darwin20_64Guest": "7.0.1.0", "darwin21_64Guest": "7.0.1.0", "darwin22_64Guest": "8.0.0.1", "darwin23_64Guest": "8.0.0.1", "vmkernel8Guest": "8.0.0.1", + "vmkernel9Guest": "9.0.0.0", "amazonlinux3_64Guest": "7.0.1.0", "crxSys1Guest": "8.0.3.0", "rockylinux_64Guest": "8.0.0.1", @@ -15042,6 +15660,45 @@ func init() { t["VirtualSerialPortEndPoint"] = reflect.TypeOf((*VirtualSerialPortEndPoint)(nil)).Elem() } +// TSO (TCP Segmentation Offload) and LRO (Large Receive Offload) +// are both offloading techniques that improve network performance +// by reducing CPU overhead associated with packet segmentation +// and aggregation, respectively. +// +// They are commonly used in modern +// networking environments to optimize data transmission and +// reception processes. This is the type of disable offload on a +// network adapter. +type VirtualVmxnet3StrictLatencyConfigDisableOffload string + +const ( + // Do not disable. + VirtualVmxnet3StrictLatencyConfigDisableOffloadNONE = VirtualVmxnet3StrictLatencyConfigDisableOffload("NONE") + // Disable TCP Segmentation Offload (TSO). + VirtualVmxnet3StrictLatencyConfigDisableOffloadTSO = VirtualVmxnet3StrictLatencyConfigDisableOffload("TSO") + // Disable Large Receive Offload (LRO). + VirtualVmxnet3StrictLatencyConfigDisableOffloadLRO = VirtualVmxnet3StrictLatencyConfigDisableOffload("LRO") + // Disable both TSO and LRO. + VirtualVmxnet3StrictLatencyConfigDisableOffloadTSO_LRO = VirtualVmxnet3StrictLatencyConfigDisableOffload("TSO_LRO") +) + +func (e VirtualVmxnet3StrictLatencyConfigDisableOffload) Values() []VirtualVmxnet3StrictLatencyConfigDisableOffload { + return []VirtualVmxnet3StrictLatencyConfigDisableOffload{ + VirtualVmxnet3StrictLatencyConfigDisableOffloadNONE, + VirtualVmxnet3StrictLatencyConfigDisableOffloadTSO, + VirtualVmxnet3StrictLatencyConfigDisableOffloadLRO, + VirtualVmxnet3StrictLatencyConfigDisableOffloadTSO_LRO, + } +} + +func (e VirtualVmxnet3StrictLatencyConfigDisableOffload) Strings() []string { + return EnumValuesAsStrings(e.Values()) +} + +func init() { + t["VirtualVmxnet3StrictLatencyConfigDisableOffload"] = reflect.TypeOf((*VirtualVmxnet3StrictLatencyConfigDisableOffload)(nil)).Elem() +} + // The enumeration of all known valid VRDMA device protocols. type VirtualVmxnet3VrdmaOptionDeviceProtocols string @@ -15678,6 +16335,7 @@ const ( VslmDiskInfoFlagKeyProviderId = VslmDiskInfoFlag("keyProviderId") VslmDiskInfoFlagNativeSnapshotSupported = VslmDiskInfoFlag("nativeSnapshotSupported") VslmDiskInfoFlagCbtEnabled = VslmDiskInfoFlag("cbtEnabled") + VslmDiskInfoFlagVirtualDiskFormat = VslmDiskInfoFlag("virtualDiskFormat") ) func (e VslmDiskInfoFlag) Values() []VslmDiskInfoFlag { @@ -15703,6 +16361,7 @@ func (e VslmDiskInfoFlag) Values() []VslmDiskInfoFlag { VslmDiskInfoFlagKeyProviderId, VslmDiskInfoFlagNativeSnapshotSupported, VslmDiskInfoFlagCbtEnabled, + VslmDiskInfoFlagVirtualDiskFormat, } } diff --git a/vendor/github.com/vmware/govmomi/vim25/types/helpers.go b/vendor/github.com/vmware/govmomi/vim25/types/helpers.go index 531b90d8..2527788b 100644 --- a/vendor/github.com/vmware/govmomi/vim25/types/helpers.go +++ b/vendor/github.com/vmware/govmomi/vim25/types/helpers.go @@ -34,6 +34,10 @@ func EnumValuesAsStrings[T ~string](enumValues []T) []string { return stringValues } +func New[T any](t T) *T { + return &t +} + func NewBool(v bool) *bool { return &v } diff --git a/vendor/github.com/vmware/govmomi/vim25/types/if.go b/vendor/github.com/vmware/govmomi/vim25/types/if.go index e33fb392..000da856 100644 --- a/vendor/github.com/vmware/govmomi/vim25/types/if.go +++ b/vendor/github.com/vmware/govmomi/vim25/types/if.go @@ -1,18 +1,6 @@ -/* -Copyright (c) 2014-2024 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. -*/ +// © Broadcom. All Rights Reserved. +// The term “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. +// SPDX-License-Identifier: Apache-2.0 package types @@ -422,6 +410,18 @@ func init() { t["BaseCpuIncompatible"] = reflect.TypeOf((*CpuIncompatible)(nil)).Elem() } +func (b *CryptoManagerKmipCryptoKeyStatusKeyInfo) GetCryptoManagerKmipCryptoKeyStatusKeyInfo() *CryptoManagerKmipCryptoKeyStatusKeyInfo { + return b +} + +type BaseCryptoManagerKmipCryptoKeyStatusKeyInfo interface { + GetCryptoManagerKmipCryptoKeyStatusKeyInfo() *CryptoManagerKmipCryptoKeyStatusKeyInfo +} + +func init() { + t["BaseCryptoManagerKmipCryptoKeyStatusKeyInfo"] = reflect.TypeOf((*CryptoManagerKmipCryptoKeyStatusKeyInfo)(nil)).Elem() +} + func (b *CryptoSpec) GetCryptoSpec() *CryptoSpec { return b } type BaseCryptoSpec interface { @@ -762,6 +762,54 @@ func init() { t["BaseDeviceNotSupported"] = reflect.TypeOf((*DeviceNotSupported)(nil)).Elem() } +func (b *DirectPathProfileManagerCapacityQuerySpec) GetDirectPathProfileManagerCapacityQuerySpec() *DirectPathProfileManagerCapacityQuerySpec { + return b +} + +type BaseDirectPathProfileManagerCapacityQuerySpec interface { + GetDirectPathProfileManagerCapacityQuerySpec() *DirectPathProfileManagerCapacityQuerySpec +} + +func init() { + t["BaseDirectPathProfileManagerCapacityQuerySpec"] = reflect.TypeOf((*DirectPathProfileManagerCapacityQuerySpec)(nil)).Elem() +} + +func (b *DirectPathProfileManagerCapacityResult) GetDirectPathProfileManagerCapacityResult() *DirectPathProfileManagerCapacityResult { + return b +} + +type BaseDirectPathProfileManagerCapacityResult interface { + GetDirectPathProfileManagerCapacityResult() *DirectPathProfileManagerCapacityResult +} + +func init() { + t["BaseDirectPathProfileManagerCapacityResult"] = reflect.TypeOf((*DirectPathProfileManagerCapacityResult)(nil)).Elem() +} + +func (b *DirectPathProfileManagerDirectPathConfig) GetDirectPathProfileManagerDirectPathConfig() *DirectPathProfileManagerDirectPathConfig { + return b +} + +type BaseDirectPathProfileManagerDirectPathConfig interface { + GetDirectPathProfileManagerDirectPathConfig() *DirectPathProfileManagerDirectPathConfig +} + +func init() { + t["BaseDirectPathProfileManagerDirectPathConfig"] = reflect.TypeOf((*DirectPathProfileManagerDirectPathConfig)(nil)).Elem() +} + +func (b *DirectPathProfileManagerTargetEntity) GetDirectPathProfileManagerTargetEntity() *DirectPathProfileManagerTargetEntity { + return b +} + +type BaseDirectPathProfileManagerTargetEntity interface { + GetDirectPathProfileManagerTargetEntity() *DirectPathProfileManagerTargetEntity +} + +func init() { + t["BaseDirectPathProfileManagerTargetEntity"] = reflect.TypeOf((*DirectPathProfileManagerTargetEntity)(nil)).Elem() +} + func (b *DiskNotSupported) GetDiskNotSupported() *DiskNotSupported { return b } type BaseDiskNotSupported interface { @@ -978,6 +1026,18 @@ func init() { t["BaseEventArgument"] = reflect.TypeOf((*EventArgument)(nil)).Elem() } +func (b *EventManagerEventViewSpec) GetEventManagerEventViewSpec() *EventManagerEventViewSpec { + return b +} + +type BaseEventManagerEventViewSpec interface { + GetEventManagerEventViewSpec() *EventManagerEventViewSpec +} + +func init() { + t["BaseEventManagerEventViewSpec"] = reflect.TypeOf((*EventManagerEventViewSpec)(nil)).Elem() +} + func (b *ExitStandbyModeFailedEvent) GetExitStandbyModeFailedEvent() *ExitStandbyModeFailedEvent { return b } @@ -1204,6 +1264,16 @@ func init() { t["BaseGuestRegistryValueFault"] = reflect.TypeOf((*GuestRegistryValueFault)(nil)).Elem() } +func (b *HbrReplicationTargetSpec) GetHbrReplicationTargetSpec() *HbrReplicationTargetSpec { return b } + +type BaseHbrReplicationTargetSpec interface { + GetHbrReplicationTargetSpec() *HbrReplicationTargetSpec +} + +func init() { + t["BaseHbrReplicationTargetSpec"] = reflect.TypeOf((*HbrReplicationTargetSpec)(nil)).Elem() +} + func (b *HostAccountSpec) GetHostAccountSpec() *HostAccountSpec { return b } type BaseHostAccountSpec interface { @@ -1842,6 +1912,26 @@ func init() { t["BaseIscsiFault"] = reflect.TypeOf((*IscsiFault)(nil)).Elem() } +func (b *KmipClusterInfoKeyInfo) GetKmipClusterInfoKeyInfo() *KmipClusterInfoKeyInfo { return b } + +type BaseKmipClusterInfoKeyInfo interface { + GetKmipClusterInfoKeyInfo() *KmipClusterInfoKeyInfo +} + +func init() { + t["BaseKmipClusterInfoKeyInfo"] = reflect.TypeOf((*KmipClusterInfoKeyInfo)(nil)).Elem() +} + +func (b *KmipServerSpecKeySpec) GetKmipServerSpecKeySpec() *KmipServerSpecKeySpec { return b } + +type BaseKmipServerSpecKeySpec interface { + GetKmipServerSpecKeySpec() *KmipServerSpecKeySpec +} + +func init() { + t["BaseKmipServerSpecKeySpec"] = reflect.TypeOf((*KmipServerSpecKeySpec)(nil)).Elem() +} + func (b *LicenseEvent) GetLicenseEvent() *LicenseEvent { return b } type BaseLicenseEvent interface { @@ -2116,6 +2206,18 @@ func init() { t["BaseOvfConsumerCallbackFault"] = reflect.TypeOf((*OvfConsumerCallbackFault)(nil)).Elem() } +func (b *OvfCreateImportSpecParams) GetOvfCreateImportSpecParams() *OvfCreateImportSpecParams { + return b +} + +type BaseOvfCreateImportSpecParams interface { + GetOvfCreateImportSpecParams() *OvfCreateImportSpecParams +} + +func init() { + t["BaseOvfCreateImportSpecParams"] = reflect.TypeOf((*OvfCreateImportSpecParams)(nil)).Elem() +} + func (b *OvfElement) GetOvfElement() *OvfElement { return b } type BaseOvfElement interface { @@ -2652,6 +2754,16 @@ func init() { t["BaseTaskInProgress"] = reflect.TypeOf((*TaskInProgress)(nil)).Elem() } +func (b *TaskManagerTaskViewSpec) GetTaskManagerTaskViewSpec() *TaskManagerTaskViewSpec { return b } + +type BaseTaskManagerTaskViewSpec interface { + GetTaskManagerTaskViewSpec() *TaskManagerTaskViewSpec +} + +func init() { + t["BaseTaskManagerTaskViewSpec"] = reflect.TypeOf((*TaskManagerTaskViewSpec)(nil)).Elem() +} + func (b *TaskReason) GetTaskReason() *TaskReason { return b } type BaseTaskReason interface { diff --git a/vendor/github.com/vmware/govmomi/vim25/types/types.go b/vendor/github.com/vmware/govmomi/vim25/types/types.go index 43f8c0a9..4420467d 100644 --- a/vendor/github.com/vmware/govmomi/vim25/types/types.go +++ b/vendor/github.com/vmware/govmomi/vim25/types/types.go @@ -1,18 +1,6 @@ -/* -Copyright (c) 2014-2024 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. -*/ +// © Broadcom. All Rights Reserved. +// The term “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. +// SPDX-License-Identifier: Apache-2.0 package types @@ -96,9 +84,9 @@ type AboutInfo struct { FullName string `xml:"fullName" json:"fullName"` // Name of the vendor of this product. Vendor string `xml:"vendor" json:"vendor"` - // Dot-separated version string. + // Dot-separated product version string. // - // For example, "1.2". + // For example, "10.0.2.0". Version string `xml:"version" json:"version"` // Patch level for the server. PatchLevel string `xml:"patchLevel,omitempty" json:"patchLevel,omitempty" vim:"7.0.2.0"` @@ -143,9 +131,10 @@ type AboutInfo struct { // - "VirtualCenter" - For a VirtualCenter instance. // - "HostAgent" - For host agent on an ESX Server or VMware Server host. ApiType string `xml:"apiType" json:"apiType"` - // The version of the API as a dot-separated string. + // The newest long-term supported API version provided by the server. // - // For example, "1.0.0". + // The version format is "x.y.z.a", where "x", "y", and "z" are numbers + // that do not exceed 99, and "a" does not exceed 9999. ApiVersion string `xml:"apiVersion" json:"apiVersion"` // A globally unique identifier associated with this service instance. InstanceUuid string `xml:"instanceUuid,omitempty" json:"instanceUuid,omitempty"` @@ -3120,6 +3109,36 @@ func init() { t["ArrayOfDiagnosticManagerLogDescriptor"] = reflect.TypeOf((*ArrayOfDiagnosticManagerLogDescriptor)(nil)).Elem() } +// A boxed array of `DirectPathProfileInfo`. To be used in `Any` placeholders. +type ArrayOfDirectPathProfileInfo struct { + DirectPathProfileInfo []DirectPathProfileInfo `xml:"DirectPathProfileInfo,omitempty" json:"_value"` +} + +func init() { + t["ArrayOfDirectPathProfileInfo"] = reflect.TypeOf((*ArrayOfDirectPathProfileInfo)(nil)).Elem() + minAPIVersionForType["ArrayOfDirectPathProfileInfo"] = "9.0.0.0" +} + +// A boxed array of `DirectPathProfileManagerCapacityQuerySpec`. To be used in `Any` placeholders. +type ArrayOfDirectPathProfileManagerCapacityQuerySpec struct { + DirectPathProfileManagerCapacityQuerySpec []BaseDirectPathProfileManagerCapacityQuerySpec `xml:"DirectPathProfileManagerCapacityQuerySpec,omitempty,typeattr" json:"_value"` +} + +func init() { + t["ArrayOfDirectPathProfileManagerCapacityQuerySpec"] = reflect.TypeOf((*ArrayOfDirectPathProfileManagerCapacityQuerySpec)(nil)).Elem() + minAPIVersionForType["ArrayOfDirectPathProfileManagerCapacityQuerySpec"] = "9.0.0.0" +} + +// A boxed array of `DirectPathProfileManagerCapacityResult`. To be used in `Any` placeholders. +type ArrayOfDirectPathProfileManagerCapacityResult struct { + DirectPathProfileManagerCapacityResult []BaseDirectPathProfileManagerCapacityResult `xml:"DirectPathProfileManagerCapacityResult,omitempty,typeattr" json:"_value"` +} + +func init() { + t["ArrayOfDirectPathProfileManagerCapacityResult"] = reflect.TypeOf((*ArrayOfDirectPathProfileManagerCapacityResult)(nil)).Elem() + minAPIVersionForType["ArrayOfDirectPathProfileManagerCapacityResult"] = "9.0.0.0" +} + // A boxed array of `DiskChangeExtent`. To be used in `Any` placeholders. type ArrayOfDiskChangeExtent struct { DiskChangeExtent []DiskChangeExtent `xml:"DiskChangeExtent,omitempty" json:"_value"` @@ -3846,6 +3865,16 @@ func init() { t["ArrayOfHbrManagerVmReplicationCapability"] = reflect.TypeOf((*ArrayOfHbrManagerVmReplicationCapability)(nil)).Elem() } +// A boxed array of `HbrTargetSpec`. To be used in `Any` placeholders. +type ArrayOfHbrTargetSpec struct { + HbrTargetSpec []HbrTargetSpec `xml:"HbrTargetSpec,omitempty" json:"_value"` +} + +func init() { + t["ArrayOfHbrTargetSpec"] = reflect.TypeOf((*ArrayOfHbrTargetSpec)(nil)).Elem() + minAPIVersionForType["ArrayOfHbrTargetSpec"] = "9.0.0.0" +} + // A boxed array of `HealthUpdate`. To be used in `Any` placeholders. type ArrayOfHealthUpdate struct { HealthUpdate []HealthUpdate `xml:"HealthUpdate,omitempty" json:"_value"` @@ -3909,6 +3938,16 @@ func init() { t["ArrayOfHostAssignableHardwareConfigAttributeOverride"] = reflect.TypeOf((*ArrayOfHostAssignableHardwareConfigAttributeOverride)(nil)).Elem() } +// A boxed array of `HostAuthenticationInfo`. To be used in `Any` placeholders. +type ArrayOfHostAuthenticationInfo struct { + HostAuthenticationInfo []HostAuthenticationInfo `xml:"HostAuthenticationInfo,omitempty" json:"_value"` +} + +func init() { + t["ArrayOfHostAuthenticationInfo"] = reflect.TypeOf((*ArrayOfHostAuthenticationInfo)(nil)).Elem() + minAPIVersionForType["ArrayOfHostAuthenticationInfo"] = "9.0.0.0" +} + // A boxed array of `HostAuthenticationStoreInfo`. To be used in `Any` placeholders. type ArrayOfHostAuthenticationStoreInfo struct { HostAuthenticationStoreInfo []BaseHostAuthenticationStoreInfo `xml:"HostAuthenticationStoreInfo,omitempty,typeattr" json:"_value"` @@ -5782,6 +5821,16 @@ func init() { t["ArrayOfOvfConsumerOvfSection"] = reflect.TypeOf((*ArrayOfOvfConsumerOvfSection)(nil)).Elem() } +// A boxed array of `OvfDatastoreMapping`. To be used in `Any` placeholders. +type ArrayOfOvfDatastoreMapping struct { + OvfDatastoreMapping []OvfDatastoreMapping `xml:"OvfDatastoreMapping,omitempty" json:"_value"` +} + +func init() { + t["ArrayOfOvfDatastoreMapping"] = reflect.TypeOf((*ArrayOfOvfDatastoreMapping)(nil)).Elem() + minAPIVersionForType["ArrayOfOvfDatastoreMapping"] = "9.0.0.0" +} + // A boxed array of `OvfDeploymentOption`. To be used in `Any` placeholders. type ArrayOfOvfDeploymentOption struct { OvfDeploymentOption []OvfDeploymentOption `xml:"OvfDeploymentOption,omitempty" json:"_value"` @@ -5845,6 +5894,16 @@ func init() { t["ArrayOfOvfResourceMap"] = reflect.TypeOf((*ArrayOfOvfResourceMap)(nil)).Elem() } +// A boxed array of `OvfStorageProfileMapping`. To be used in `Any` placeholders. +type ArrayOfOvfStorageProfileMapping struct { + OvfStorageProfileMapping []OvfStorageProfileMapping `xml:"OvfStorageProfileMapping,omitempty" json:"_value"` +} + +func init() { + t["ArrayOfOvfStorageProfileMapping"] = reflect.TypeOf((*ArrayOfOvfStorageProfileMapping)(nil)).Elem() + minAPIVersionForType["ArrayOfOvfStorageProfileMapping"] = "9.0.0.0" +} + // A boxed array of `PerfCounterInfo`. To be used in `Any` placeholders. type ArrayOfPerfCounterInfo struct { PerfCounterInfo []PerfCounterInfo `xml:"PerfCounterInfo,omitempty" json:"_value"` @@ -6484,6 +6543,16 @@ func init() { t["ArrayOfStructuredCustomizations"] = reflect.TypeOf((*ArrayOfStructuredCustomizations)(nil)).Elem() } +// A boxed array of `SubnetInfo`. To be used in `Any` placeholders. +type ArrayOfSubnetInfo struct { + SubnetInfo []SubnetInfo `xml:"SubnetInfo,omitempty" json:"_value"` +} + +func init() { + t["ArrayOfSubnetInfo"] = reflect.TypeOf((*ArrayOfSubnetInfo)(nil)).Elem() + minAPIVersionForType["ArrayOfSubnetInfo"] = "9.0.0.0" +} + // A boxed array of `SystemEventInfo`. To be used in `Any` placeholders. type ArrayOfSystemEventInfo struct { SystemEventInfo []SystemEventInfo `xml:"SystemEventInfo,omitempty" json:"_value"` @@ -6772,6 +6841,26 @@ func init() { t["ArrayOfVStorageObjectAssociationsVmDiskAssociations"] = reflect.TypeOf((*ArrayOfVStorageObjectAssociationsVmDiskAssociations)(nil)).Elem() } +// A boxed array of `VStorageObjectReconcileResultInvalidDiskPath`. To be used in `Any` placeholders. +type ArrayOfVStorageObjectReconcileResultInvalidDiskPath struct { + VStorageObjectReconcileResultInvalidDiskPath []VStorageObjectReconcileResultInvalidDiskPath `xml:"VStorageObjectReconcileResultInvalidDiskPath,omitempty" json:"_value"` +} + +func init() { + t["ArrayOfVStorageObjectReconcileResultInvalidDiskPath"] = reflect.TypeOf((*ArrayOfVStorageObjectReconcileResultInvalidDiskPath)(nil)).Elem() + minAPIVersionForType["ArrayOfVStorageObjectReconcileResultInvalidDiskPath"] = "9.0.0.0" +} + +// A boxed array of `VStorageObjectReconcileResultReconcileDetail`. To be used in `Any` placeholders. +type ArrayOfVStorageObjectReconcileResultReconcileDetail struct { + VStorageObjectReconcileResultReconcileDetail []VStorageObjectReconcileResultReconcileDetail `xml:"VStorageObjectReconcileResultReconcileDetail,omitempty" json:"_value"` +} + +func init() { + t["ArrayOfVStorageObjectReconcileResultReconcileDetail"] = reflect.TypeOf((*ArrayOfVStorageObjectReconcileResultReconcileDetail)(nil)).Elem() + minAPIVersionForType["ArrayOfVStorageObjectReconcileResultReconcileDetail"] = "9.0.0.0" +} + // A boxed array of `VStorageObjectSnapshotInfoVStorageObjectSnapshot`. To be used in `Any` placeholders. type ArrayOfVStorageObjectSnapshotInfoVStorageObjectSnapshot struct { VStorageObjectSnapshotInfoVStorageObjectSnapshot []VStorageObjectSnapshotInfoVStorageObjectSnapshot `xml:"VStorageObjectSnapshotInfoVStorageObjectSnapshot,omitempty" json:"_value"` @@ -11328,6 +11417,9 @@ type ClusterConfigInfoEx struct { ProactiveDrsConfig *ClusterProactiveDrsConfigInfo `xml:"proactiveDrsConfig,omitempty" json:"proactiveDrsConfig,omitempty"` // Cluster-wide configuration of the encryption mode. CryptoConfig *ClusterCryptoConfigInfo `xml:"cryptoConfig,omitempty" json:"cryptoConfig,omitempty"` + // vSAN first-class settings that will be configured together with + // vSAN enablement. + VsanCoreConfig *VsanClusterCoreConfig `xml:"vsanCoreConfig,omitempty" json:"vsanCoreConfig,omitempty" vim:"9.0.0.0"` } func init() { @@ -11632,6 +11724,9 @@ type ClusterConfigSpecEx struct { InHciWorkflow *bool `xml:"inHciWorkflow" json:"inHciWorkflow,omitempty"` // Cluster-wide configuration of encryption mode. CryptoConfig *ClusterCryptoConfigInfo `xml:"cryptoConfig,omitempty" json:"cryptoConfig,omitempty"` + // vSAN first-class settings that will be configured together with + // vSAN enablement. + VsanCoreConfigSpec *VsanClusterCoreConfigSpec `xml:"vsanCoreConfigSpec,omitempty" json:"vsanCoreConfigSpec,omitempty" vim:"9.0.0.0"` } func init() { @@ -13411,6 +13506,11 @@ func init() { } // Information about an IO Filter on a compute resource. +// +// On vLCM managed cluster, this contains information +// about iofilter at solution level. So, iofilter +// information properties output on a compute resource +// can differ from the hosts on a vLCM cluster. type ClusterIoFilterInfo struct { IoFilterInfo @@ -14014,6 +14114,16 @@ type ClusterUsageSummary struct { PoweredOffVmCount int32 `xml:"poweredOffVmCount" json:"poweredOffVmCount"` // The number of VMs in the cluster TotalVmCount int32 `xml:"totalVmCount" json:"totalVmCount"` + // Total Tier 0 memory capacity in a cluster. + Tier0MemCapacityMB int32 `xml:"tier0MemCapacityMB,omitempty" json:"tier0MemCapacityMB,omitempty" vim:"9.0.0.0"` + // Total amount of Tier 0 memory used to satisfy virtual machine reservation. + ReservedTier0MemMB int32 `xml:"reservedTier0MemMB,omitempty" json:"reservedTier0MemMB,omitempty" vim:"9.0.0.0"` + // Total amount of Tier 0 memory available to satisfy reservation. + // + // Available + // reservation is calculated after accounting for DRS overheads and current + // reservation. + UnreservedTier0MemMB int32 `xml:"unreservedTier0MemMB,omitempty" json:"unreservedTier0MemMB,omitempty" vim:"9.0.0.0"` } func init() { @@ -14658,7 +14768,10 @@ type ComputeResourceConfigSpec struct { // Desired software spec for the set of physical compute resources. // // This - // parameter is only supported in vim.Folder#createClusterEx operation. + // parameter is supported in vim.Folder#createClusterEx and + // vim.Folder#addStandaloneHost operations. + // If unset, this field will be initialized with the latest base image + // from the image depot on vSphere version 9.0 and later. DesiredSoftwareSpec *DesiredSoftwareSpec `xml:"desiredSoftwareSpec,omitempty" json:"desiredSoftwareSpec,omitempty"` // Key for Maximum Hardware Version to be used on this compute resource // in the format of `VirtualMachineConfigOptionDescriptor.key`. @@ -14678,6 +14791,25 @@ type ComputeResourceConfigSpec struct { EnableConfigManager *bool `xml:"enableConfigManager" json:"enableConfigManager,omitempty" vim:"7.0.3.1"` // Specification for the host seeding operation. HostSeedSpec *ComputeResourceHostSeedSpec `xml:"hostSeedSpec,omitempty" json:"hostSeedSpec,omitempty" vim:"8.0.3.0"` + // ID of a software specification from the repository. + // + // This software specification is created in the repository before + // cluster creation operation or add standalone host operation. + // This desired state software specification will be applied to the + // cluster or the standalone host. + // The lifecycle of the created cluster or the added standalone host + // will be managed by vLCM. + SoftwareSpecId string `xml:"softwareSpecId,omitempty" json:"softwareSpecId,omitempty" vim:"9.0.0.0"` + // Enumeration indicating whether and what kind of netwoork boot mode + // should be configured for the compute resource. + // + // Supported values are + // enumerated in `ComputeResourceNetworkBootMode_enum`. If the + // property is not set not network boot will not be supported by this + // compute resource. + // This property is only supported in `Folder.CreateClusterEx` + // operation. + NetworkBootMode string `xml:"networkBootMode,omitempty" json:"networkBootMode,omitempty" vim:"9.0.0.0"` } func init() { @@ -14865,6 +14997,8 @@ type ConfigTarget struct { // List of distributed virtual switch available for virtual network // adapters. DistributedVirtualSwitch []DistributedVirtualSwitchInfo `xml:"distributedVirtualSwitch,omitempty" json:"distributedVirtualSwitch,omitempty"` + // List of subnets available for virtual network adapters. + SubnetInfo []SubnetInfo `xml:"subnetInfo,omitempty" json:"subnetInfo,omitempty" vim:"9.0.0.0"` // List of CD-ROM devices available for use by virtual CD-ROMs. // // Used for @@ -14962,6 +15096,19 @@ type ConfigTarget struct { MaxSimultaneousThreads int32 `xml:"maxSimultaneousThreads,omitempty" json:"maxSimultaneousThreads,omitempty" vim:"8.0.0.1"` // List of Device Virtualization Extensions (DVX) classes. DvxClassInfo []VirtualMachineDvxClassInfo `xml:"dvxClassInfo,omitempty" json:"dvxClassInfo,omitempty" vim:"8.0.0.1"` + // Indicates whether the compute resource is capable of running AMD Secure + // Encrypted Virtualization Secure Nested Paging (SEV-SNP) enabled virtual + // machines. + // + // The compute resource supports SEV-SNP when this value is set + // to true. + SevSnpSupported *bool `xml:"sevSnpSupported" json:"sevSnpSupported,omitempty" vim:"9.0.0.0"` + // Indicates whether the compute resource is capable of running INTEL Trusted + // Domain Extensions (TDX) enabled virtual machines. + // + // The compute resource + // supports TDX when this value is set to true. + TdxSupported *bool `xml:"tdxSupported" json:"tdxSupported,omitempty" vim:"9.0.0.0"` } func init() { @@ -16303,7 +16450,7 @@ type CreateImportSpecRequestType struct { Datastore ManagedObjectReference `xml:"datastore" json:"datastore"` // Additional parameters to the method, bundled in an instance of // CreateImportSpecParams. - Cisp OvfCreateImportSpecParams `xml:"cisp" json:"cisp"` + Cisp BaseOvfCreateImportSpecParams `xml:"cisp,typeattr" json:"cisp"` } func init() { @@ -17442,6 +17589,10 @@ type CryptoManagerKmipCryptoKeyStatus struct { // // `CryptoManagerKmipCryptoKeyStatusKeyUnavailableReason_enum` lists the set of supported values. Reason string `xml:"reason,omitempty" json:"reason,omitempty"` + // The key info of the wrapped key. + // + // If key is not a wrapped, then it will unset. + KeyInfo BaseCryptoManagerKmipCryptoKeyStatusKeyInfo `xml:"keyInfo,omitempty,typeattr" json:"keyInfo,omitempty" vim:"9.0.0.0"` // The list of VMs which use that key // // Refers instances of `VirtualMachine`. @@ -17458,6 +17609,52 @@ func init() { t["CryptoManagerKmipCryptoKeyStatus"] = reflect.TypeOf((*CryptoManagerKmipCryptoKeyStatus)(nil)).Elem() } +// Base class of key information. +type CryptoManagerKmipCryptoKeyStatusKeyInfo struct { + DynamicData + + // Wrapping Key ID + KeyId string `xml:"keyId" json:"keyId"` +} + +func init() { + t["CryptoManagerKmipCryptoKeyStatusKeyInfo"] = reflect.TypeOf((*CryptoManagerKmipCryptoKeyStatusKeyInfo)(nil)).Elem() + minAPIVersionForType["CryptoManagerKmipCryptoKeyStatusKeyInfo"] = "9.0.0.0" +} + +// Wrapping key ID key information. +type CryptoManagerKmipCryptoKeyStatusWrappingKeyIdKeyInfo struct { + CryptoManagerKmipCryptoKeyStatusKeyInfo + + // Wrapping Key manually configured time. + ConfiguredTime *time.Time `xml:"configuredTime" json:"configuredTime,omitempty"` +} + +func init() { + t["CryptoManagerKmipCryptoKeyStatusWrappingKeyIdKeyInfo"] = reflect.TypeOf((*CryptoManagerKmipCryptoKeyStatusWrappingKeyIdKeyInfo)(nil)).Elem() + minAPIVersionForType["CryptoManagerKmipCryptoKeyStatusWrappingKeyIdKeyInfo"] = "9.0.0.0" +} + +// Wrapping rotation interval key information. +type CryptoManagerKmipCryptoKeyStatusWrappingRotationIntervalKeyInfo struct { + CryptoManagerKmipCryptoKeyStatusKeyInfo + + // Wrapping Key create time. + // + // Will be unset when the creation time is unknown. + CreateTime *time.Time `xml:"createTime" json:"createTime,omitempty"` + // Wrapping Key rotate out time. + // + // Will be unset when the wrapping key has not rotated, or the + // rotation time is unknown. + RotateTime *time.Time `xml:"rotateTime" json:"rotateTime,omitempty"` +} + +func init() { + t["CryptoManagerKmipCryptoKeyStatusWrappingRotationIntervalKeyInfo"] = reflect.TypeOf((*CryptoManagerKmipCryptoKeyStatusWrappingRotationIntervalKeyInfo)(nil)).Elem() + minAPIVersionForType["CryptoManagerKmipCryptoKeyStatusWrappingRotationIntervalKeyInfo"] = "9.0.0.0" +} + // Crypto key custom attribute spec type CryptoManagerKmipCustomAttributeSpec struct { DynamicData @@ -17471,6 +17668,23 @@ func init() { minAPIVersionForType["CryptoManagerKmipCustomAttributeSpec"] = "8.0.1.0" } +// Specification for key generation. +type CryptoManagerKmipGenerateKeySpec struct { + DynamicData + + // Request key type. + // + // If it unset then will use the `KmipClusterInfo.defaultKeyType` + // of the key provider. + // See `KmipClusterInfoKeyType_enum` for supported values. + KeyType string `xml:"keyType,omitempty" json:"keyType,omitempty"` +} + +func init() { + t["CryptoManagerKmipGenerateKeySpec"] = reflect.TypeOf((*CryptoManagerKmipGenerateKeySpec)(nil)).Elem() + minAPIVersionForType["CryptoManagerKmipGenerateKeySpec"] = "9.0.0.0" +} + // Information about the KMIP server certificate. type CryptoManagerKmipServerCertInfo struct { DynamicData @@ -19085,6 +19299,8 @@ type DVPortgroupConfigInfo struct { LogicalSwitchUuid string `xml:"logicalSwitchUuid,omitempty" json:"logicalSwitchUuid,omitempty"` // The segment ID of logical switch SegmentId string `xml:"segmentId,omitempty" json:"segmentId,omitempty"` + // ID of the VPC Subnet when the DVPG is backed by a VPC Subnet + SubnetId string `xml:"subnetId,omitempty" json:"subnetId,omitempty" vim:"9.0.0.0"` } func init() { @@ -19182,6 +19398,8 @@ type DVPortgroupConfigSpec struct { LogicalSwitchUuid string `xml:"logicalSwitchUuid,omitempty" json:"logicalSwitchUuid,omitempty"` // The segment ID of logical switch SegmentId string `xml:"segmentId,omitempty" json:"segmentId,omitempty"` + // The subnet ID of logical switch + SubnetId string `xml:"subnetId,omitempty" json:"subnetId,omitempty" vim:"9.0.0.0"` } func init() { @@ -21199,6 +21417,22 @@ type DatastoreInfo struct { // datastore. // See `DatastoreInfo.containerId`. AliasOf string `xml:"aliasOf,omitempty" json:"aliasOf,omitempty"` + // A list of virtual disk format type which can be supported + // on that datastore. + // + // Supported values are `native_512` and + // `native_4k`. + SupportedVDiskFormats []string `xml:"supportedVDiskFormats,omitempty" json:"supportedVDiskFormats,omitempty" vim:"9.0.0.0"` + // The logical sector size of the datastore. + // + // If not set, + // the default is 512 bytes. + LogicalSectorSize int32 `xml:"logicalSectorSize,omitempty" json:"logicalSectorSize,omitempty" vim:"9.0.0.0"` + // The physical sector size of the datastore. + // + // If not set, + // the default is 512 bytes. + PhysicalSectorSize int32 `xml:"physicalSectorSize,omitempty" json:"physicalSectorSize,omitempty" vim:"9.0.0.0"` } func init() { @@ -22800,6 +23034,535 @@ func init() { t["DigestNotSupportedFault"] = reflect.TypeOf((*DigestNotSupportedFault)(nil)).Elem() } +// Information about a DirectPath profile. +type DirectPathProfileInfo struct { + DynamicData + + // Unique identifier of the DirectPath profile. + Id string `xml:"id" json:"id"` + // Name of the DirectPath profile. + Name string `xml:"name" json:"name"` + // Description of the DirectPath profile. + Description string `xml:"description,omitempty" json:"description,omitempty"` + // Name of the vendor for the device represented by this DirectPath + // profile. + VendorName string `xml:"vendorName" json:"vendorName"` + // Configuration of the DirectPath device represented by this DirectPath + // profile. + // + // Since one DirectPath profile represents one device, the + // configuration will be one of the following types: + // 1\) `DirectPathProfileManagerVmiopDirectPathConfig` + // 2\) `DirectPathProfileManagerDvxDirectPathConfig` + // 3\) `DirectPathProfileManagerDynamicDirectPathConfig` + // 4\) `DirectPathProfileManagerVirtualDeviceGroupDirectPathConfig` + DeviceConfig BaseDirectPathProfileManagerDirectPathConfig `xml:"deviceConfig,typeattr" json:"deviceConfig"` +} + +func init() { + t["DirectPathProfileInfo"] = reflect.TypeOf((*DirectPathProfileInfo)(nil)).Elem() + minAPIVersionForType["DirectPathProfileInfo"] = "9.0.0.0" +} + +// Specification for a successful capacity query result returned from +// `DirectPathProfileManager.DirectPathProfileManagerQueryCapacity`. +// +// The result object contains the +// resulting DirectPath profile and detailed capacity information. +type DirectPathProfileManagerCapacityInfo struct { + DirectPathProfileManagerCapacityResult + + // Detailed information of the DirectPath profile. + // + // See `DirectPathProfileInfo`. + Profile DirectPathProfileInfo `xml:"profile" json:"profile"` + // Number of DirectPath profile units consumed by the powered-on VMs on + // the `DirectPathProfileManagerTargetEntity`. + Consumed int32 `xml:"consumed" json:"consumed"` + // Number of DirectPath profile units that are remaining and have not yet + // been assigned to any powered-on VM on the `DirectPathProfileManagerTargetEntity`. + Remaining int32 `xml:"remaining" json:"remaining"` + // The total capacity of DirectPath profile in the `DirectPathProfileManagerTargetEntity`. + // + // The total capacity of a profile is computed in a theoretical condition + // when no VM is running on the `DirectPathProfileManagerTargetEntity`. In addition, this + // capacity doesn't include the capacity consumed by vSphere's system + // components. + Max int32 `xml:"max" json:"max"` + // Number of DirectPath profile units that are reserved but have not yet + // been assigned to any powered-on VM. + // + // These units can be used to power-on + // VMs for which the capacity has been reserved. This is different from + // remaining capacity because this capacity is actually reserved but just + // unused by any VM whereas remaining capacity indicates what has not even + // been reserved either. For any given DirectPath profile, we will always + // have the constraint: + // max >= consumed + remaining + unusedReservation + UnusedReservation int32 `xml:"unusedReservation" json:"unusedReservation"` +} + +func init() { + t["DirectPathProfileManagerCapacityInfo"] = reflect.TypeOf((*DirectPathProfileManagerCapacityInfo)(nil)).Elem() + minAPIVersionForType["DirectPathProfileManagerCapacityInfo"] = "9.0.0.0" +} + +// Specification describing device config of the DirectPath profile for +// which capacity needs to be queried using +// `DirectPathProfileManager.DirectPathProfileManagerQueryCapacity`. +type DirectPathProfileManagerCapacityQueryByDeviceConfig struct { + DirectPathProfileManagerCapacityQuerySpec + + // Device config of the DirectPath profile. + DeviceConfig BaseDirectPathProfileManagerDirectPathConfig `xml:"deviceConfig,typeattr" json:"deviceConfig"` +} + +func init() { + t["DirectPathProfileManagerCapacityQueryByDeviceConfig"] = reflect.TypeOf((*DirectPathProfileManagerCapacityQueryByDeviceConfig)(nil)).Elem() + minAPIVersionForType["DirectPathProfileManagerCapacityQueryByDeviceConfig"] = "9.0.0.0" +} + +// Specification describing id of the DirectPath profile for which capacity +// needs to be queried using `DirectPathProfileManager.DirectPathProfileManagerQueryCapacity`. +type DirectPathProfileManagerCapacityQueryById struct { + DirectPathProfileManagerCapacityQuerySpec + + // Identifier of the DirectPath profile. + Id string `xml:"id" json:"id"` +} + +func init() { + t["DirectPathProfileManagerCapacityQueryById"] = reflect.TypeOf((*DirectPathProfileManagerCapacityQueryById)(nil)).Elem() + minAPIVersionForType["DirectPathProfileManagerCapacityQueryById"] = "9.0.0.0" +} + +// Specification describing name of the DirectPath profile for which +// capacity needs to be queried using +// `DirectPathProfileManager.DirectPathProfileManagerQueryCapacity`. +type DirectPathProfileManagerCapacityQueryByName struct { + DirectPathProfileManagerCapacityQuerySpec + + // Name of the DirectPath profile. + Name string `xml:"name" json:"name"` +} + +func init() { + t["DirectPathProfileManagerCapacityQueryByName"] = reflect.TypeOf((*DirectPathProfileManagerCapacityQueryByName)(nil)).Elem() + minAPIVersionForType["DirectPathProfileManagerCapacityQueryByName"] = "9.0.0.0" +} + +// Base specification describing information about a DirectPath profile +// for which capacity needs to be queried using +// `DirectPathProfileManager.DirectPathProfileManagerQueryCapacity`. +type DirectPathProfileManagerCapacityQuerySpec struct { + DynamicData +} + +func init() { + t["DirectPathProfileManagerCapacityQuerySpec"] = reflect.TypeOf((*DirectPathProfileManagerCapacityQuerySpec)(nil)).Elem() + minAPIVersionForType["DirectPathProfileManagerCapacityQuerySpec"] = "9.0.0.0" +} + +// Base specification for capacity query result returned from +// `DirectPathProfileManager.DirectPathProfileManagerQueryCapacity`. +// +// Each of the result object +// corresponds to each of the specification described in +// `DirectPathProfileManagerCapacityQuerySpec`. +type DirectPathProfileManagerCapacityResult struct { + DynamicData +} + +func init() { + t["DirectPathProfileManagerCapacityResult"] = reflect.TypeOf((*DirectPathProfileManagerCapacityResult)(nil)).Elem() + minAPIVersionForType["DirectPathProfileManagerCapacityResult"] = "9.0.0.0" +} + +// Specification for an unsuccessful capacity query result returned from +// `DirectPathProfileManager.DirectPathProfileManagerQueryCapacity`. +// +// The result object contains +// the original query specification and detailed fault messages. +type DirectPathProfileManagerCapacityUnknown struct { + DirectPathProfileManagerCapacityResult + + // The query specification associated with the failure. + QuerySpec BaseDirectPathProfileManagerCapacityQuerySpec `xml:"querySpec,typeattr" json:"querySpec"` + // List of faults explaining why the query result is invalid. + // + // The faults + // contain the reason(s) for failure(s). + // Example of failure reasons are the DirectPath profile is not found or + // the name string is too long. + FaultList []LocalizedMethodFault `xml:"faultList,omitempty" json:"faultList,omitempty"` +} + +func init() { + t["DirectPathProfileManagerCapacityUnknown"] = reflect.TypeOf((*DirectPathProfileManagerCapacityUnknown)(nil)).Elem() + minAPIVersionForType["DirectPathProfileManagerCapacityUnknown"] = "9.0.0.0" +} + +type DirectPathProfileManagerCreate DirectPathProfileManagerCreateRequestType + +func init() { + t["DirectPathProfileManagerCreate"] = reflect.TypeOf((*DirectPathProfileManagerCreate)(nil)).Elem() +} + +// The parameters of `DirectPathProfileManager.DirectPathProfileManagerCreate`. +type DirectPathProfileManagerCreateRequestType struct { + This ManagedObjectReference `xml:"_this" json:"-"` + Spec DirectPathProfileManagerCreateSpec `xml:"spec" json:"spec"` +} + +func init() { + t["DirectPathProfileManagerCreateRequestType"] = reflect.TypeOf((*DirectPathProfileManagerCreateRequestType)(nil)).Elem() + minAPIVersionForType["DirectPathProfileManagerCreateRequestType"] = "9.0.0.0" +} + +type DirectPathProfileManagerCreateResponse struct { + Returnval string `xml:"returnval" json:"returnval"` +} + +// Specification describing the parameters used for creating a +// DirectPath profile. +type DirectPathProfileManagerCreateSpec struct { + DynamicData + + // Name of the DirectPath profile. + // + // The name should be less than or equal + // to 80 characters. + Name string `xml:"name" json:"name"` + // Description of the DirectPath profile. + // + // The description should be less + // than 256 characters. + Description string `xml:"description,omitempty" json:"description,omitempty"` + // Configuration of the DirectPath device to be represented. + // + // Since one + // DirectPath profile represents one device, the specified configuration + // can be one of the following types: + // 1\) `DirectPathProfileManagerVmiopDirectPathConfig` + // 2\) `DirectPathProfileManagerDvxDirectPathConfig` + // 3\) `DirectPathProfileManagerDynamicDirectPathConfig` + // 4\) `DirectPathProfileManagerVirtualDeviceGroupDirectPathConfig` + DeviceConfig BaseDirectPathProfileManagerDirectPathConfig `xml:"deviceConfig,typeattr" json:"deviceConfig"` +} + +func init() { + t["DirectPathProfileManagerCreateSpec"] = reflect.TypeOf((*DirectPathProfileManagerCreateSpec)(nil)).Elem() + minAPIVersionForType["DirectPathProfileManagerCreateSpec"] = "9.0.0.0" +} + +type DirectPathProfileManagerDelete DirectPathProfileManagerDeleteRequestType + +func init() { + t["DirectPathProfileManagerDelete"] = reflect.TypeOf((*DirectPathProfileManagerDelete)(nil)).Elem() +} + +// The parameters of `DirectPathProfileManager.DirectPathProfileManagerDelete`. +type DirectPathProfileManagerDeleteRequestType struct { + This ManagedObjectReference `xml:"_this" json:"-"` + // Unique identifier of the DirectPath profile to be deleted. + Id string `xml:"id" json:"id"` +} + +func init() { + t["DirectPathProfileManagerDeleteRequestType"] = reflect.TypeOf((*DirectPathProfileManagerDeleteRequestType)(nil)).Elem() + minAPIVersionForType["DirectPathProfileManagerDeleteRequestType"] = "9.0.0.0" +} + +type DirectPathProfileManagerDeleteResponse struct { +} + +// Base configuration of a DirectPath device. +// +// This contains the information +// about a DirectPath device that is needed for representing the device via +// a DirectPath profile. A DirectPath device can be of different sub-types. +// Each sub-type extends from this base configuration and further defines +// its own properties. +type DirectPathProfileManagerDirectPathConfig struct { + DynamicData +} + +func init() { + t["DirectPathProfileManagerDirectPathConfig"] = reflect.TypeOf((*DirectPathProfileManagerDirectPathConfig)(nil)).Elem() + minAPIVersionForType["DirectPathProfileManagerDirectPathConfig"] = "9.0.0.0" +} + +// Configuration of a DVX DirectPath device. +// +// This configuration represents +// the properties of a DVX device that are needed for creating a DirectPath +// profile. +type DirectPathProfileManagerDvxDirectPathConfig struct { + DirectPathProfileManagerDirectPathConfig + + // Backing that represents the information specific to a DVX device. + // + // See `VirtualPCIPassthroughDvxBackingInfo` for + // details. + DvxBacking VirtualPCIPassthroughDvxBackingInfo `xml:"dvxBacking" json:"dvxBacking"` +} + +func init() { + t["DirectPathProfileManagerDvxDirectPathConfig"] = reflect.TypeOf((*DirectPathProfileManagerDvxDirectPathConfig)(nil)).Elem() + minAPIVersionForType["DirectPathProfileManagerDvxDirectPathConfig"] = "9.0.0.0" +} + +// Configuration of a Dynamic DirectPath device. +// +// This configuration +// represents the properties of a Dynamic DirectPath device that are needed +// for creating a DirectPath profile. +type DirectPathProfileManagerDynamicDirectPathConfig struct { + DirectPathProfileManagerDirectPathConfig + + // Backing that maps a virtual device onto a physical device for a + // Dynamic DirectPath device. + // + // See `VirtualPCIPassthroughDynamicBackingInfo` for + // details. + DynamicDirectPathBacking VirtualPCIPassthroughDynamicBackingInfo `xml:"dynamicDirectPathBacking" json:"dynamicDirectPathBacking"` +} + +func init() { + t["DirectPathProfileManagerDynamicDirectPathConfig"] = reflect.TypeOf((*DirectPathProfileManagerDynamicDirectPathConfig)(nil)).Elem() + minAPIVersionForType["DirectPathProfileManagerDynamicDirectPathConfig"] = "9.0.0.0" +} + +// Specification describing the parameters used to filter the results when +// listing DirectPath profiles in a vCenter (see +// `DirectPathProfileManager.DirectPathProfileManagerList`). +// +// If multiple fields are specified, only +// the DirectPath profiles that match at least one element of each field +// match the filter. +type DirectPathProfileManagerFilterSpec struct { + DynamicData + + // Identifiers of the DirectPath profiles to be retrieved. + // + // If a non-empty + // list of identifiers is specified while listing DirectPath profiles in + // a vCenter (see `DirectPathProfileManager.DirectPathProfileManagerList`), then information about + // every DirectPath profile whose identifier matches with one of the + // specified identifiers will be retrieved. In other words, if identifier + // of a DirectPath profile is not present in the specified list of + // identifiers, then that DirectPath profile will not be retrieved. + Ids []string `xml:"ids,omitempty" json:"ids,omitempty"` + // Names of the DirectPath profiles to be retrieved. + // + // If a non-empty list + // of names is specified while listing DirectPath profiles in a vCenter + // (see `DirectPathProfileManager.DirectPathProfileManagerList`) then information about every + // DirectPath profile whose name matches with one of the specified names + // will be retrieved. In other words, if name of a DirectPath profile is + // not present in the specified list of names, then that DirectPath + // profile will not be retrieved. + Names []string `xml:"names,omitempty" json:"names,omitempty"` + // MoRefs of the vSphere clusters for which DirectPath profiles need + // to be retrieved. + // + // If a non-empty list of cluster MoRefs is specified + // while listing DirectPath profiles in a vCenter + // (see `DirectPathProfileManager.DirectPathProfileManagerList`), then information about the + // DirectPath profiles applicable to all the specified clusters is + // returned. + // + // Refers instances of `ClusterComputeResource`. + Clusters []ManagedObjectReference `xml:"clusters,omitempty" json:"clusters,omitempty"` +} + +func init() { + t["DirectPathProfileManagerFilterSpec"] = reflect.TypeOf((*DirectPathProfileManagerFilterSpec)(nil)).Elem() + minAPIVersionForType["DirectPathProfileManagerFilterSpec"] = "9.0.0.0" +} + +type DirectPathProfileManagerList DirectPathProfileManagerListRequestType + +func init() { + t["DirectPathProfileManagerList"] = reflect.TypeOf((*DirectPathProfileManagerList)(nil)).Elem() +} + +// The parameters of `DirectPathProfileManager.DirectPathProfileManagerList`. +type DirectPathProfileManagerListRequestType struct { + This ManagedObjectReference `xml:"_this" json:"-"` + FilterSpec DirectPathProfileManagerFilterSpec `xml:"filterSpec" json:"filterSpec"` +} + +func init() { + t["DirectPathProfileManagerListRequestType"] = reflect.TypeOf((*DirectPathProfileManagerListRequestType)(nil)).Elem() + minAPIVersionForType["DirectPathProfileManagerListRequestType"] = "9.0.0.0" +} + +type DirectPathProfileManagerListResponse struct { + Returnval []DirectPathProfileInfo `xml:"returnval,omitempty" json:"returnval,omitempty"` +} + +type DirectPathProfileManagerQueryCapacity DirectPathProfileManagerQueryCapacityRequestType + +func init() { + t["DirectPathProfileManagerQueryCapacity"] = reflect.TypeOf((*DirectPathProfileManagerQueryCapacity)(nil)).Elem() +} + +// The parameters of `DirectPathProfileManager.DirectPathProfileManagerQueryCapacity`. +type DirectPathProfileManagerQueryCapacityRequestType struct { + This ManagedObjectReference `xml:"_this" json:"-"` + // specifies the compute resource for which the capacity + // needs to be computed. See `DirectPathProfileManagerTargetEntity`. A null or an invalid + // target will cause an exception. + Target BaseDirectPathProfileManagerTargetEntity `xml:"target,typeattr" json:"target"` + // specifies a list of `DirectPathProfileManagerCapacityQuerySpec`, where each + // of them specifies the information about the DirectPath profile for which + // capacity needs to be computed. + QuerySpec []BaseDirectPathProfileManagerCapacityQuerySpec `xml:"querySpec,omitempty,typeattr" json:"querySpec,omitempty"` +} + +func init() { + t["DirectPathProfileManagerQueryCapacityRequestType"] = reflect.TypeOf((*DirectPathProfileManagerQueryCapacityRequestType)(nil)).Elem() + minAPIVersionForType["DirectPathProfileManagerQueryCapacityRequestType"] = "9.0.0.0" +} + +type DirectPathProfileManagerQueryCapacityResponse struct { + Returnval []BaseDirectPathProfileManagerCapacityResult `xml:"returnval,omitempty,typeattr" json:"returnval,omitempty"` +} + +// Specification of a vSphere cluster as the target entity against which the +// capacity of a DirectPath profile can be queried using +// `DirectPathProfileManager.DirectPathProfileManagerQueryCapacity`. +type DirectPathProfileManagerTargetCluster struct { + DirectPathProfileManagerTargetEntity + + // MoRef of the target vSphere cluster. + // + // Refers instance of `ClusterComputeResource`. + Cluster ManagedObjectReference `xml:"cluster" json:"cluster"` +} + +func init() { + t["DirectPathProfileManagerTargetCluster"] = reflect.TypeOf((*DirectPathProfileManagerTargetCluster)(nil)).Elem() + minAPIVersionForType["DirectPathProfileManagerTargetCluster"] = "9.0.0.0" +} + +// Base specification describing the target entity against which the +// capacity of a DirectPath profile can be queried using +// `DirectPathProfileManager.DirectPathProfileManagerQueryCapacity`. +type DirectPathProfileManagerTargetEntity struct { + DynamicData +} + +func init() { + t["DirectPathProfileManagerTargetEntity"] = reflect.TypeOf((*DirectPathProfileManagerTargetEntity)(nil)).Elem() + minAPIVersionForType["DirectPathProfileManagerTargetEntity"] = "9.0.0.0" +} + +// Specification of an ESXi host as the target entity against which the +// capacity of a DirectPath profile can be queried using +// `DirectPathProfileManager.DirectPathProfileManagerQueryCapacity`. +type DirectPathProfileManagerTargetHost struct { + DirectPathProfileManagerTargetEntity + + // MoRef of the target ESXi host. + // + // Refers instance of `HostSystem`. + Host ManagedObjectReference `xml:"host" json:"host"` +} + +func init() { + t["DirectPathProfileManagerTargetHost"] = reflect.TypeOf((*DirectPathProfileManagerTargetHost)(nil)).Elem() + minAPIVersionForType["DirectPathProfileManagerTargetHost"] = "9.0.0.0" +} + +type DirectPathProfileManagerUpdate DirectPathProfileManagerUpdateRequestType + +func init() { + t["DirectPathProfileManagerUpdate"] = reflect.TypeOf((*DirectPathProfileManagerUpdate)(nil)).Elem() +} + +// The parameters of `DirectPathProfileManager.DirectPathProfileManagerUpdate`. +type DirectPathProfileManagerUpdateRequestType struct { + This ManagedObjectReference `xml:"_this" json:"-"` + // Unique identifier of the DirectPath profile being updated. + Id string `xml:"id" json:"id"` + // Specification for the DirectPath device being updated. + Spec DirectPathProfileManagerUpdateSpec `xml:"spec" json:"spec"` +} + +func init() { + t["DirectPathProfileManagerUpdateRequestType"] = reflect.TypeOf((*DirectPathProfileManagerUpdateRequestType)(nil)).Elem() + minAPIVersionForType["DirectPathProfileManagerUpdateRequestType"] = "9.0.0.0" +} + +type DirectPathProfileManagerUpdateResponse struct { +} + +// Specification describing the parameters used for updating an already +// existing DirectPath profile. +// +// Once a DirectPath profile has been created, +// its `DirectPathProfileManagerDirectPathConfig` cannot be updated. +type DirectPathProfileManagerUpdateSpec struct { + DynamicData + + // The desired name of the DirectPath profile being updated. + // + // The name + // should be less than or equal to 80 characters. + Name string `xml:"name,omitempty" json:"name,omitempty"` + // The desired description of the DirectPath profile being updated. + // + // The + // description should be less than 256 characters. + Description string `xml:"description,omitempty" json:"description,omitempty"` +} + +func init() { + t["DirectPathProfileManagerUpdateSpec"] = reflect.TypeOf((*DirectPathProfileManagerUpdateSpec)(nil)).Elem() + minAPIVersionForType["DirectPathProfileManagerUpdateSpec"] = "9.0.0.0" +} + +// Configuration of a Vendor Device Group. +// +// This configuration represents the +// the properties of a Vendor Device Group that are needed for creating a +// DirectPath profile. +// Vendor Device Groups allow third-parties to define collections of +// devices that must be allocated to a virtual machine as a unit. Typically, +// this is because the set of devices are related in some way, e.g. a +// physical link connects the devices. +type DirectPathProfileManagerVirtualDeviceGroupDirectPathConfig struct { + DirectPathProfileManagerDirectPathConfig + + // Name of the Vendor Device Group. + DeviceGroupName string `xml:"deviceGroupName" json:"deviceGroupName"` +} + +func init() { + t["DirectPathProfileManagerVirtualDeviceGroupDirectPathConfig"] = reflect.TypeOf((*DirectPathProfileManagerVirtualDeviceGroupDirectPathConfig)(nil)).Elem() + minAPIVersionForType["DirectPathProfileManagerVirtualDeviceGroupDirectPathConfig"] = "9.0.0.0" +} + +// Configuration of a VMIOP DirectPath device. +// +// This configuration represents +// the properties of a VMIOP device that are needed for creating a DirectPath +// profile. At present, vGPUs are the only devices implemented using VMIOP +// interface. +type DirectPathProfileManagerVmiopDirectPathConfig struct { + DirectPathProfileManagerDirectPathConfig + + // The name of vGPU configuration type exposed by a VMIOP plugin. + VgpuProfile string `xml:"vgpuProfile" json:"vgpuProfile"` +} + +func init() { + t["DirectPathProfileManagerVmiopDirectPathConfig"] = reflect.TypeOf((*DirectPathProfileManagerVmiopDirectPathConfig)(nil)).Elem() + minAPIVersionForType["DirectPathProfileManagerVmiopDirectPathConfig"] = "9.0.0.0" +} + // This fault is thrown when an operation fails because the specified // directory is not empty. type DirectoryNotEmpty struct { @@ -22967,6 +23730,24 @@ func init() { type DisableMultipathPathResponse struct { } +type DisableNetworkBootRequestType struct { + This ManagedObjectReference `xml:"_this" json:"-"` +} + +func init() { + t["DisableNetworkBootRequestType"] = reflect.TypeOf((*DisableNetworkBootRequestType)(nil)).Elem() +} + +type DisableNetworkBoot_Task DisableNetworkBootRequestType + +func init() { + t["DisableNetworkBoot_Task"] = reflect.TypeOf((*DisableNetworkBoot_Task)(nil)).Elem() +} + +type DisableNetworkBoot_TaskResponse struct { + Returnval ManagedObjectReference `xml:"returnval" json:"returnval"` +} + type DisableRuleset DisableRulesetRequestType func init() { @@ -23574,6 +24355,8 @@ type DistributedVirtualPortgroupInfo struct { LogicalSwitchUuid string `xml:"logicalSwitchUuid,omitempty" json:"logicalSwitchUuid,omitempty"` // The segment ID of logical switch, which is used by NSX portroup SegmentId string `xml:"segmentId,omitempty" json:"segmentId,omitempty"` + // The subnet ID of logical switch + SubnetId string `xml:"subnetId,omitempty" json:"subnetId,omitempty" vim:"9.0.0.0"` } func init() { @@ -26867,6 +27650,27 @@ func init() { type EnableMultipathPathResponse struct { } +// The parameters of `ComputeResource.EnableNetworkBoot_Task`. +type EnableNetworkBootRequestType struct { + This ManagedObjectReference `xml:"_this" json:"-"` + NetworkBootMode string `xml:"networkBootMode" json:"networkBootMode"` +} + +func init() { + t["EnableNetworkBootRequestType"] = reflect.TypeOf((*EnableNetworkBootRequestType)(nil)).Elem() + minAPIVersionForType["EnableNetworkBootRequestType"] = "9.0.0.0" +} + +type EnableNetworkBoot_Task EnableNetworkBootRequestType + +func init() { + t["EnableNetworkBoot_Task"] = reflect.TypeOf((*EnableNetworkBoot_Task)(nil)).Elem() +} + +type EnableNetworkBoot_TaskResponse struct { + Returnval ManagedObjectReference `xml:"returnval" json:"returnval"` +} + type EnableNetworkResourceManagement EnableNetworkResourceManagementRequestType func init() { @@ -27862,6 +28666,41 @@ func init() { t["EventFilterSpecByUsername"] = reflect.TypeOf((*EventFilterSpecByUsername)(nil)).Elem() } +// BaseClass allowing different views on filtered set. +type EventManagerEventViewSpec struct { + DynamicData +} + +func init() { + t["EventManagerEventViewSpec"] = reflect.TypeOf((*EventManagerEventViewSpec)(nil)).Elem() + minAPIVersionForType["EventManagerEventViewSpec"] = "9.0.0.0" +} + +// Defines the view parameters with starting event ID for the event query. +type EventManagerViewByStartId struct { + EventManagerEventViewSpec + + // An integer value specifying the ID of the event from which to start + // the query. + // + // Must be >= 0. The maximum event ID is defined by + // "config.vpxd.event.maxEventId" advanced vCenter configuration option + // which has a default value of 2147480000. + StartEventId int32 `xml:"startEventId" json:"startEventId"` + // A boolean flag indicating the direction of the query. + // + // If true, the query retrieves events with IDs greater than + // startEventId, representing newer events. + // If false, the query retrieves events with IDs less than + // startEventId, representing older events. + IsForward bool `xml:"isForward" json:"isForward"` +} + +func init() { + t["EventManagerViewByStartId"] = reflect.TypeOf((*EventManagerViewByStartId)(nil)).Elem() + minAPIVersionForType["EventManagerViewByStartId"] = "9.0.0.0" +} + type ExecuteHostProfile ExecuteHostProfileRequestType func init() { @@ -29716,6 +30555,12 @@ type FileBackedVirtualDiskSpec struct { Profile []BaseVirtualMachineProfileSpec `xml:"profile,omitempty,typeattr" json:"profile,omitempty"` // Encryption options for the new virtual disk. Crypto BaseCryptoSpec `xml:"crypto,omitempty,typeattr" json:"crypto,omitempty"` + // Optional sector format. + // + // If not specified, an appropriate default format will be choosen by + // the storage system. If available, native\_512 is preferred. + // For the list of supported values, see `DatastoreSectorFormat_enum`. + SectorFormat string `xml:"sectorFormat,omitempty" json:"sectorFormat,omitempty" vim:"9.0.0.0"` } func init() { @@ -30470,6 +31315,23 @@ func init() { t["FolderEventArgument"] = reflect.TypeOf((*FolderEventArgument)(nil)).Elem() } +// Information of externally managed folder. +type FolderExternallyManagedFolderInfo struct { + DynamicData + + // The ID of the folder in the external system. + Id string `xml:"id" json:"id"` + // The type of the externally managed folder. + // + // See `FolderExternallyManagedFolderType_enum` for supported values. + Type string `xml:"type" json:"type"` +} + +func init() { + t["FolderExternallyManagedFolderInfo"] = reflect.TypeOf((*FolderExternallyManagedFolderInfo)(nil)).Elem() + minAPIVersionForType["FolderExternallyManagedFolderInfo"] = "9.0.0.0" +} + type FolderFailedHostResult struct { DynamicData @@ -31087,6 +31949,10 @@ type GenerateKeyRequestType struct { KeyProvider *KeyProviderId `xml:"keyProvider,omitempty" json:"keyProvider,omitempty"` // \[in\] The spec that contains custom attributes key/value pairs. Spec *CryptoManagerKmipCustomAttributeSpec `xml:"spec,omitempty" json:"spec,omitempty" vim:"8.0.1.0"` + // \[in\] The keySpec that contains key generation options. + // If unset, key will be generated with default settings + // of the key provider. + KeySpec *CryptoManagerKmipGenerateKeySpec `xml:"keySpec,omitempty" json:"keySpec,omitempty" vim:"9.0.0.0"` } func init() { @@ -33125,6 +33991,52 @@ func init() { t["HbrManagerVmReplicationCapability"] = reflect.TypeOf((*HbrManagerVmReplicationCapability)(nil)).Elem() } +// The base data type for all different spec operations. +type HbrReplicationTargetSpec struct { + DynamicData +} + +func init() { + t["HbrReplicationTargetSpec"] = reflect.TypeOf((*HbrReplicationTargetSpec)(nil)).Elem() + minAPIVersionForType["HbrReplicationTargetSpec"] = "9.0.0.0" +} + +// TargetSpec represents the settings of remote target on source host. +type HbrTargetSpec struct { + DynamicData + + // The replication target IP address. + TargetIP string `xml:"targetIP" json:"targetIP"` + // The target PEM-encoded certificate. + Certificate string `xml:"certificate" json:"certificate"` +} + +func init() { + t["HbrTargetSpec"] = reflect.TypeOf((*HbrTargetSpec)(nil)).Elem() + minAPIVersionForType["HbrTargetSpec"] = "9.0.0.0" +} + +// Defines replace-all specs on source host operation. +// +// This operation will +// remove all existing specs and will replace them with new ones. +// If specs is empty array, all existing specs will be removed and nothing new +// will be added. +type HbrTargetSpecReplacement struct { + HbrReplicationTargetSpec + + // Array of all new targets. + // + // If this is empty array, nothing new will be + // configured and all existing ones will be deleted. + Spec []HbrTargetSpec `xml:"spec,omitempty" json:"spec,omitempty"` +} + +func init() { + t["HbrTargetSpecReplacement"] = reflect.TypeOf((*HbrTargetSpecReplacement)(nil)).Elem() + minAPIVersionForType["HbrTargetSpecReplacement"] = "9.0.0.0" +} + // Event used to report change in health status of VirtualCenter components. type HealthStatusChangedEvent struct { Event @@ -33597,6 +34509,31 @@ func init() { t["HostAssignableHardwareConfigAttributeOverride"] = reflect.TypeOf((*HostAssignableHardwareConfigAttributeOverride)(nil)).Elem() } +// Authentication information for a host managed by a vCenter +// Server or a vCenter extension to login into other hosts without +// username/password authentication. +type HostAuthenticationInfo struct { + DynamicData + + // The principal used for the login session + Principal string `xml:"principal" json:"principal"` + // The tag associated with this registration. + // + // Owner tags allow + // multiple entities to register the same certificate without + // interfering with each other on the life cycle of the certificate with + // their unique tags. + // Each solution must use a unique tag to identify itself. + OwnerTag string `xml:"ownerTag" json:"ownerTag"` + // Specify the PEM-encoded SSL certificate to register on the host. + SslCertificates []string `xml:"sslCertificates,omitempty" json:"sslCertificates,omitempty"` +} + +func init() { + t["HostAuthenticationInfo"] = reflect.TypeOf((*HostAuthenticationInfo)(nil)).Elem() + minAPIVersionForType["HostAuthenticationInfo"] = "9.0.0.0" +} + // The `HostAuthenticationManagerInfo` data object provides // access to authentication information for the ESX host. type HostAuthenticationManagerInfo struct { @@ -34397,6 +35334,10 @@ type HostCapability struct { VmknicBindingOnNFSv41 *bool `xml:"vmknicBindingOnNFSv41" json:"vmknicBindingOnNFSv41,omitempty" vim:"8.0.3.0"` // Indicates whether VasaProvider Status can be monitored on the host. VpStatusCheckSupported *bool `xml:"vpStatusCheckSupported" json:"vpStatusCheckSupported,omitempty" vim:"8.0.3.0"` + // Indicates whether E2E 4KN capability is supported on the host. + E2e4knSupported *bool `xml:"e2e4knSupported" json:"e2e4knSupported,omitempty" vim:"9.0.0.0"` + // Indicates whether vSAN external vmknic configuration is supported on the host. + VsanDedicatedVmkNicSupported *bool `xml:"vsanDedicatedVmkNicSupported" json:"vsanDedicatedVmkNicSupported,omitempty" vim:"9.0.0.0"` // Indicates whether NFS41 NCONNECT is supported on this host. NConnectSupported *bool `xml:"nConnectSupported" json:"nConnectSupported,omitempty" vim:"8.0.3.0"` // Indicates whether user-provided private key installation is supported on this host. @@ -34410,6 +35351,18 @@ type HostCapability struct { // time UEFI Secure Boot state and its complete configuration. An // out-of-band management channel may also be considered. UefiSecureBoot *bool `xml:"uefiSecureBoot" json:"uefiSecureBoot,omitempty" vim:"8.0.3.0"` + // Indicates whether this host can populate and consume + // `VirtualMachineConfigInfo.vmxRuntimeConfig` property. + VpxdVmxGenerationSupported *bool `xml:"vpxdVmxGenerationSupported" json:"vpxdVmxGenerationSupported,omitempty" vim:"9.0.0.0"` + // Indicates whether this host supports NFS41 + // encryption using KRB5P protocol. + Nfs41Krb5pSupported *bool `xml:"nfs41Krb5pSupported" json:"nfs41Krb5pSupported,omitempty" vim:"9.0.0.0"` + // Indicates whether this host supports CIM + CimSupported *bool `xml:"cimSupported" json:"cimSupported,omitempty" vim:"9.0.0.0"` + // Indicate whether this host supports NPIV + NpivSupported *bool `xml:"npivSupported" json:"npivSupported,omitempty" vim:"9.0.0.0"` + // Indicates whether this host supports license entitlements + EntitlementSupported *bool `xml:"entitlementSupported" json:"entitlementSupported,omitempty" vim:"9.0.0.0"` } func init() { @@ -34450,6 +35403,11 @@ type HostCertificateManagerCertificateSpec struct { // The list of supported values can be found in `HostCertificateManagerCertificateKind_enum` Kind string `xml:"kind" json:"kind"` + // List of subject alternative names to be included in the certificate. + // + // May contain both DNS names and IP addresses. + // If unset, the certificate will contain only its CN as a SAN. + SubjectAlternativeNames []string `xml:"subjectAlternativeNames,omitempty" json:"subjectAlternativeNames,omitempty" vim:"9.0.0.0"` } func init() { @@ -34872,6 +35830,8 @@ type HostConfigInfo struct { SslThumbprintInfo *HostSslThumbprintInfo `xml:"sslThumbprintInfo,omitempty" json:"sslThumbprintInfo,omitempty"` // SSL Thumbprints registered on this host. SslThumbprintData []HostSslThumbprintInfo `xml:"sslThumbprintData,omitempty" json:"sslThumbprintData,omitempty"` + // Authentication info registered on this host. + AuthenticationData []HostAuthenticationInfo `xml:"authenticationData,omitempty" json:"authenticationData,omitempty" vim:"9.0.0.0"` // Full Host Certificate in PEM format, if known Certificate ByteSlice `xml:"certificate,omitempty" json:"certificate,omitempty"` // PCI passthrough information. @@ -35191,6 +36151,11 @@ type HostConfigSummary struct { Port int32 `xml:"port" json:"port"` // The SSL thumbprint of the host, if known. SslThumbprint string `xml:"sslThumbprint,omitempty" json:"sslThumbprint,omitempty"` + // The SSL certificate of the host, if known. + // + // Note: `HostConfigSummary.sslThumbprint` and `HostConfigSummary.sslCertificate` parameters are + // mutually exclusive, and should never be used simultaneously. + SslCertificate string `xml:"sslCertificate,omitempty" json:"sslCertificate,omitempty" vim:"9.0.0.0"` // Information about the software running on the host, if known. // // The current supported hosts are ESX Server 2.0.1 (and later) and VMware Server @@ -35378,6 +36343,14 @@ type HostConnectSpec struct { // xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx // where, 'x' represents a hexadecimal digit SslThumbprint string `xml:"sslThumbprint,omitempty" json:"sslThumbprint,omitempty"` + // The expected SSL certificate of the host in PEM format. + // + // This value is a fallback to be used when the certificate provided + // by the host can not be verified via a trusted CA. A replacement of + // `HostConnectSpec.sslThumbprint`. + // Note: `HostConnectSpec.sslThumbprint` and `HostConnectSpec.sslCertificate` parameters are + // mutually exclusive, and should never be used simultaneously. + SslCertificate string `xml:"sslCertificate,omitempty" json:"sslCertificate,omitempty" vim:"9.0.0.0"` // The administration account on the host. // // (Required for adding @@ -36677,10 +37650,15 @@ type HostDiskPartitionSpec struct { Chs *HostDiskDimensionsChs `xml:"chs,omitempty" json:"chs,omitempty"` // Disk dimensions expressed as a total number of sectors. // - // For sector size, see the `sectorSize` field. + // For sector size, see the `HostDiskPartitionSpec.sectorSize` field. TotalSectors int64 `xml:"totalSectors,omitempty" json:"totalSectors,omitempty"` // List of partitions on the disk. Partition []HostDiskPartitionAttributes `xml:"partition,omitempty" json:"partition,omitempty"` + // The sector size in bytes. + // + // The typical values are 512 and 4096. + // If unset, the value should be considered 512. + SectorSize int32 `xml:"sectorSize,omitempty" json:"sectorSize,omitempty" vim:"9.0.0.0"` } func init() { @@ -37643,6 +38621,8 @@ type HostHardwareInfo struct { // order of tiers (ie, tier 0 at array index 0, tier 1 at array index 1, // and so on). MemoryTierInfo []HostMemoryTierInfo `xml:"memoryTierInfo,omitempty" json:"memoryTierInfo,omitempty" vim:"7.0.3.0"` + // TDX (Trust Domain Extensions) configuration on this host. + TdxInfo *HostTdxInfo `xml:"tdxInfo,omitempty" json:"tdxInfo,omitempty" vim:"9.0.0.0"` } func init() { @@ -37676,6 +38656,8 @@ type HostHardwareSummary struct { Vendor string `xml:"vendor" json:"vendor"` // The system model identification. Model string `xml:"model" json:"model"` + // The system family identification. + Family string `xml:"family,omitempty" json:"family,omitempty" vim:"9.0.0.0"` // The hardware BIOS identification. Uuid string `xml:"uuid" json:"uuid"` // Other identification information. @@ -38557,6 +39539,9 @@ func init() { } // Information about an IO Filter installed on a host. +// +// On vLCM managed cluster, this contains information +// about iofilter at agent level. type HostIoFilterInfo struct { IoFilterInfo @@ -39568,10 +40553,14 @@ type HostMountInfo struct { // If the datastore becomes accessible following an inaccessible condition, // the property `HostMountInfo.inaccessibleReason` will be unset. InaccessibleReason string `xml:"inaccessibleReason,omitempty" json:"inaccessibleReason,omitempty"` - // The name of the vmknic used during mount. + // The name of the vmknic used during mount for NFSv3 datstore. // // Populated by the vmk control layer if the NAS // volume is mounted successfully with a vmknic binding. + // In case of NFS v4.1, if vmknic binding is enabled successfully, + // then output will be in format {hostip1:vmknic1, hostip2:vmknic2}. + // If vmknic binding is not enabled, then vmknicName + // will have 'None' string. VmknicName string `xml:"vmknicName,omitempty" json:"vmknicName,omitempty" vim:"8.0.1.0"` // Indicates whether vmknic is active or inactive. // @@ -40340,6 +41329,12 @@ type HostNetStackInstance struct { // This property is not supported currently. IpV6Enabled *bool `xml:"ipV6Enabled" json:"ipV6Enabled,omitempty"` RouteTableConfig *HostIpRouteTableConfig `xml:"routeTableConfig,omitempty" json:"routeTableConfig,omitempty"` + // Owner of this stack instance. + // + // It is only valid for showing system + // net stack instance. The unset means not owned by the system. + // See `HostConfigChangeOwner_enum` for supported values. + Owner string `xml:"owner,omitempty" json:"owner,omitempty" vim:"9.0.0.0"` } func init() { @@ -41949,6 +42944,10 @@ type HostPciDevice struct { Bus byte `xml:"bus" json:"bus"` // The slot ID of this PCI. Slot byte `xml:"slot" json:"slot"` + // The physical slot of this PCI device + PhysicalSlot int32 `xml:"physicalSlot,omitempty" json:"physicalSlot,omitempty" vim:"9.0.0.0"` + // The slot description + SlotDescription string `xml:"slotDescription,omitempty" json:"slotDescription,omitempty" vim:"9.0.0.0"` // The function ID of this PCI. Function byte `xml:"function" json:"function"` // The vendor ID of this PCI. @@ -43374,6 +44373,11 @@ type HostReconcileDatastoreInventoryRequestType struct { // // Refers instance of `Datastore`. Datastore ManagedObjectReference `xml:"datastore" json:"datastore"` + // If set true, the reconcile task will check for the + // extent files and the disk descriptor file content + // as part of reconciliation. Note that this is a time + // consuming process. + DeepCleansing *bool `xml:"deepCleansing" json:"deepCleansing,omitempty" vim:"9.0.0.0"` } func init() { @@ -43857,6 +44861,11 @@ type HostScheduleReconcileDatastoreInventoryRequestType struct { // // Refers instance of `Datastore`. Datastore ManagedObjectReference `xml:"datastore" json:"datastore"` + // If set true, the reconcile task will check for the + // extent files and the disk descriptor file content + // as part of reconciliation. Note that this is a time + // consuming process. + DeepCleansing *bool `xml:"deepCleansing" json:"deepCleansing,omitempty" vim:"9.0.0.0"` } func init() { @@ -44186,6 +45195,11 @@ type HostServiceTicket struct { // The expected thumbprint of the SSL cert of the host to which // we are connecting. SslThumbprint string `xml:"sslThumbprint,omitempty" json:"sslThumbprint,omitempty"` + // PEM-encoded SSL certificate of the host to which we are connecting. + // + // Note: `HostServiceTicket.sslThumbprint` and `HostServiceTicket.sslCertificate` parameters are + // mutually exclusive, and should never be used simultaneously. + SslCertificate string `xml:"sslCertificate,omitempty" json:"sslCertificate,omitempty" vim:"9.0.0.0"` // The name of the service to which to connect. Service string `xml:"service" json:"service"` // A dot-separated string identifying the service protocol version. @@ -44291,6 +45305,13 @@ type HostSevInfo struct { SevState string `xml:"sevState" json:"sevState"` // The maximum number of SEV-ES and SEV-SNP guests supported on this host. MaxSevEsGuests int64 `xml:"maxSevEsGuests" json:"maxSevEsGuests"` + // State of SEV-SNP (SEV Secure Nested Paging) on the host. + // + // The supported + // values are described in `HostSevInfoSevState_enum`. + SnpState string `xml:"snpState,omitempty" json:"snpState,omitempty" vim:"9.0.0.0"` + // SEV-SNP (SEV Secure Nested Paging) supported + SnpSupported *bool `xml:"snpSupported" json:"snpSupported,omitempty" vim:"9.0.0.0"` } func init() { @@ -44982,6 +46003,8 @@ type HostSystemInfo struct { Vendor string `xml:"vendor" json:"vendor"` // System model identification. Model string `xml:"model" json:"model"` + // System family identification. + Family string `xml:"family,omitempty" json:"family,omitempty" vim:"9.0.0.0"` // Hardware BIOS identification. Uuid string `xml:"uuid" json:"uuid"` // Other System identification information. @@ -45232,6 +46255,25 @@ func init() { minAPIVersionForType["HostTcpTargetTransport"] = "7.0.3.0" } +// Data object describing the TDX (Trust Domain Extensions) configuration +// on the ESXi host. +type HostTdxInfo struct { + DynamicData + + // State of TDX on the host. + // + // The supported values are described in + // `HostTdxInfoTdxState_enum`. + TdxState string `xml:"tdxState" json:"tdxState"` + // The number of TDX private key IDs on this host. + NumTDXPrivateKeyIDs int32 `xml:"numTDXPrivateKeyIDs" json:"numTDXPrivateKeyIDs"` +} + +func init() { + t["HostTdxInfo"] = reflect.TypeOf((*HostTdxInfo)(nil)).Elem() + minAPIVersionForType["HostTdxInfo"] = "9.0.0.0" +} + // This data object type represents result of TPM attestation. type HostTpmAttestationInfo struct { DynamicData @@ -46347,6 +47389,12 @@ type HostVirtualNic struct { // If the Virtual NIC is connected to // DistributedVirtualSwitch or opaque network, this property is unset. Port string `xml:"port,omitempty" json:"port,omitempty"` + // Owner of vmknic. + // + // It is only valid for system vmknic. The unset means + // not owned by the system. + // See `HostConfigChangeOwner_enum` for supported values. + Owner string `xml:"owner,omitempty" json:"owner,omitempty" vim:"9.0.0.0"` } func init() { @@ -47366,6 +48414,8 @@ type HttpNfcLeaseDeviceUrl struct { // Empty if no SSL thumbprint // is available or needed. SslThumbprint string `xml:"sslThumbprint" json:"sslThumbprint"` + // PEM encoded SSL Certificate of the host + SslCertificate string `xml:"sslCertificate,omitempty" json:"sslCertificate,omitempty" vim:"9.0.0.0"` // Optional value to specify if the attached file is a disk in // vmdk format. Disk *bool `xml:"disk" json:"disk,omitempty"` @@ -47646,6 +48696,11 @@ type HttpNfcLeaseSourceFile struct { // Client should verify the server certificate and provide // certificate thumbprint here. SslThumbprint string `xml:"sslThumbprint,omitempty" json:"sslThumbprint,omitempty"` + // PEM encoded SSL Certificate of the source server. + // + // Note: `HttpNfcLeaseSourceFile.sslThumbprint` and `HttpNfcLeaseSourceFile.sslCertificate` parameters are + // mutually exclusive, and should never be used simultaneously. + SslCertificate string `xml:"sslCertificate,omitempty" json:"sslCertificate,omitempty" vim:"9.0.0.0"` // For the case when remote server requires authentication or any other // type of custom HTTP headers be provided with the request. HttpHeaders []KeyValue `xml:"httpHeaders,omitempty" json:"httpHeaders,omitempty"` @@ -48373,6 +49428,30 @@ type InitiateFileTransferToGuestResponse struct { Returnval string `xml:"returnval" json:"returnval"` } +// The parameters of `IoFilterManager.InitiateTransitionToVLCM_Task`. +type InitiateTransitionToVLCMRequestType struct { + This ManagedObjectReference `xml:"_this" json:"-"` + // The cluster. + // + // Refers instance of `ClusterComputeResource`. + Cluster ManagedObjectReference `xml:"cluster" json:"cluster"` +} + +func init() { + t["InitiateTransitionToVLCMRequestType"] = reflect.TypeOf((*InitiateTransitionToVLCMRequestType)(nil)).Elem() + minAPIVersionForType["InitiateTransitionToVLCMRequestType"] = "9.0.0.0" +} + +type InitiateTransitionToVLCM_Task InitiateTransitionToVLCMRequestType + +func init() { + t["InitiateTransitionToVLCM_Task"] = reflect.TypeOf((*InitiateTransitionToVLCM_Task)(nil)).Elem() +} + +type InitiateTransitionToVLCM_TaskResponse struct { + Returnval ManagedObjectReference `xml:"returnval" json:"returnval"` +} + // The parameters of `HostPatchManager.InstallHostPatch_Task`. type InstallHostPatchRequestType struct { This ManagedObjectReference `xml:"_this" json:"-"` @@ -50380,6 +51459,29 @@ type IsClusteredVmdkEnabledResponse struct { Returnval bool `xml:"returnval" json:"returnval"` } +type IsGuestOsCustomizable IsGuestOsCustomizableRequestType + +func init() { + t["IsGuestOsCustomizable"] = reflect.TypeOf((*IsGuestOsCustomizable)(nil)).Elem() +} + +// The parameters of `CustomizationSpecManager.IsGuestOsCustomizable`. +type IsGuestOsCustomizableRequestType struct { + This ManagedObjectReference `xml:"_this" json:"-"` + // Short name from the guest OS descriptor list describing the + // OS we intend to check. + GuestId string `xml:"guestId" json:"guestId"` +} + +func init() { + t["IsGuestOsCustomizableRequestType"] = reflect.TypeOf((*IsGuestOsCustomizableRequestType)(nil)).Elem() + minAPIVersionForType["IsGuestOsCustomizableRequestType"] = "9.0.0.0" +} + +type IsGuestOsCustomizableResponse struct { + Returnval bool `xml:"returnval" json:"returnval"` +} + type IsKmsClusterActive IsKmsClusterActiveRequestType func init() { @@ -51002,12 +52104,60 @@ type KmipClusterInfo struct { HasBackup *bool `xml:"hasBackup" json:"hasBackup,omitempty" vim:"7.0.2.0"` TpmRequired *bool `xml:"tpmRequired" json:"tpmRequired,omitempty" vim:"7.0.2.0"` KeyId string `xml:"keyId,omitempty" json:"keyId,omitempty" vim:"7.0.2.0"` + // Key type which the key provider generates by default. + // + // See `KmipClusterInfoKeyType_enum` for supported values. + DefaultKeyType string `xml:"defaultKeyType,omitempty" json:"defaultKeyType,omitempty" vim:"9.0.0.0"` + // Key information. + KeyInfo BaseKmipClusterInfoKeyInfo `xml:"keyInfo,omitempty,typeattr" json:"keyInfo,omitempty" vim:"9.0.0.0"` } func init() { t["KmipClusterInfo"] = reflect.TypeOf((*KmipClusterInfo)(nil)).Elem() } +// Base class of key information. +type KmipClusterInfoKeyInfo struct { + DynamicData +} + +func init() { + t["KmipClusterInfoKeyInfo"] = reflect.TypeOf((*KmipClusterInfoKeyInfo)(nil)).Elem() + minAPIVersionForType["KmipClusterInfoKeyInfo"] = "9.0.0.0" +} + +// Wrapping key ID key information. +type KmipClusterInfoWrappingKeyIdKeyInfo struct { + KmipClusterInfoKeyInfo + + // Wrapping key identifier. + KeyId string `xml:"keyId" json:"keyId"` + // The time when `KmipClusterInfoWrappingKeyIdKeyInfo.keyId` was set as the wrapping key ID. + ConfiguredTime time.Time `xml:"configuredTime" json:"configuredTime"` +} + +func init() { + t["KmipClusterInfoWrappingKeyIdKeyInfo"] = reflect.TypeOf((*KmipClusterInfoWrappingKeyIdKeyInfo)(nil)).Elem() + minAPIVersionForType["KmipClusterInfoWrappingKeyIdKeyInfo"] = "9.0.0.0" +} + +// Wrapping rotation interval key information. +type KmipClusterInfoWrappingRotationIntervalKeyInfo struct { + KmipClusterInfoKeyInfo + + // Wrapping key identifier. + KeyId string `xml:"keyId,omitempty" json:"keyId,omitempty"` + // Wrapping key rotation interval (number of days). + RotationInterval int32 `xml:"rotationInterval,omitempty" json:"rotationInterval,omitempty"` + // Last wrapping key rotation timestamp. + LastRotation *time.Time `xml:"lastRotation" json:"lastRotation,omitempty"` +} + +func init() { + t["KmipClusterInfoWrappingRotationIntervalKeyInfo"] = reflect.TypeOf((*KmipClusterInfoWrappingRotationIntervalKeyInfo)(nil)).Elem() + minAPIVersionForType["KmipClusterInfoWrappingRotationIntervalKeyInfo"] = "9.0.0.0" +} + // Data Object representing a KMIP server connection information. type KmipServerInfo struct { DynamicData @@ -51068,12 +52218,64 @@ type KmipServerSpec struct { // // Set value to empty string to delete the entry. Password string `xml:"password,omitempty" json:"password,omitempty"` + // Key type which the key provider generates by default. + // + // See `KmipClusterInfoKeyType_enum` for supported values. + DefaultKeyType string `xml:"defaultKeyType,omitempty" json:"defaultKeyType,omitempty" vim:"9.0.0.0"` + // Specification of key. + KeySpec BaseKmipServerSpecKeySpec `xml:"keySpec,omitempty,typeattr" json:"keySpec,omitempty" vim:"9.0.0.0"` } func init() { t["KmipServerSpec"] = reflect.TypeOf((*KmipServerSpec)(nil)).Elem() } +// Base class of key specification. +type KmipServerSpecKeySpec struct { + DynamicData +} + +func init() { + t["KmipServerSpecKeySpec"] = reflect.TypeOf((*KmipServerSpecKeySpec)(nil)).Elem() + minAPIVersionForType["KmipServerSpecKeySpec"] = "9.0.0.0" +} + +// Wrapping key ID key specification. +// +// Key rotation will not occur automatically when a client +// specified key ID is used. +type KmipServerSpecWrappingKeyIdKeySpec struct { + KmipServerSpecKeySpec + + // Wrapping key identifier. + KeyId string `xml:"keyId" json:"keyId"` +} + +func init() { + t["KmipServerSpecWrappingKeyIdKeySpec"] = reflect.TypeOf((*KmipServerSpecWrappingKeyIdKeySpec)(nil)).Elem() + minAPIVersionForType["KmipServerSpecWrappingKeyIdKeySpec"] = "9.0.0.0" +} + +// Wrapping rotation interval key specification. +// +// The wrapping key will be created automatically and will rotate +// automatically based on the rotation interval. +type KmipServerSpecWrappingRotationIntervalKeySpec struct { + KmipServerSpecKeySpec + + // Wrapping key regular rotation interval (number of days). + // + // The allowed minimum number of days is 30 days, + // and maximum number of days is 3650 days. + // If not set, then a system default number of days will be used. + RotationInterval int32 `xml:"rotationInterval,omitempty" json:"rotationInterval,omitempty"` +} + +func init() { + t["KmipServerSpecWrappingRotationIntervalKeySpec"] = reflect.TypeOf((*KmipServerSpecWrappingRotationIntervalKeySpec)(nil)).Elem() + minAPIVersionForType["KmipServerSpecWrappingRotationIntervalKeySpec"] = "9.0.0.0" +} + // Data Object representing a KMIP server status. type KmipServerStatus struct { DynamicData @@ -58257,6 +59459,21 @@ func init() { t["OvfCreateImportSpecResult"] = reflect.TypeOf((*OvfCreateImportSpecResult)(nil)).Elem() } +// A DatastoreMapping is a choice made by the caller about which datastore to +// use for a specific disk in the OVF descriptor as specified by "ovf:diskId". +type OvfDatastoreMapping struct { + DynamicData + + DiskId string `xml:"diskId" json:"diskId"` + // Refers instance of `Datastore`. + Datastore ManagedObjectReference `xml:"datastore" json:"datastore"` +} + +func init() { + t["OvfDatastoreMapping"] = reflect.TypeOf((*OvfDatastoreMapping)(nil)).Elem() + minAPIVersionForType["OvfDatastoreMapping"] = "9.0.0.0" +} + // A deployment option as defined in the OVF specfication. // // This corresponds to the Configuration element of the DeploymentOptionSection in the @@ -58764,6 +59981,64 @@ func init() { t["OvfImportFault"] = reflect.TypeOf((*OvfImportFault)(nil)).Elem() } +// Custom parameters used while deploying an OVF. +type OvfImportParams struct { + OvfCreateImportSpecParams + + // Use Push mode for transferring VM files to ESX. + // + // Push mode transfers + // files from client to ESXi, whereas in Pull mode ESX "pulls" the files + // directly from source. This flag only applies to vCenter as ESXi + // can only pull directly if `OvfManager.DeployVm_Task` is invoked + // on ESX itself. + // See (@link vim.HttpNfcLease#pullFromUrls) for more on Pull mode. + // The default/Default: false + PushMode *bool `xml:"pushMode" json:"pushMode,omitempty"` + // Require that the OVF package has a signed certificate and manifest + // and both match. + // + // See also manifest validation. + // Default is false. + SignatureRequired *bool `xml:"signatureRequired" json:"signatureRequired,omitempty"` + // If a manifest file is present in the OVF package the format is checked. + // + // Also all file SHA entries are validated against SHA of read files. If + // value is true and manifest file is present a warning is generated. + // Default is false. + SkipManifestCheck *bool `xml:"skipManifestCheck" json:"skipManifestCheck,omitempty"` + // Whether to power on the deployed entity. + // + // Note for ESX and Virtual Machine deployment: In order to customize + // GuestOS on a deployed Virtual Machine we require that the + // powerOn flag must be true. GuestOS customization happens + // after VM is powered On and then reconfigured. vCenter does not + // require a powerOn and reconfigure to customize GuestOS as it + // stores all OVF properties as VApp properties and pushes them to + // GuestOS upon powerOn for consumption. + // Default is false. + PowerOn *bool `xml:"powerOn" json:"powerOn,omitempty"` + // For the case when remote server requires authentication or any other + // type of custom HTTP headers be provided with the request. + CustomHttpHeaders []KeyValue `xml:"customHttpHeaders,omitempty" json:"customHttpHeaders,omitempty"` + // Optionally used for source validation. + // + // The source server certificate + // in PEM format. + SourceCertificate string `xml:"sourceCertificate,omitempty" json:"sourceCertificate,omitempty"` + // The optional datastore mapping(s). + DatastoreMappings []OvfDatastoreMapping `xml:"datastoreMappings,omitempty" json:"datastoreMappings,omitempty"` + // The optional Storage Profile Id for VM's home. + VmProfile string `xml:"vmProfile,omitempty" json:"vmProfile,omitempty"` + // The optional Storage Profile mapping(s). + DiskProfiles []OvfStorageProfileMapping `xml:"diskProfiles,omitempty" json:"diskProfiles,omitempty"` +} + +func init() { + t["OvfImportParams"] = reflect.TypeOf((*OvfImportParams)(nil)).Elem() + minAPIVersionForType["OvfImportParams"] = "9.0.0.0" +} + // Disk mode not supported type OvfInternalError struct { OvfSystemFault @@ -59436,6 +60711,23 @@ func init() { t["OvfResourceMap"] = reflect.TypeOf((*OvfResourceMap)(nil)).Elem() } +// A StorageProfileMapping is the mapping of diskId in "ovf:diskId" field in +// OVF to the Storage Profile Id(SPBM ID) in the inventory. +// +// The SPBM profile +// ID will apply to non-PMem disks only. +type OvfStorageProfileMapping struct { + DynamicData + + DiskId string `xml:"diskId" json:"diskId"` + StorageProfileId string `xml:"storageProfileId" json:"storageProfileId"` +} + +func init() { + t["OvfStorageProfileMapping"] = reflect.TypeOf((*OvfStorageProfileMapping)(nil)).Elem() + minAPIVersionForType["OvfStorageProfileMapping"] = "9.0.0.0" +} + // A common base class to host all the OVF subsystems's system faults. // // This is a class of fault that can be thrown because of @@ -63755,6 +65047,13 @@ type QueryConnectionInfoRequestType struct { Password string `xml:"password" json:"password"` // The expected SSL thumbprint of the host's certificate. SslThumbprint string `xml:"sslThumbprint,omitempty" json:"sslThumbprint,omitempty"` + // The expected SSL certificate of the host in PEM format. + // This parameter is a fallback to be used when the certificate provided + // by the host can not be verified via a trusted CA. A replacement of + // `sslThumbprint`. + // Note: `sslThumbprint` and `sslCertificate` parameters are + // mutually exclusive, and should never be used simultaneously. + SslCertificate string `xml:"sslCertificate,omitempty" json:"sslCertificate,omitempty" vim:"9.0.0.0"` } func init() { @@ -64117,8 +65416,22 @@ func init() { // The parameters of `EventManager.QueryEvents`. type QueryEventsRequestType struct { This ManagedObjectReference `xml:"_this" json:"-"` - // The events qualified. + // Defines a filtering criteria for the event query. Filter EventFilterSpec `xml:"filter" json:"filter"` + // Defines the view parameters for the event query. + // + // To retrieve the newest events in the system, use 2147480000 + // (or the value of "config.vpxd.event.maxEventId" advanced vCenter + // configuration option) as `EventManagerViewByStartId.startEventId` and + // set `EventManagerViewByStartId.isForward` to false. To retrieve subsequent + // pages of results with older events, use the smallest event ID + // from the previous response as the `EventManagerViewByStartId.startEventId` + // and set`EventManagerViewByStartId.isForward` to false in the next query. + // To retrieve subsequent pages of results with newer events, use + // the biggest event ID from the previous page as the + // `EventManagerViewByStartId.startEventId` and set + // `EventManagerViewByStartId.isForward` to true in the next query. + EventViewSpec BaseEventManagerEventViewSpec `xml:"eventViewSpec,omitempty,typeattr" json:"eventViewSpec,omitempty" vim:"9.0.0.0"` } func init() { @@ -66234,6 +67547,32 @@ func init() { t["ReadNextTasks"] = reflect.TypeOf((*ReadNextTasks)(nil)).Elem() } +type ReadNextTasksByViewSpec ReadNextTasksByViewSpecRequestType + +func init() { + t["ReadNextTasksByViewSpec"] = reflect.TypeOf((*ReadNextTasksByViewSpec)(nil)).Elem() +} + +// The parameters of `TaskManager.ReadNextTasksByViewSpec`. +type ReadNextTasksByViewSpecRequestType struct { + This ManagedObjectReference `xml:"_this" json:"-"` + // The view parameters for the tasks query. + ViewSpec BaseTaskManagerTaskViewSpec `xml:"viewSpec,typeattr" json:"viewSpec"` + // The specification for the task query filter. + FilterSpec TaskFilterSpec `xml:"filterSpec" json:"filterSpec"` + // The specification for the task info filter. + InfoFilterSpec *TaskInfoFilterSpec `xml:"infoFilterSpec,omitempty" json:"infoFilterSpec,omitempty"` +} + +func init() { + t["ReadNextTasksByViewSpecRequestType"] = reflect.TypeOf((*ReadNextTasksByViewSpecRequestType)(nil)).Elem() + minAPIVersionForType["ReadNextTasksByViewSpecRequestType"] = "9.0.0.0" +} + +type ReadNextTasksByViewSpecResponse struct { + Returnval []TaskInfo `xml:"returnval,omitempty" json:"returnval,omitempty"` +} + // The parameters of `TaskHistoryCollector.ReadNextTasks`. type ReadNextTasksRequestType struct { This ManagedObjectReference `xml:"_this" json:"-"` @@ -66449,6 +67788,29 @@ type RecommissionVsanNode_TaskResponse struct { Returnval ManagedObjectReference `xml:"returnval" json:"returnval"` } +// The parameters of `VcenterVStorageObjectManager.ReconcileDatastoreInventoryEx_Task`. +type ReconcileDatastoreInventoryExRequestType struct { + This ManagedObjectReference `xml:"_this" json:"-"` + // The specification to reconcile/scan a datastore for virtual + // storage objects. + Spec VStorageObjectReconcileSpec `xml:"spec" json:"spec"` +} + +func init() { + t["ReconcileDatastoreInventoryExRequestType"] = reflect.TypeOf((*ReconcileDatastoreInventoryExRequestType)(nil)).Elem() + minAPIVersionForType["ReconcileDatastoreInventoryExRequestType"] = "9.0.0.0" +} + +type ReconcileDatastoreInventoryEx_Task ReconcileDatastoreInventoryExRequestType + +func init() { + t["ReconcileDatastoreInventoryEx_Task"] = reflect.TypeOf((*ReconcileDatastoreInventoryEx_Task)(nil)).Elem() +} + +type ReconcileDatastoreInventoryEx_TaskResponse struct { + Returnval ManagedObjectReference `xml:"returnval" json:"returnval"` +} + // The parameters of `VcenterVStorageObjectManager.ReconcileDatastoreInventory_Task`. type ReconcileDatastoreInventoryRequestType struct { This ManagedObjectReference `xml:"_this" json:"-"` @@ -66456,6 +67818,11 @@ type ReconcileDatastoreInventoryRequestType struct { // // Refers instance of `Datastore`. Datastore ManagedObjectReference `xml:"datastore" json:"datastore"` + // If set true, the reconcile task will check for the + // extent files and the disk descriptor file content + // as part of reconciliation. Note that this is a time + // consuming process. + DeepCleansing *bool `xml:"deepCleansing" json:"deepCleansing,omitempty" vim:"9.0.0.0"` } func init() { @@ -67369,8 +68736,8 @@ type RegisterKmipServerRequestType struct { This ManagedObjectReference `xml:"_this" json:"-"` // \[in\] KMIP server connection information. // When register a new KMIP server to the key provider, - // the `KmipServerSpec#defaultKeyType` and - // `KmipServerSpec#wrappingKeySpec` must match + // the `KmipServerSpec.defaultKeyType` and + // `KmipServerSpecWrappingKeyIdKeySpec` must match // existing servers. Server KmipServerSpec `xml:"server" json:"server"` } @@ -68364,6 +69731,27 @@ func init() { type RemoveSmartCardTrustAnchorByFingerprintResponse struct { } +type RemoveSmartCardTrustAnchorCertificate RemoveSmartCardTrustAnchorCertificateRequestType + +func init() { + t["RemoveSmartCardTrustAnchorCertificate"] = reflect.TypeOf((*RemoveSmartCardTrustAnchorCertificate)(nil)).Elem() +} + +// The parameters of `HostActiveDirectoryAuthentication.RemoveSmartCardTrustAnchorCertificate`. +type RemoveSmartCardTrustAnchorCertificateRequestType struct { + This ManagedObjectReference `xml:"_this" json:"-"` + // PEM encoded certificate to remove + Certificate string `xml:"certificate" json:"certificate"` +} + +func init() { + t["RemoveSmartCardTrustAnchorCertificateRequestType"] = reflect.TypeOf((*RemoveSmartCardTrustAnchorCertificateRequestType)(nil)).Elem() + minAPIVersionForType["RemoveSmartCardTrustAnchorCertificateRequestType"] = "9.0.0.0" +} + +type RemoveSmartCardTrustAnchorCertificateResponse struct { +} + // The parameters of `HostActiveDirectoryAuthentication.RemoveSmartCardTrustAnchor`. type RemoveSmartCardTrustAnchorRequestType struct { This ManagedObjectReference `xml:"_this" json:"-"` @@ -68783,7 +70171,7 @@ type ReplicationConfigSpec struct { // This field is only relevant when net encryption is enabled. EncryptionPort int32 `xml:"encryptionPort,omitempty" json:"encryptionPort,omitempty"` // Deprecated field is deprecated, use - // `vim.HbrManager.configureReplicationTargets` instead. + // `HbrManager.HbrConfigureReplicationTargets_Task` instead. // // The SHA256 thumbprint of the remote server certificate. // @@ -71443,6 +72831,10 @@ type SSLVerifyFault struct { // // This field is optional since vSphere 8.0u2. Thumbprint string `xml:"thumbprint,omitempty" json:"thumbprint,omitempty"` + // The certificate of the host + // Note: `SSLVerifyFault.thumbprint` and `SSLVerifyFault.certificate` parameters are + // mutually exclusive, and should never be used simultaneously. + Certificate string `xml:"certificate,omitempty" json:"certificate,omitempty" vim:"9.0.0.0"` } func init() { @@ -71585,6 +72977,11 @@ type ScheduleReconcileDatastoreInventoryRequestType struct { // // Refers instance of `Datastore`. Datastore ManagedObjectReference `xml:"datastore" json:"datastore"` + // If set true, the reconcile task will check for the + // extent files and the disk descriptor file content + // as part of reconciliation. Note that this is a time + // consuming process. + DeepCleansing *bool `xml:"deepCleansing" json:"deepCleansing,omitempty" vim:"9.0.0.0"` } func init() { @@ -72735,6 +74132,10 @@ type ServiceContent struct { // // Refers instance of `StorageQueryManager`. StorageQueryManager *ManagedObjectReference `xml:"storageQueryManager,omitempty" json:"storageQueryManager,omitempty"` + // A singleton managed object used to query DirectPath profiles. + // + // Refers instance of `DirectPathProfileManager`. + DirectPathProfileManager *ManagedObjectReference `xml:"directPathProfileManager,omitempty" json:"directPathProfileManager,omitempty" vim:"9.0.0.0"` } func init() { @@ -72759,10 +74160,16 @@ type ServiceLocator struct { Credential BaseServiceLocatorCredential `xml:"credential,typeattr" json:"credential"` // The SSL thumbprint of the certificate of the service endpoint. // - // Superceded by `#sslCertificate`. + // Superceded by `ServiceLocator.sslCertificate`. // Note: If both sslThumbprint and sslCertificate are set, // sslThumbprint must correspond to the sslCertificate. SslThumbprint string `xml:"sslThumbprint,omitempty" json:"sslThumbprint,omitempty"` + // The SSL certificate of the service endpoint in PEM format. + // + // A replacement for `ServiceLocator.sslThumbprint`. + // Note: If both sslThumbprint and sslCertificate are set, + // sslThumbprint must correspond to the sslCertificate. + SslCertificate string `xml:"sslCertificate,omitempty" json:"sslCertificate,omitempty" vim:"9.0.0.0"` } func init() { @@ -72920,6 +74327,13 @@ type SessionManagerGenericServiceTicket struct { // includes all hash types that are considered secure. See vmware.com // for the current security standards. CertThumbprintList []VirtualMachineCertThumbprint `xml:"certThumbprintList,omitempty" json:"certThumbprintList,omitempty" vim:"7.0.3.1"` + // Supported only by vCenter. + // + // The expected SSL certificate of the host to which we are connecting + // to, in PEM format. + // Note: `SessionManagerGenericServiceTicket.sslThumbprint` and `SessionManagerGenericServiceTicket.sslCertificate` parameters are + // mutually exclusive, and should never be used simultaneously. + SslCertificate string `xml:"sslCertificate,omitempty" json:"sslCertificate,omitempty" vim:"9.0.0.0"` // Type of the ticket // See { @Vim::SessionManager::GenericServiceTicket::TicketType } TicketType string `xml:"ticketType,omitempty" json:"ticketType,omitempty" vim:"7.0.2.0"` @@ -75385,7 +76799,7 @@ type StorageIORMConfigSpec struct { // datastore is higher than specified threshold value. // // This value (if present) overrides - // `vim.StorageResourceManager.PodConfigInfo.reservableIopsThreshold` + // `StorageIORMInfo.reservableIopsThreshold` ReservableIopsThreshold int32 `xml:"reservableIopsThreshold,omitempty" json:"reservableIopsThreshold,omitempty"` } @@ -75437,7 +76851,7 @@ type StorageIORMInfo struct { // datastore is higher than specified threshold value. // // This value (if present) overrides - // `vim.StorageResourceManager.PodConfigInfo.reservableIopsThreshold` + // `StorageIORMInfo.reservableIopsThreshold` ReservableIopsThreshold int32 `xml:"reservableIopsThreshold,omitempty" json:"reservableIopsThreshold,omitempty"` } @@ -75899,6 +77313,41 @@ func init() { t["StructuredCustomizations"] = reflect.TypeOf((*StructuredCustomizations)(nil)).Elem() } +type SubnetInfo struct { + VirtualMachineTargetInfo + + // The ID of the subnet + Id string `xml:"id" json:"id"` + // The subnet folder info + SubnetFolderInfo SubnetInfoFolderInfo `xml:"subnetFolderInfo" json:"subnetFolderInfo"` + // The VPC folder info + VpcFolderInfo SubnetInfoFolderInfo `xml:"vpcFolderInfo" json:"vpcFolderInfo"` + // The project folder info + ProjectFolderInfo *SubnetInfoFolderInfo `xml:"projectFolderInfo,omitempty" json:"projectFolderInfo,omitempty"` + // The root folder info. + // + // root folder can be either "Virtual Private Clouds" or "NSX Managed Folders" + RootFolderInfo SubnetInfoFolderInfo `xml:"rootFolderInfo" json:"rootFolderInfo"` +} + +func init() { + t["SubnetInfo"] = reflect.TypeOf((*SubnetInfo)(nil)).Elem() + minAPIVersionForType["SubnetInfo"] = "9.0.0.0" +} + +type SubnetInfoFolderInfo struct { + DynamicData + + Name string `xml:"name" json:"name"` + // Refers instance of `Folder`. + Folder ManagedObjectReference `xml:"folder" json:"folder"` +} + +func init() { + t["SubnetInfoFolderInfo"] = reflect.TypeOf((*SubnetInfoFolderInfo)(nil)).Elem() + minAPIVersionForType["SubnetInfoFolderInfo"] = "9.0.0.0" +} + type SuspendVAppRequestType struct { This ManagedObjectReference `xml:"_this" json:"-"` } @@ -76468,6 +77917,46 @@ func init() { minAPIVersionForType["TaskInfoFilterSpecFilterTaskResults"] = "8.0.3.0" } +// `TaskManagerTaskViewSpec` provides the specifications +// for returning the set of tasks in the +// Task Console. +type TaskManagerTaskViewSpec struct { + DynamicData +} + +func init() { + t["TaskManagerTaskViewSpec"] = reflect.TypeOf((*TaskManagerTaskViewSpec)(nil)).Elem() + minAPIVersionForType["TaskManagerTaskViewSpec"] = "9.0.0.0" +} + +// Defines the view parameters with starting task ID for the task query. +type TaskManagerViewByStartId struct { + TaskManagerTaskViewSpec + + // The page size to be fetched. + // + // When the value is > 0, the query will fetch tasks older than + // the specified task in `TaskManagerViewByStartId.startId` parameter with lesser task IDs. + // (Next page when the tasks are shown with the newest task first) + // When the value is < 0, the query will fetch tasks newer than + // the specified task in `TaskManagerViewByStartId.startId` parameter with greater task IDs. + // (Previous page when the tasks are shown with the newest task first) + Count int32 `xml:"count" json:"count"` + // Specifies the `TaskInfo.key` of the task from which to + // start the query. + // + // If it is set to an empty string and `TaskManagerViewByStartId.count` > 0, + // the query will return the latest (newest) `TaskManagerViewByStartId.count` tasks in the system. + // In order to read the oldest tasks in the system, the caller should set this + // field to "task-0" and `TaskManagerViewByStartId.count` to a negative number. + StartId string `xml:"startId" json:"startId"` +} + +func init() { + t["TaskManagerViewByStartId"] = reflect.TypeOf((*TaskManagerViewByStartId)(nil)).Elem() + minAPIVersionForType["TaskManagerViewByStartId"] = "9.0.0.0" +} + // Base type for all task reasons. // // Task reasons represent the kind of entity responsible for a task's creation. @@ -78867,8 +80356,8 @@ type UpdateKmipServerRequestType struct { This ManagedObjectReference `xml:"_this" json:"-"` // \[in\] KMIP server connection information. // When update a KMIP server settings, changes to - // `KmipServerSpec#defaultKeyType` and - // `KmipServerSpec#wrappingKeySpec` + // `KmipServerSpec.defaultKeyType` and + // `KmipServerSpecWrappingKeyIdKeySpec` // will apply to all servers. Server KmipServerSpec `xml:"server" json:"server"` } @@ -81576,6 +83065,8 @@ type VMwareDVSConfigInfo struct { // (`VMwareDVSConfigInfo.networkOffloadSpecId` // is not "None"). NetworkOffloadConfig *VmwareDistributedVirtualSwitchNetworkOffloadConfig `xml:"networkOffloadConfig,omitempty" json:"networkOffloadConfig,omitempty" vim:"8.0.3.0"` + // The real-time specific configuration of the switch. + RealTimeConfig *VmwareDistributedVirtualSwitchRealTimeConfig `xml:"realTimeConfig,omitempty" json:"realTimeConfig,omitempty" vim:"8.0.3.1"` } func init() { @@ -81650,6 +83141,8 @@ type VMwareDVSConfigSpec struct { // (`VMwareDVSConfigInfo.networkOffloadSpecId` // is not "None"). NetworkOffloadConfig *VmwareDistributedVirtualSwitchNetworkOffloadConfig `xml:"networkOffloadConfig,omitempty" json:"networkOffloadConfig,omitempty" vim:"8.0.3.0"` + // The real-time specific configuration of the switch. + RealTimeConfig *VmwareDistributedVirtualSwitchRealTimeConfig `xml:"realTimeConfig,omitempty" json:"realTimeConfig,omitempty" vim:"8.0.3.1"` } func init() { @@ -81698,6 +83191,12 @@ type VMwareDVSFeatureCapability struct { NsxSupported *bool `xml:"nsxSupported" json:"nsxSupported,omitempty"` // The support for version-specific supported MTU. MtuCapability *VMwareDvsMtuCapability `xml:"mtuCapability,omitempty" json:"mtuCapability,omitempty" vim:"7.0.2.0"` + // Flag to indicate whether real-time configuration is supported on + // Distributed Switch. + // + // Real-time configuration is supported in vSphere Distributed Switch + // Version 9.0 or later. + RealTimeConfigSupported *bool `xml:"realTimeConfigSupported" json:"realTimeConfigSupported,omitempty" vim:"8.0.3.1"` } func init() { @@ -82233,11 +83732,18 @@ type VMwareIpfixConfig struct { // // Legal value range is 60-3600. Default: 60. ActiveFlowTimeout int32 `xml:"activeFlowTimeout" json:"activeFlowTimeout"` + // Deprecated as of vSphere API 9.0 + // Since from 9.0, client still can set the value of IpfixConfig.idleFlowTimeout + // when creating/reconfiguring DVS, but no matter what value they set, + // it will be overrided to 15 by backend. + // In 9.0, idleFlow still functions with this overrided timeout '15', + // but it would be fully replaced by CT-based IPFIX in newer releases. + // // The number of seconds after which "idle" flows are forced to be // exported to the collector. // // Legal value range is 10-600. Default: 15. - IdleFlowTimeout int32 `xml:"idleFlowTimeout" json:"idleFlowTimeout"` + IdleFlowTimeout int32 `xml:"idleFlowTimeout,omitempty" json:"idleFlowTimeout,omitempty"` // The ratio of total number of packets to the number of packets // analyzed. // @@ -82544,6 +84050,12 @@ type VStorageObjectConfigInfo struct { // // For a virtual disk, this can be VM ID(s). ConsumerId []ID `xml:"consumerId,omitempty" json:"consumerId,omitempty"` + // The type of VirtualDisk for 4k native disk/array support. + // + // See `DatastoreSectorFormat_enum` for definitions of + // supported types. If not set, the default value is + // `native_512`. + VirtualDiskFormat string `xml:"virtualDiskFormat,omitempty" json:"virtualDiskFormat,omitempty" vim:"9.0.0.0"` } func init() { @@ -82664,6 +84176,125 @@ type VStorageObjectExtendDiskEx_TaskResponse struct { Returnval ManagedObjectReference `xml:"returnval" json:"returnval"` } +// Contains result to be returned for +// `VcenterVStorageObjectManager.ReconcileDatastoreInventoryEx_Task` task. +type VStorageObjectReconcileResult struct { + DynamicData + + ReconcileDetails []VStorageObjectReconcileResultReconcileDetail `xml:"reconcileDetails,omitempty" json:"reconcileDetails,omitempty"` +} + +func init() { + t["VStorageObjectReconcileResult"] = reflect.TypeOf((*VStorageObjectReconcileResult)(nil)).Elem() + minAPIVersionForType["VStorageObjectReconcileResult"] = "9.0.0.0" +} + +type VStorageObjectReconcileResultInvalidDiskPath struct { + DynamicData + + // invalid disk path for reconcile. + Path string `xml:"path" json:"path"` + // Reason for invalid disk path + Reason string `xml:"reason" json:"reason"` +} + +func init() { + t["VStorageObjectReconcileResultInvalidDiskPath"] = reflect.TypeOf((*VStorageObjectReconcileResultInvalidDiskPath)(nil)).Elem() + minAPIVersionForType["VStorageObjectReconcileResultInvalidDiskPath"] = "9.0.0.0" +} + +// Contains information related to the performed reconcile operation. +type VStorageObjectReconcileResultReconcileDetail struct { + DynamicData + + // Host name where reconcile operation was performed. + // + // This will have the either VC name or the host name based on + // where the details were captured. + // In case we do not get the hostName for the system it would be + // empty string. + HostName string `xml:"hostName,omitempty" json:"hostName,omitempty"` + // Reconcile report path in host. + ReconcileReportPath string `xml:"reconcileReportPath,omitempty" json:"reconcileReportPath,omitempty"` + // Set to true if reconcile was done from host, false otherwise + // for host. + // + // This will be unset for the vcenter part of result. + IsReconciled *bool `xml:"isReconciled" json:"isReconciled,omitempty"` + // If deepScan was done from host, false otherwise for host. + // + // This will be unset for vcenter part of result. + IsDeepScanned *bool `xml:"isDeepScanned" json:"isDeepScanned,omitempty"` + // Number of reconcile issues found + NumberOfReconcileIssues int32 `xml:"numberOfReconcileIssues,omitempty" json:"numberOfReconcileIssues,omitempty"` + // Number of fcds before reconcile operation + // This will be unset for vcenter part of result. + NumberOfFcdsBeforeReconcile int32 `xml:"numberOfFcdsBeforeReconcile,omitempty" json:"numberOfFcdsBeforeReconcile,omitempty"` + // Number of fcds after reconcile operation. + // + // This will be unset for vcenter part of result. + NumberOfFcdsAfterReconcile int32 `xml:"numberOfFcdsAfterReconcile,omitempty" json:"numberOfFcdsAfterReconcile,omitempty"` + // reconcile invalid disk paths + InvalidDiskPaths []VStorageObjectReconcileResultInvalidDiskPath `xml:"invalidDiskPaths,omitempty" json:"invalidDiskPaths,omitempty"` +} + +func init() { + t["VStorageObjectReconcileResultReconcileDetail"] = reflect.TypeOf((*VStorageObjectReconcileResultReconcileDetail)(nil)).Elem() + minAPIVersionForType["VStorageObjectReconcileResultReconcileDetail"] = "9.0.0.0" +} + +// Contains specification to reconcile a datastore +type VStorageObjectReconcileSpec struct { + DynamicData + + // The datastore managed object that is to be reconciled/scanned. + // + // Refers instance of `Datastore`. + Datastore ManagedObjectReference `xml:"datastore" json:"datastore"` + // List of paths of the disk descriptor files which are to be reconciled + // or scanned. + // + // This is an optional parameter and if specified, the reconciliation will + // scan only these disk paths and reconcile the catalog. + // This will save time and avoid scanning all the vmdk files. + // The disk paths should belong to the same datastore. + // The field should adhere to the following format: + // /vmfs/volume/<datastore-uuid>/.../<disk-name>.vmdk . + // Please note, either this field or `VStorageObjectReconcileSpec.excludeDiskPaths` + // should be specified in `VStorageObjectReconcileSpec` and not both. + IncludeDiskPaths []string `xml:"includeDiskPaths,omitempty" json:"includeDiskPaths,omitempty"` + // List of paths of the disk descriptor files which are excluded for reconcile + // or scan operation. + // + // This is an optional parameter and if specified, the reconciliation will + // skip these disk paths. + // This will be useful in a case when user wants to reconcile complete datastore + // and skip few set of the FCD's which are present in same datastore. + // The disk paths should belong to the same datastore. + // The field should adhere to the following format: + // /vmfs/volume/<datastore-uuid>/.../<disk-name>.vmdk + // Please note, either `VStorageObjectReconcileSpec.includeDiskPaths` or this field + // should be specified in `VStorageObjectReconcileSpec` and not both. + ExcludeDiskPaths []string `xml:"excludeDiskPaths,omitempty" json:"excludeDiskPaths,omitempty"` + // If true - Checks extent files and disk descriptor file contents + // Note that this is a time consuming process. + DeepScan *bool `xml:"deepScan" json:"deepScan,omitempty"` + // If true - Does not reconcile but only scans the datastore. + DryRun *bool `xml:"dryRun" json:"dryRun,omitempty"` + // If set to 1, generate report for + // `HostVStorageObjectManager.HostReconcileDatastoreInventoryEx_Task` task. + // + // If set to 0 or unset, do not generate report + // Partner apps can use 0 and 1 as values. + // Other values are reserved for future and internal use. + GenerateReport int32 `xml:"generateReport,omitempty" json:"generateReport,omitempty"` +} + +func init() { + t["VStorageObjectReconcileSpec"] = reflect.TypeOf((*VStorageObjectReconcileSpec)(nil)).Elem() + minAPIVersionForType["VStorageObjectReconcileSpec"] = "9.0.0.0" +} + // This data object type contains ID and VClock details of a virtual disk snapshot. type VStorageObjectSnapshot struct { DynamicData @@ -84346,6 +85977,20 @@ type VirtualDisk struct { VDiskId *ID `xml:"vDiskId,omitempty" json:"vDiskId,omitempty"` // Disk descriptor version of the virtual disk. VDiskVersion int32 `xml:"vDiskVersion,omitempty" json:"vDiskVersion,omitempty" vim:"8.0.1.0"` + // Indicates the disk format of the virtual disk. + // + // The supported values are `native_4k` + // and `native_512`. + // If unset during virtual machine creation `Folder.CreateVM_Task`, + // the default value will be based on `DatastoreInfo.supportedVDiskFormats`. + // If `DatastoreInfo.supportedVDiskFormats` has only one value + // then the default value will be the same. + // If `DatastoreInfo.supportedVDiskFormats` has both the values + // `native_512` and `native_4k` + // then default value will be `native_512`. + // If unset when returned as part of a `VirtualMachineConfigInfo` then the + // default value is `native_512`. + VirtualDiskFormat string `xml:"virtualDiskFormat,omitempty" json:"virtualDiskFormat,omitempty" vim:"9.0.0.0"` // Indicates whether a disk with // `VirtualDiskFlatVer2BackingInfo` backing is a linked // clone from an unmanaged delta disk and hence the @@ -84828,6 +86473,10 @@ type VirtualDiskFlatVer2BackingOption struct { DeltaDiskFormat *ChoiceOption `xml:"deltaDiskFormat,omitempty" json:"deltaDiskFormat,omitempty"` // Delta disk formats supported for each datastore type. DeltaDiskFormatsSupported []VirtualDiskDeltaDiskFormatsSupported `xml:"deltaDiskFormatsSupported,omitempty" json:"deltaDiskFormatsSupported,omitempty"` + // Virtual disk format. + // + // See `DatastoreSectorFormat_enum` for the list of supported types. + VirtualDiskFormat *ChoiceOption `xml:"virtualDiskFormat,omitempty" json:"virtualDiskFormat,omitempty" vim:"9.0.0.0"` } func init() { @@ -85202,6 +86851,10 @@ type VirtualDiskRawDiskMappingVer1BackingOption struct { DiskMode ChoiceOption `xml:"diskMode" json:"diskMode"` // Flag to indicate whether this backing supports disk UUID property. Uuid bool `xml:"uuid" json:"uuid"` + // Virtual disk format. + // + // See `DatastoreSectorFormat_enum` for the list of supported types. + VirtualDiskFormat *ChoiceOption `xml:"virtualDiskFormat,omitempty" json:"virtualDiskFormat,omitempty" vim:"9.0.0.0"` } func init() { @@ -85269,13 +86922,20 @@ func init() { t["VirtualDiskRuleSpec"] = reflect.TypeOf((*VirtualDiskRuleSpec)(nil)).Elem() } -// Backing type for virtual disks that use the space efficient -// sparse format. +// Deprecated as of vSphere API 9.0, space efficient sparse format only +// applies to delta disks, see +// `DeltaDiskFormat`. +// SE sparse base disk is no longer supported, instead set +// `VirtualDiskFlatVer2BackingInfo.thinProvisioned` +// to true for potential space saving. // // Space for space efficient sparse disks is allocated on // demand and optimizations are applied to achieve additional // space savings. The effective space usage of such a disk can // be obtained from `VirtualMachineFileLayoutEx`. +// +// Backing type for virtual disks that use the space efficient +// sparse format. type VirtualDiskSeSparseBackingInfo struct { VirtualDeviceFileBackingInfo @@ -85418,6 +87078,10 @@ type VirtualDiskSeSparseBackingOption struct { Uuid bool `xml:"uuid" json:"uuid"` // Delta disk formats supported for each datastore type. DeltaDiskFormatsSupported []VirtualDiskDeltaDiskFormatsSupported `xml:"deltaDiskFormatsSupported" json:"deltaDiskFormatsSupported"` + // Virtual disk format. + // + // See `DatastoreSectorFormat_enum` for the list of supported types. + VirtualDiskFormat *ChoiceOption `xml:"virtualDiskFormat,omitempty" json:"virtualDiskFormat,omitempty" vim:"9.0.0.0"` } func init() { @@ -85684,6 +87348,10 @@ type VirtualDiskSparseVer2BackingOption struct { HotGrowable bool `xml:"hotGrowable" json:"hotGrowable"` // Flag to indicate whether this backing supports disk UUID property. Uuid bool `xml:"uuid" json:"uuid"` + // Virtual disk format. + // + // See `DatastoreSectorFormat_enum` for the list of supported types. + VirtualDiskFormat *ChoiceOption `xml:"virtualDiskFormat,omitempty" json:"virtualDiskFormat,omitempty" vim:"9.0.0.0"` } func init() { @@ -85872,6 +87540,12 @@ type VirtualEthernetCard struct { // Clients can set this property enabled or disabled if ethernet // virtual device is Vmxnet3. UptCompatibilityEnabled *bool `xml:"uptCompatibilityEnabled" json:"uptCompatibilityEnabled,omitempty"` + // The ID of the subnet the virtual network adapter connects to. + // + // It + // is only set when the virtual network adapter is connected + // to a subnet. + SubnetId string `xml:"subnetId,omitempty" json:"subnetId,omitempty" vim:"9.0.0.0"` } func init() { @@ -86773,6 +88447,17 @@ type VirtualMachineCapability struct { ChangeModeDisksSupported *bool `xml:"changeModeDisksSupported" json:"changeModeDisksSupported,omitempty" vim:"8.0.0.1"` // Indicates support for Vendor Device Groups VendorDeviceGroupSupported *bool `xml:"vendorDeviceGroupSupported" json:"vendorDeviceGroupSupported,omitempty" vim:"8.0.1.0"` + // Indicates support for AMD-SEV-SNP (Secure Encrypted Virtualization Secure + // Nested Paging). + // + // SEV-SNP is supported when set to true, and unsupported + // otherwise. + SevSnpSupported *bool `xml:"sevSnpSupported" json:"sevSnpSupported,omitempty" vim:"9.0.0.0"` + // Indicates support for INTEL-TDX (Trusted Domain Extensions). + // + // TDX is + // supported when set to true, and unsupported otherwise. + TdxSupported *bool `xml:"tdxSupported" json:"tdxSupported,omitempty" vim:"9.0.0.0"` } func init() { @@ -87299,6 +88984,12 @@ type VirtualMachineConfigInfo struct { // \- If FALSE or unset, FT Metro Cluster is disabled for the VM. Both FT // primary and secondary will be put in the same HostGroup. MetroFtEnabled *bool `xml:"metroFtEnabled" json:"metroFtEnabled,omitempty" vim:"8.0.3.0"` + // Contains properties that are established when the VM + // powers-on and are later examined when the VM is resumed to ensure that + // the VM is compatible with the suspended device state. + // + // It is only populated while the VM is powered-on. + VmxRuntimeConfig []BaseOptionValue `xml:"vmxRuntimeConfig,omitempty,typeattr" json:"vmxRuntimeConfig,omitempty" vim:"9.0.0.0"` // Indicate the Host Group (`ClusterHostGroup`) for FT // Metro Cluster enabled Virtual Machine. // @@ -87306,6 +88997,16 @@ type VirtualMachineConfigInfo struct { // into two groups and ensure to place FT primary and FT secondary in // different groups. MetroFtHostGroup string `xml:"metroFtHostGroup,omitempty" json:"metroFtHostGroup,omitempty" vim:"8.0.3.0"` + // TDX (Trust Domain Extensions) enabled or not. + // + // TDX is enabled + // when set to true, and disabled otherwise. + TdxEnabled *bool `xml:"tdxEnabled" json:"tdxEnabled,omitempty" vim:"9.0.0.0"` + // SEV-SNP (Secure Encrypted Virtualization Secure Nested paging) enabled or + // not. + // + // SEV-SNP is enabled when set to true, and disabled otherwise. + SevSnpEnabled *bool `xml:"sevSnpEnabled" json:"sevSnpEnabled,omitempty" vim:"9.0.0.0"` } func init() { @@ -88027,6 +89728,16 @@ type VirtualMachineConfigSpec struct { // into two groups and ensure to place FT primary and FT secondary in // different groups. MetroFtHostGroup string `xml:"metroFtHostGroup,omitempty" json:"metroFtHostGroup,omitempty" vim:"8.0.3.0"` + // TDX (Trust Domain Extensions) enabled or not. + // + // TDX is enabled when + // set to true, and disabled otherwise. + TdxEnabled *bool `xml:"tdxEnabled" json:"tdxEnabled,omitempty" vim:"9.0.0.0"` + // SEV-SNP (Secure Encrypted Virtualization Secure Nested paging) enabled or + // not. + // + // SEV-SNP is enabled when set to true, and disabled otherwise. + SevSnpEnabled *bool `xml:"sevSnpEnabled" json:"sevSnpEnabled,omitempty" vim:"9.0.0.0"` } func init() { @@ -88226,6 +89937,12 @@ type VirtualMachineDatastoreInfo struct { // // See also `FileSystemMountInfoVStorageSupportStatus_enum`. VStorageSupport string `xml:"vStorageSupport,omitempty" json:"vStorageSupport,omitempty"` + // A list of virtual disk format types which are supported + // on that datastore. + // + // See `DatastoreSectorFormat_enum` for the list + // of supported types. + SupportedVDiskFormats []string `xml:"supportedVDiskFormats,omitempty" json:"supportedVDiskFormats,omitempty" vim:"9.0.0.0"` } func init() { @@ -88800,6 +90517,11 @@ type VirtualMachineFileLayoutExDiskLayout struct { // Identifier for the virtual disk in `VirtualHardware.device`. Key int32 `xml:"key" json:"key"` + // The sector format of the virtual disk. + // + // See `DatastoreSectorFormat_enum` for definitions of supported types. If not + // set, the default value is `native_512`. + VirtualDiskFormat string `xml:"virtualDiskFormat,omitempty" json:"virtualDiskFormat,omitempty" vim:"9.0.0.0"` // The disk-unit chain that makes up this virtual disk. Chain []VirtualMachineFileLayoutExDiskUnit `xml:"chain,omitempty" json:"chain,omitempty"` } @@ -90761,6 +92483,11 @@ type VirtualMachineTicket struct { // includes all hash types that are considered secure. See vmware.com // for the current security standards. CertThumbprintList []VirtualMachineCertThumbprint `xml:"certThumbprintList,omitempty" json:"certThumbprintList,omitempty" vim:"7.0.3.1"` + // PEM-encoded SSL certificate of the host to which we are connecting. + // + // Note: `VirtualMachineTicket.sslThumbprint` and `VirtualMachineTicket.sslCertificate` parameters are + // mutually exclusive, and should never be used simultaneously. + SslCertificate string `xml:"sslCertificate,omitempty" json:"sslCertificate,omitempty" vim:"9.0.0.0"` // Websocket URL. // // Some tickets are "websocket" tickets and are best expressed @@ -93530,6 +95257,14 @@ type VirtualVmxnet3 struct { // virtual device is Vmxnet3. It requires the VM hardware version is // compatible with ESXi version which has enabled smartnic feature. Uptv2Enabled *bool `xml:"uptv2Enabled" json:"uptv2Enabled,omitempty" vim:"8.0.0.1"` + // Indicates whether strict latency parameters are configured on this + // network adapter. + // + // Clients can set these parameters to control behaviors + // on this network adapter, e.g., set the TX/RX ring size, etc. Requires + // VM hardware version compatible with ESXi release supporting the + // "real-time switch" feature. + StrictLatencyConfig *VirtualVmxnet3StrictLatencyConfig `xml:"strictLatencyConfig,omitempty" json:"strictLatencyConfig,omitempty" vim:"8.0.3.1"` } func init() { @@ -93544,12 +95279,110 @@ type VirtualVmxnet3Option struct { // Flag to indicate whether UPTv2(Uniform Pass-through version 2) is // settable on this device. Uptv2Enabled *BoolOption `xml:"uptv2Enabled,omitempty" json:"uptv2Enabled,omitempty" vim:"8.0.0.1"` + // Strict latency configure options. + StrictLatencyConfigOption *VirtualVmxnet3OptionStrictLatencyConfigOption `xml:"strictLatencyConfigOption,omitempty" json:"strictLatencyConfigOption,omitempty" vim:"8.0.3.1"` } func init() { t["VirtualVmxnet3Option"] = reflect.TypeOf((*VirtualVmxnet3Option)(nil)).Elem() } +// Strict latency configure options. +// +// Indicates options for each strict +// latency configure specification, as defined by +// `VirtualVmxnet3StrictLatencyConfig`. +type VirtualVmxnet3OptionStrictLatencyConfigOption struct { + DynamicData + + // Indicates whether strict latency configuration is allowed on this + // network adapter. + Allowed BoolOption `xml:"allowed" json:"allowed"` + // Indicates whether latency measurement is enabled on this network + // adapter. + MeasureLatency BoolOption `xml:"measureLatency" json:"measureLatency"` + // Three properties (maxTxQueues.min, maxTxQueues.max, and + // maxTxQueues.defaultValue) define the minimum, maximum, and default + // number of transmit queues on this network adapter. + MaxTxQueues IntOption `xml:"maxTxQueues" json:"maxTxQueues"` + // Three properties (maxRxQueues.min, maxRxQueues.max, and + // maxRxQueues.defaultValue) define the minimum, maximum, and default + // number of receive queues on this network adapter. + MaxRxQueues IntOption `xml:"maxRxQueues" json:"maxRxQueues"` + // Three properties (txDataRingDescSize.min, txDataRingDescSize.max, and + // txDataRingDescSize.defaultValue) define the minimum, maximum, and + // default transmit data ring size on this network adapter. + TxDataRingDescSize IntOption `xml:"txDataRingDescSize" json:"txDataRingDescSize"` + // Three properties (rxDataRingDescSize.min, rxDataRingDescSize.max, and + // rxDataRingDescSize.defaultValue) define the minimum, maximum, and + // default receive data ring size on this network adapter. + RxDataRingDescSize IntOption `xml:"rxDataRingDescSize" json:"rxDataRingDescSize"` + // Type of disable offload being performed on the specified network + // adapter. + DisableOffload ChoiceOption `xml:"disableOffload" json:"disableOffload"` +} + +func init() { + t["VirtualVmxnet3OptionStrictLatencyConfigOption"] = reflect.TypeOf((*VirtualVmxnet3OptionStrictLatencyConfigOption)(nil)).Elem() + minAPIVersionForType["VirtualVmxnet3OptionStrictLatencyConfigOption"] = "8.0.3.1" +} + +// The structure below defines the strict latency configuration of a +// network adapter. +// +// The configuration parameters are only supported when +// the strict latency capability is enabled on the adapter. When adding +// a new adapter, unset config parameters are interpreted as "use the +// default value". When altering the configuration of an existing adapter, +// unset parameters mean "do not change the current config" +type VirtualVmxnet3StrictLatencyConfig struct { + DynamicData + + // Indicates whether strict latency configuration is allowed on this + // network adapter. + // + // Requires VM hardware version compatible with ESXi + // release supporting the "real-time switch" feature. + Allowed *bool `xml:"allowed" json:"allowed,omitempty"` + // Indicates whether the latency measurement is enabled. + // + // The default + // value is "enabled". + MeasureLatency *bool `xml:"measureLatency" json:"measureLatency,omitempty"` + // The number of transmit queues. + // + // The default value is 1. The allowed + // range is 1 to 32, including. + MaxTxQueues int32 `xml:"maxTxQueues,omitempty" json:"maxTxQueues,omitempty"` + // The number of receive queues. + // + // The default value is 1. The allowed + // range is 1 to 32, including. + MaxRxQueues int32 `xml:"maxRxQueues,omitempty" json:"maxRxQueues,omitempty"` + // The transmit data ring size. + // + // The default value is 256. The allowed + // range is 128 to 2048, including, must be multiple of 64. + TxDataRingDescSize int32 `xml:"txDataRingDescSize,omitempty" json:"txDataRingDescSize,omitempty"` + // The receive data ring size. + // + // The default value is 256. The allowed + // range is 128 to 2048, including, must be multiple of 64. + RxDataRingDescSize int32 `xml:"rxDataRingDescSize,omitempty" json:"rxDataRingDescSize,omitempty"` + // Type of disable offload being performed on the specified network + // adapter. + // + // If not specified, TSO\_LRO will be used as the default during + // adding new network adapter. The supported values are listed in + // `VirtualVmxnet3StrictLatencyConfigDisableOffload_enum`. + DisableOffload string `xml:"disableOffload,omitempty" json:"disableOffload,omitempty"` +} + +func init() { + t["VirtualVmxnet3StrictLatencyConfig"] = reflect.TypeOf((*VirtualVmxnet3StrictLatencyConfig)(nil)).Elem() + minAPIVersionForType["VirtualVmxnet3StrictLatencyConfig"] = "8.0.3.1" +} + // The VirtualVmxnet3Vrdma data object type represents an instance of the // VRDMA virtual Remote Direct Memory Access adapter attached to a virtual // machine. @@ -94307,6 +96140,10 @@ type VmDiskFileInfo struct { // field is always set. Inspect the VmDiskEncryptionInfo to // determine if the virtual disk is encrypted. Encryption *VmDiskFileEncryptionInfo `xml:"encryption,omitempty" json:"encryption,omitempty"` + // Sector format of this virtual disk. + // + // For the list of supported values, see `DatastoreSectorFormat_enum`. + SectorFormat string `xml:"sectorFormat,omitempty" json:"sectorFormat,omitempty" vim:"9.0.0.0"` } func init() { @@ -94412,6 +96249,9 @@ type VmDiskFileQueryFlags struct { // The flag to indicate whether the encryption information of the // virtual disk is returned. Encryption *bool `xml:"encryption" json:"encryption,omitempty"` + // The flag to indicate whether or not the sector format of the virtual + // disk is returned. + SectorFormat *bool `xml:"sectorFormat" json:"sectorFormat,omitempty" vim:"9.0.0.0"` } func init() { @@ -96400,6 +98240,43 @@ func init() { t["VmwareDistributedVirtualSwitchPvlanSpec"] = reflect.TypeOf((*VmwareDistributedVirtualSwitchPvlanSpec)(nil)).Elem() } +// This data structure defines the real-time specific configuration of +// a distributed virtual switch when real-time flag is enabled. +type VmwareDistributedVirtualSwitchRealTimeConfig struct { + DynamicData + + // The flag to indicate whether real-time configuration is allowed on + // the switch. + Allowed *bool `xml:"allowed" json:"allowed,omitempty"` + // The real-time LANs (LAN A/LAN B) annotation, to mark the uplink(s) + // for each LAN. + LanAnnotation *VmwareDistributedVirtualSwitchRealTimeLanAnnotation `xml:"lanAnnotation,omitempty" json:"lanAnnotation,omitempty"` +} + +func init() { + t["VmwareDistributedVirtualSwitchRealTimeConfig"] = reflect.TypeOf((*VmwareDistributedVirtualSwitchRealTimeConfig)(nil)).Elem() + minAPIVersionForType["VmwareDistributedVirtualSwitchRealTimeConfig"] = "8.0.3.1" +} + +// This data structure defines the real-time configuration for a distributed +// virtual switch when real-time flag is enabled. +// +// The uplink(s) are set in +// two different LANs (LAN A/LAN B). +type VmwareDistributedVirtualSwitchRealTimeLanAnnotation struct { + DynamicData + + // The name(s) of the LAN A uplink(s). + LanAUplink []string `xml:"lanAUplink,omitempty" json:"lanAUplink,omitempty"` + // The name(s) of the LAN B uplink(s). + LanBUplink []string `xml:"lanBUplink,omitempty" json:"lanBUplink,omitempty"` +} + +func init() { + t["VmwareDistributedVirtualSwitchRealTimeLanAnnotation"] = reflect.TypeOf((*VmwareDistributedVirtualSwitchRealTimeLanAnnotation)(nil)).Elem() + minAPIVersionForType["VmwareDistributedVirtualSwitchRealTimeLanAnnotation"] = "8.0.3.1" +} + // This data type specifies that the port uses trunk mode, // which allows the guest operating system to manage its own VLAN tags. type VmwareDistributedVirtualSwitchTrunkVlanSpec struct { @@ -96614,6 +98491,32 @@ func init() { t["VsanClusterConfigInfoHostDefaultInfo"] = reflect.TypeOf((*VsanClusterConfigInfoHostDefaultInfo)(nil)).Elem() } +// vSAN first-class settings which should be configured together with +// vSAN enablement. +type VsanClusterCoreConfig struct { + DynamicData + + VsanMaxEnabled *bool `xml:"vsanMaxEnabled" json:"vsanMaxEnabled,omitempty"` +} + +func init() { + t["VsanClusterCoreConfig"] = reflect.TypeOf((*VsanClusterCoreConfig)(nil)).Elem() + minAPIVersionForType["VsanClusterCoreConfig"] = "9.0.0.0" +} + +// vSAN first-class settings which should be configured together with +// vSAN enablement. +type VsanClusterCoreConfigSpec struct { + DynamicData + + VsanMaxEnabled *bool `xml:"vsanMaxEnabled" json:"vsanMaxEnabled,omitempty"` +} + +func init() { + t["VsanClusterCoreConfigSpec"] = reflect.TypeOf((*VsanClusterCoreConfigSpec)(nil)).Elem() + minAPIVersionForType["VsanClusterCoreConfigSpec"] = "9.0.0.0" +} + // Fault thrown for the case that an attempt is made to move a host which // is enabled for VSAN into a `ClusterComputeResource` whose // VSAN cluster UUID does not match. diff --git a/vendor/github.com/vmware/govmomi/vim25/types/unreleased.go b/vendor/github.com/vmware/govmomi/vim25/types/unreleased.go index 094ac395..2114d55f 100644 --- a/vendor/github.com/vmware/govmomi/vim25/types/unreleased.go +++ b/vendor/github.com/vmware/govmomi/vim25/types/unreleased.go @@ -97,34 +97,6 @@ func init() { t["PlaceVmsXClusterResultPlacementInfo"] = reflect.TypeOf((*PlaceVmsXClusterResultPlacementInfo)(nil)).Elem() } -// Defines the type of placement -type PlaceVmsXClusterSpecPlacementType string - -const ( - // Create a new VM to be powered On - PlaceVmsXClusterSpecPlacementTypeCreateAndPowerOn = PlaceVmsXClusterSpecPlacementType("createAndPowerOn") - // Reconfigure a VM - PlaceVmsXClusterSpecPlacementTypeReconfigure = PlaceVmsXClusterSpecPlacementType("reconfigure") - // Relocate a VM - PlaceVmsXClusterSpecPlacementTypeRelocate = PlaceVmsXClusterSpecPlacementType("relocate") -) - -func (e PlaceVmsXClusterSpecPlacementType) Values() []PlaceVmsXClusterSpecPlacementType { - return []PlaceVmsXClusterSpecPlacementType{ - PlaceVmsXClusterSpecPlacementTypeCreateAndPowerOn, - PlaceVmsXClusterSpecPlacementTypeReconfigure, - PlaceVmsXClusterSpecPlacementTypeRelocate, - } -} - -func (e PlaceVmsXClusterSpecPlacementType) Strings() []string { - return EnumValuesAsStrings(e.Values()) -} - -func init() { - t["PlaceVmsXClusterSpecPlacementType"] = reflect.TypeOf((*PlaceVmsXClusterSpecPlacementType)(nil)).Elem() -} - type PlaceVmsXClusterSpec struct { DynamicData diff --git a/vendor/modules.txt b/vendor/modules.txt index c1d563fd..a02993b7 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -20,8 +20,8 @@ github.com/rs/zerolog github.com/rs/zerolog/internal/cbor github.com/rs/zerolog/internal/json github.com/rs/zerolog/log -# github.com/vmware/govmomi v0.46.3 -## explicit; go 1.22 +# github.com/vmware/govmomi v0.47.0 +## explicit; go 1.21 github.com/vmware/govmomi github.com/vmware/govmomi/fault github.com/vmware/govmomi/find