github.com/vmware/govmomi@v0.43.0/eam/types/types.go (about)

     1  /*
     2  Copyright (c) 2021-2024 VMware, Inc. All Rights Reserved.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package types
    18  
    19  import (
    20  	"reflect"
    21  	"time"
    22  
    23  	"github.com/vmware/govmomi/vim25/types"
    24  )
    25  
    26  type AddIssue AddIssueRequestType
    27  
    28  func init() {
    29  	types.Add("eam:AddIssue", reflect.TypeOf((*AddIssue)(nil)).Elem())
    30  }
    31  
    32  // The parameters of `Agency.AddIssue`.
    33  //
    34  // This structure may be used only with operations rendered under `/eam`.
    35  type AddIssueRequestType struct {
    36  	This types.ManagedObjectReference `xml:"_this" json:"_this"`
    37  	// A new issue.
    38  	Issue BaseIssue `xml:"issue,typeattr" json:"issue"`
    39  }
    40  
    41  func init() {
    42  	types.Add("eam:AddIssueRequestType", reflect.TypeOf((*AddIssueRequestType)(nil)).Elem())
    43  }
    44  
    45  type AddIssueResponse struct {
    46  	Returnval BaseIssue `xml:"returnval,typeattr" json:"returnval"`
    47  }
    48  
    49  // Scope specifies on which compute resources to deploy a solution's agents.
    50  //
    51  // This structure may be used only with operations rendered under `/eam`.
    52  type AgencyComputeResourceScope struct {
    53  	AgencyScope
    54  
    55  	// Compute resources on which to deploy the agents.
    56  	//
    57  	// If `AgencyConfigInfoEx.vmPlacementPolicy` is set, the array needs to
    58  	// contain exactly one cluster compute resource.
    59  	//
    60  	// Refers instances of `ComputeResource`.
    61  	ComputeResource []types.ManagedObjectReference `xml:"computeResource,omitempty" json:"computeResource,omitempty"`
    62  }
    63  
    64  func init() {
    65  	types.Add("eam:AgencyComputeResourceScope", reflect.TypeOf((*AgencyComputeResourceScope)(nil)).Elem())
    66  }
    67  
    68  // This is the configuration of an <code>Agency</code>.
    69  //
    70  // It determines on
    71  // which compute resources to deploy the agents, which VIB to install, which
    72  // OVF package to install, and how to configure these items by setting the
    73  // OVF environment properties.
    74  //
    75  // This structure may be used only with operations rendered under `/eam`.
    76  type AgencyConfigInfo struct {
    77  	types.DynamicData
    78  
    79  	// A list of `AgentConfigInfo`s for hosts covered by this
    80  	// <code>Agency</code>.
    81  	//
    82  	// When provisioning a new agent to a host, vSphere
    83  	// ESX Agent Manager tries to find, from left to right in the array, a
    84  	// match for an `AgentConfigInfo` and stops searching at the first
    85  	// one that it finds.
    86  	// If `AgencyConfigInfoEx.vmPlacementPolicy` is set, the array needs to contain only a
    87  	// single agent config. In that case the agent config is not bound to a
    88  	// specific host, but to the whole cluster.
    89  	AgentConfig []AgentConfigInfo `xml:"agentConfig,omitempty" json:"agentConfig,omitempty"`
    90  	// The scope of the <code>Agency</code>.
    91  	Scope BaseAgencyScope `xml:"scope,omitempty,typeattr" json:"scope,omitempty"`
    92  	// If set to <code>true</code>, the client of this agency must manually
    93  	// mark the agent as ready after the agent virtual machine has been
    94  	// provisioned.
    95  	//
    96  	// This is useful if the client of this solution performs
    97  	// some extra reconfiguration of the agent virtual machine before it is
    98  	// powered on.
    99  	//
   100  	// See also `Agent.MarkAsAvailable`.
   101  	ManuallyMarkAgentVmAvailableAfterProvisioning *bool `xml:"manuallyMarkAgentVmAvailableAfterProvisioning" json:"manuallyMarkAgentVmAvailableAfterProvisioning,omitempty"`
   102  	// If set to <code>true</code>, the client of this agency must manually
   103  	// mark the agent as ready after the agent virtual machine has been
   104  	// powered on.
   105  	//
   106  	// In this case, DRS will not regard the agent virtual machine
   107  	// as ready until the client has marked the agent as ready.
   108  	//
   109  	// See also `Agent.MarkAsAvailable`.
   110  	ManuallyMarkAgentVmAvailableAfterPowerOn *bool `xml:"manuallyMarkAgentVmAvailableAfterPowerOn" json:"manuallyMarkAgentVmAvailableAfterPowerOn,omitempty"`
   111  	// If set to <code>true</code>, ESX Agent Manager will use vSphere Linked
   112  	// Clones to speed up the deployment of agent virtual machines.
   113  	//
   114  	// Using
   115  	// linked clones implies that the agent virtual machines cannot use
   116  	// Storage vMotion to move to another vSphere datastore.
   117  	// If set to <code>false</code>, ESX Agent Manager will use Full VM
   118  	// Cloning.
   119  	// If unset default is <code>true<code>.
   120  	OptimizedDeploymentEnabled *bool `xml:"optimizedDeploymentEnabled" json:"optimizedDeploymentEnabled,omitempty"`
   121  	// An optional name to use when naming agent virtual machines.
   122  	//
   123  	// For
   124  	// example, if set to "example-agent", each agent virtual machine will be
   125  	// named "example-agent (1)", "example-agent (2)", and so on. The maximum
   126  	// length of <code>agentName</code> is 70 characters.
   127  	AgentName string `xml:"agentName,omitempty" json:"agentName,omitempty"`
   128  	// Name of the agency.
   129  	//
   130  	// Must be set when creating the agency.
   131  	AgencyName string `xml:"agencyName,omitempty" json:"agencyName,omitempty"`
   132  	// Property <code>agentName</code> is required if this property is set to
   133  	// <code>true</code>.
   134  	//
   135  	// If set to <code>true</code>, ESX Agent Manager will name virtual
   136  	// machines with UUID suffix. For example, "example-agent-UUID".
   137  	// In this case, the maximum length of <code>agentName</code> is 43
   138  	// characters.
   139  	//
   140  	// If not set or is set to <code>false</code>, virtual
   141  	// machines will not contain UUID in their name.
   142  	UseUuidVmName *bool `xml:"useUuidVmName" json:"useUuidVmName,omitempty"`
   143  	// Deprecated use automatically provisioned VMs and register hooks to
   144  	// have control post provisioning and power on.
   145  	//
   146  	// Set to true if agent VMs are manually provisioned.
   147  	//
   148  	// If unset, defaults
   149  	// to false.
   150  	ManuallyProvisioned *bool `xml:"manuallyProvisioned" json:"manuallyProvisioned,omitempty"`
   151  	// Deprecated use automatically provisioned VMs and register hooks to
   152  	// have control post provisioning and power on.
   153  	//
   154  	// Set to true if agent VMs are manually monitored.
   155  	//
   156  	// If unset, defaults to
   157  	// false. This can only be set to true if
   158  	// `AgencyConfigInfo.manuallyProvisioned` is set to true.
   159  	ManuallyMonitored *bool `xml:"manuallyMonitored" json:"manuallyMonitored,omitempty"`
   160  	// Deprecated vUM is no more consulted so this property has no sense
   161  	// anymore.
   162  	//
   163  	// Set to true will install VIBs directly on the hosts even if VMware
   164  	// Update Manager is installed.
   165  	//
   166  	// If unset, defaults to false.
   167  	BypassVumEnabled *bool `xml:"bypassVumEnabled" json:"bypassVumEnabled,omitempty"`
   168  	// Specifies the networks which to be configured on the agent VMs.
   169  	//
   170  	// This property is only applicable for pinned to host VMs - i.e.
   171  	// (`AgencyConfigInfoEx.vmPlacementPolicy`) is not set.
   172  	//
   173  	// If not set or `AgencyConfigInfo.preferHostConfiguration` is set to true, the
   174  	// default host agent VM network (configured through
   175  	// vim.host.EsxAgentHostManager) is used, otherwise the first network from
   176  	// the array that is present on the host is used.
   177  	//
   178  	// At most one of `AgencyConfigInfo.agentVmNetwork` and `AgencyConfigInfoEx.vmNetworkMapping`
   179  	// needs to be set.
   180  	//
   181  	// Refers instances of `Network`.
   182  	AgentVmNetwork []types.ManagedObjectReference `xml:"agentVmNetwork,omitempty" json:"agentVmNetwork,omitempty"`
   183  	// The datastores used to configure the storage on the agent VMs.
   184  	//
   185  	// This property is required if `AgencyConfigInfoEx.vmPlacementPolicy` is set and
   186  	// `AgencyConfigInfoEx.datastoreSelectionPolicy` is not set. In that case the first
   187  	// element from the list is used.
   188  	//
   189  	// If not set or `AgencyConfigInfo.preferHostConfiguration` is set to true and
   190  	// `AgencyConfigInfoEx.vmPlacementPolicy` is not set, the default host agent VM
   191  	// datastore (configured through vim.host.EsxAgentHostManager) is used,
   192  	// otherwise the first datastore from the array that is present on the
   193  	// host is used.
   194  	//
   195  	// If `AgencyConfigInfoEx.vmPlacementPolicy` is set at most one of
   196  	// `AgencyConfigInfo.agentVmDatastore` and `AgencyConfigInfoEx.datastoreSelectionPolicy` needs
   197  	// to be set. If `AgencyConfigInfoEx.vmPlacementPolicy` is not set
   198  	// `AgencyConfigInfoEx.datastoreSelectionPolicy` takes precedence over
   199  	// `AgencyConfigInfo.agentVmDatastore` .
   200  	//
   201  	// Refers instances of `Datastore`.
   202  	AgentVmDatastore []types.ManagedObjectReference `xml:"agentVmDatastore,omitempty" json:"agentVmDatastore,omitempty"`
   203  	// If set to true the default agent VM datastore and network will take
   204  	// precedence over `AgencyConfigInfo.agentVmNetwork` and
   205  	// `AgencyConfigInfo.agentVmDatastore` when configuring the agent
   206  	// VMs.
   207  	//
   208  	// This property is not used if `AgencyConfigInfoEx.vmPlacementPolicy` is set.
   209  	PreferHostConfiguration *bool `xml:"preferHostConfiguration" json:"preferHostConfiguration,omitempty"`
   210  	// Deprecated that is a custom configuration that should be setup by the
   211  	// agency owner. One way is to use
   212  	// `AgencyConfigInfo.manuallyMarkAgentVmAvailableAfterPowerOn` or
   213  	// `AgencyConfigInfo.manuallyMarkAgentVmAvailableAfterProvisioning`
   214  	// hooks.
   215  	//
   216  	// If set, a property with id "ip" and value an IP from the pool is added
   217  	// to the vApp configuration of the deployed VMs.
   218  	IpPool *types.IpPool `xml:"ipPool,omitempty" json:"ipPool,omitempty"`
   219  	// Defines the resource pools where VMs to be deployed.
   220  	//
   221  	// If specified, the VMs for every compute resouce in the scope will be
   222  	// deployed to its corresponding resource pool.
   223  	// If not specified, the agent VMs for each compute resource will be
   224  	// deployed under top level nested resource pool created for the agent
   225  	// VMs. If unable to create a nested resource pool, the root resource pool
   226  	// of the compute resource will be used.
   227  	ResourcePools []AgencyVMResourcePool `xml:"resourcePools,omitempty" json:"resourcePools,omitempty"`
   228  	// Defines the folders where VMs to be deployed.
   229  	//
   230  	// If specified, the VMs for every compute resouce in the scope will be
   231  	// deployed to its corresponding folder. The link is made between the
   232  	// compute resource parent and the datacenter the folder belongs to
   233  	// `AgencyVMFolder.datacenterId`.
   234  	// If not specified, the agent VMs for each compute resource will be
   235  	// deployed in top level folder created in each datacenter for the agent
   236  	// VMs.
   237  	Folders []AgencyVMFolder `xml:"folders,omitempty" json:"folders,omitempty"`
   238  }
   239  
   240  func init() {
   241  	types.Add("eam:AgencyConfigInfo", reflect.TypeOf((*AgencyConfigInfo)(nil)).Elem())
   242  }
   243  
   244  // Agency is disabled - one or more ClusterComputeResources from it's scope are
   245  // disabled.
   246  //
   247  // This is not a remediable issue. To remediate, re-enable the cluster.
   248  //
   249  // This structure may be used only with operations rendered under `/eam`.
   250  type AgencyDisabled struct {
   251  	AgencyIssue
   252  }
   253  
   254  func init() {
   255  	types.Add("eam:AgencyDisabled", reflect.TypeOf((*AgencyDisabled)(nil)).Elem())
   256  	types.AddMinAPIVersionForType("eam:AgencyDisabled", "7.6")
   257  }
   258  
   259  // Base class for all agency issues.
   260  //
   261  // This structure may be used only with operations rendered under `/eam`.
   262  type AgencyIssue struct {
   263  	Issue
   264  
   265  	// The agency to which this issue belongs.
   266  	//
   267  	// Refers instance of `Agency`.
   268  	Agency types.ManagedObjectReference `xml:"agency" json:"agency"`
   269  	// The name of the agency.
   270  	AgencyName string `xml:"agencyName" json:"agencyName"`
   271  	// The ID of the solution to which this issue belongs.
   272  	SolutionId string `xml:"solutionId" json:"solutionId"`
   273  	// The name of the solution to which this issue belongs.
   274  	SolutionName string `xml:"solutionName" json:"solutionName"`
   275  }
   276  
   277  func init() {
   278  	types.Add("eam:AgencyIssue", reflect.TypeOf((*AgencyIssue)(nil)).Elem())
   279  }
   280  
   281  type AgencyQueryRuntime AgencyQueryRuntimeRequestType
   282  
   283  func init() {
   284  	types.Add("eam:AgencyQueryRuntime", reflect.TypeOf((*AgencyQueryRuntime)(nil)).Elem())
   285  }
   286  
   287  type AgencyQueryRuntimeRequestType struct {
   288  	This types.ManagedObjectReference `xml:"_this" json:"_this"`
   289  }
   290  
   291  func init() {
   292  	types.Add("eam:AgencyQueryRuntimeRequestType", reflect.TypeOf((*AgencyQueryRuntimeRequestType)(nil)).Elem())
   293  }
   294  
   295  type AgencyQueryRuntimeResponse struct {
   296  	Returnval BaseEamObjectRuntimeInfo `xml:"returnval,typeattr" json:"returnval"`
   297  }
   298  
   299  // Scope specifies which where to deploy agents.
   300  //
   301  // This structure may be used only with operations rendered under `/eam`.
   302  type AgencyScope struct {
   303  	types.DynamicData
   304  }
   305  
   306  func init() {
   307  	types.Add("eam:AgencyScope", reflect.TypeOf((*AgencyScope)(nil)).Elem())
   308  }
   309  
   310  // Represents the mapping of a VM folder to a datacenter.
   311  //
   312  // This structure may be used only with operations rendered under `/eam`.
   313  type AgencyVMFolder struct {
   314  	types.DynamicData
   315  
   316  	// Folder identifier.
   317  	//
   318  	// The folder must be present in the corresponding
   319  	// datacenter.
   320  	//
   321  	// Refers instance of `Folder`.
   322  	FolderId types.ManagedObjectReference `xml:"folderId" json:"folderId"`
   323  	// Datacenter identifier.
   324  	//
   325  	// Refers instance of `Datacenter`.
   326  	DatacenterId types.ManagedObjectReference `xml:"datacenterId" json:"datacenterId"`
   327  }
   328  
   329  func init() {
   330  	types.Add("eam:AgencyVMFolder", reflect.TypeOf((*AgencyVMFolder)(nil)).Elem())
   331  }
   332  
   333  // Represents the mapping of a VM resource pool to a compute resource.
   334  //
   335  // This structure may be used only with operations rendered under `/eam`.
   336  type AgencyVMResourcePool struct {
   337  	types.DynamicData
   338  
   339  	// Resource pool identifier.
   340  	//
   341  	// The resource pool must be present in the
   342  	// corresponding compute resource.
   343  	//
   344  	// Refers instance of `ResourcePool`.
   345  	ResourcePoolId types.ManagedObjectReference `xml:"resourcePoolId" json:"resourcePoolId"`
   346  	// Compute resource identifier.
   347  	//
   348  	// Refers instance of `ComputeResource`.
   349  	ComputeResourceId types.ManagedObjectReference `xml:"computeResourceId" json:"computeResourceId"`
   350  }
   351  
   352  func init() {
   353  	types.Add("eam:AgencyVMResourcePool", reflect.TypeOf((*AgencyVMResourcePool)(nil)).Elem())
   354  }
   355  
   356  type Agency_Disable Agency_DisableRequestType
   357  
   358  func init() {
   359  	types.Add("eam:Agency_Disable", reflect.TypeOf((*Agency_Disable)(nil)).Elem())
   360  }
   361  
   362  type Agency_DisableRequestType struct {
   363  	This types.ManagedObjectReference `xml:"_this" json:"_this"`
   364  }
   365  
   366  func init() {
   367  	types.Add("eam:Agency_DisableRequestType", reflect.TypeOf((*Agency_DisableRequestType)(nil)).Elem())
   368  }
   369  
   370  type Agency_DisableResponse struct {
   371  }
   372  
   373  type Agency_Enable Agency_EnableRequestType
   374  
   375  func init() {
   376  	types.Add("eam:Agency_Enable", reflect.TypeOf((*Agency_Enable)(nil)).Elem())
   377  }
   378  
   379  type Agency_EnableRequestType struct {
   380  	This types.ManagedObjectReference `xml:"_this" json:"_this"`
   381  }
   382  
   383  func init() {
   384  	types.Add("eam:Agency_EnableRequestType", reflect.TypeOf((*Agency_EnableRequestType)(nil)).Elem())
   385  }
   386  
   387  type Agency_EnableResponse struct {
   388  }
   389  
   390  // Specifies an SSL policy that trusts any SSL certificate.
   391  //
   392  // This structure may be used only with operations rendered under `/eam`.
   393  type AgentAnyCertificate struct {
   394  	AgentSslTrust
   395  }
   396  
   397  func init() {
   398  	types.Add("eam:AgentAnyCertificate", reflect.TypeOf((*AgentAnyCertificate)(nil)).Elem())
   399  	types.AddMinAPIVersionForType("eam:AgentAnyCertificate", "8.2")
   400  }
   401  
   402  // A description of what should be put on a host.
   403  //
   404  // By setting the
   405  // <code>productLineId</code> and <code>hostVersion</code>, you can specify
   406  // the types of hosts for which to use the <code>ConfigInfo</code>.
   407  //
   408  // This structure may be used only with operations rendered under `/eam`.
   409  type AgentConfigInfo struct {
   410  	types.DynamicData
   411  
   412  	// The product line ID of the host.
   413  	//
   414  	// Examples of values are "esx" or
   415  	// "embeddedEsx". If omitted, the host's product line ID is not considered
   416  	// when matching an <code>AgentPackage</code> against a host.
   417  	ProductLineId string `xml:"productLineId,omitempty" json:"productLineId,omitempty"`
   418  	// A dot-separated string of the host version.
   419  	//
   420  	// Examples of values are
   421  	// "4.1.0" "3.5", "4.\*" where \* is a wildcard meaning any version minor
   422  	// version of the major version 4. If omitted, the host version will not
   423  	// be considered when matching an <code>AgentPackage</code> against a
   424  	// host.
   425  	// This property is not used if
   426  	// `AgencyConfigInfoEx.vmPlacementPolicy` is set. It is client's
   427  	// responsibility to trigger an agency upgrade with a new
   428  	// `AgentConfigInfo.ovfPackageUrl`.
   429  	HostVersion string `xml:"hostVersion,omitempty" json:"hostVersion,omitempty"`
   430  	// The URL of the solution's agent OVF package.
   431  	//
   432  	// If not set, no agent
   433  	// virtual machines are installed on the hosts covered by the scope.
   434  	// If `AgencyConfigInfoEx.vmPlacementPolicy` is set, the VM needs to
   435  	// be agnostic to the different host versions inside the cluster.
   436  	OvfPackageUrl        string `xml:"ovfPackageUrl,omitempty" json:"ovfPackageUrl,omitempty"`
   437  	AuthenticationScheme string `xml:"authenticationScheme,omitempty" json:"authenticationScheme,omitempty"`
   438  	// Specifies an SSL trust policy to be use for verification of the
   439  	// server that hosts the `AgentConfigInfo.ovfPackageUrl`.
   440  	//
   441  	// If not set, the server
   442  	// certificate is validated against the trusted root certificates of the
   443  	// OS (Photon) and VECS (TRUSTED\_ROOTS).
   444  	OvfSslTrust BaseAgentSslTrust `xml:"ovfSslTrust,omitempty,typeattr" json:"ovfSslTrust,omitempty" vim:"8.2"`
   445  	// The part of the OVF environment that can be set by the solution.
   446  	//
   447  	// This
   448  	// is where Properties that the agent virtual machine's OVF descriptor
   449  	// specifies are set here. All properties that are specified as
   450  	// user-configurable must be set.
   451  	OvfEnvironment *AgentOvfEnvironmentInfo `xml:"ovfEnvironment,omitempty" json:"ovfEnvironment,omitempty"`
   452  	// An optional URL to an offline bundle.
   453  	//
   454  	// If not set, no VIB is installed
   455  	// on the hosts in the scope. Offline bundles are only supported on 4.0
   456  	// hosts and later.
   457  	//
   458  	// VIB downgrade is not permitted - in case a VIB with the same name, but
   459  	// lower version is installed on a host in the scope the VIB installation
   460  	// on that host will not succeed.
   461  	//
   462  	// If two or more agents have the same VIB with different versions on the
   463  	// same host, the install/uninstall behaviour is undefined (the VIB may
   464  	// remain installed, etc.).
   465  	//
   466  	// The property is not used if `AgencyConfigInfoEx.vmPlacementPolicy`
   467  	// is set.
   468  	VibUrl string `xml:"vibUrl,omitempty" json:"vibUrl,omitempty"`
   469  	// Specifies an SSL trust policy to be use for verification of the
   470  	// server that hosts the `AgentConfigInfo.vibUrl`.
   471  	//
   472  	// If not set, the server
   473  	// certificate is validated against the trusted root certificates of the
   474  	// OS (Photon) and VECS (TRUSTED\_ROOTS).
   475  	VibSslTrust BaseAgentSslTrust `xml:"vibSslTrust,omitempty,typeattr" json:"vibSslTrust,omitempty" vim:"8.2"`
   476  	// Deprecated vIB matching rules are no longer supported by EAM. Same
   477  	// overlaps with VIB dependency requirements which reside in
   478  	// each VIB's metadata.
   479  	//
   480  	// Optional Vib matching rules.
   481  	//
   482  	// If set, the Vib, specified by vibUrl, will
   483  	// be installed either
   484  	//   - if there is installed Vib on the host which name and version match
   485  	//     the regular expressions in the corresponding rule
   486  	//   - or there isn't any installed Vib on the host with name which
   487  	//     matches the Vib name regular expression in the corresponding rule. Vib
   488  	//     matching rules are usually used for controlling VIB upgrades, in which
   489  	//     case the name regular expression matches any previous versions of the
   490  	//     agency Vib and version regular expression determines whether the
   491  	//     existing Vib should be upgraded.
   492  	//
   493  	// For every Vib in the Vib package, only one Vib matching rule can be
   494  	// defined. If specified more than one, it is not determined which one
   495  	// will be used. The Vib name regular expression in the Vib matching rule
   496  	// will be matched against the name of the Vib which will be installed.
   497  	// Only rules for Vibs which are defined in the Vib package metadata will
   498  	// be taken in account.
   499  	VibMatchingRules []AgentVibMatchingRule `xml:"vibMatchingRules,omitempty" json:"vibMatchingRules,omitempty"`
   500  	// Deprecated use VIB metadata to add such dependency.
   501  	//
   502  	// An optional name of a VIB.
   503  	//
   504  	// If set, no VIB is installed on the host. The
   505  	// host is checked if a VIB with vibName is already installed on it. Also
   506  	// the vibUrl must not be set together with the vibUrl.
   507  	VibName string `xml:"vibName,omitempty" json:"vibName,omitempty"`
   508  	// Deprecated that is a custom setup specific for a particular agency.
   509  	// The agency owner should do it using other means, e.g.
   510  	// `AgencyConfigInfo.manuallyMarkAgentVmAvailableAfterPowerOn` or
   511  	// `AgencyConfigInfo.manuallyMarkAgentVmAvailableAfterProvisioning`
   512  	// hooks. Support for this has been removed. Seting this to
   513  	// <code>true</code> will no longer have any effect.
   514  	//
   515  	// If set to <code>true</code>, the hosts in the scope must be configured
   516  	// for DvFilter before VIBs and agent virtual machines are deployed on
   517  	// them.
   518  	//
   519  	// If not set or set to <code>false</code>, no DvFilter
   520  	// configuration is done on the hosts.
   521  	DvFilterEnabled *bool `xml:"dvFilterEnabled" json:"dvFilterEnabled,omitempty"`
   522  	// Deprecated express that requirement in the VIB descriptor with
   523  	// 'live-remove-allowed=false'.
   524  	//
   525  	// An optional boolean flag to specify whether the agent's host is
   526  	// rebooted after the VIB is uninstalled.
   527  	//
   528  	// If not set, the default value is
   529  	// <code>false</code>. If set to <code>true</code>, the agent gets a
   530  	// `VibRequiresHostReboot` issue after a successful
   531  	// uninstallation.
   532  	RebootHostAfterVibUninstall *bool `xml:"rebootHostAfterVibUninstall" json:"rebootHostAfterVibUninstall,omitempty"`
   533  	// If set the virtual machine will be configured with the services and
   534  	// allow VMCI access from the virtual machine to the installed VIB.
   535  	VmciService []string `xml:"vmciService,omitempty" json:"vmciService,omitempty"`
   536  	// AgentVM disk provisioning type.
   537  	//
   538  	// Defaults to `none` if not specified.
   539  	OvfDiskProvisioning string `xml:"ovfDiskProvisioning,omitempty" json:"ovfDiskProvisioning,omitempty"`
   540  	// Defines the storage policies configured on Agent VMs.
   541  	//
   542  	// Storage policies
   543  	// are configured on all VM related objects including disks.
   544  	// NOTE: The property needs to be configured on each update, otherwise
   545  	// vSphere ESX Agent Manager will unset this configuration for all future
   546  	// agent VMs.
   547  	VmStoragePolicies       []BaseAgentStoragePolicy `xml:"vmStoragePolicies,omitempty,typeattr" json:"vmStoragePolicies,omitempty"`
   548  	VmResourceConfiguration string                   `xml:"vmResourceConfiguration,omitempty" json:"vmResourceConfiguration,omitempty"`
   549  }
   550  
   551  func init() {
   552  	types.Add("eam:AgentConfigInfo", reflect.TypeOf((*AgentConfigInfo)(nil)).Elem())
   553  }
   554  
   555  // Base class for all agent issues.
   556  //
   557  // This structure may be used only with operations rendered under `/eam`.
   558  type AgentIssue struct {
   559  	AgencyIssue
   560  
   561  	// The agent that has this issue.
   562  	//
   563  	// Refers instance of `Agent`.
   564  	Agent types.ManagedObjectReference `xml:"agent" json:"agent"`
   565  	// The name of the agent.
   566  	AgentName string `xml:"agentName" json:"agentName"`
   567  	// The managed object reference to the host on which this agent is located.
   568  	//
   569  	// Refers instance of `HostSystem`.
   570  	Host types.ManagedObjectReference `xml:"host" json:"host"`
   571  	// The name of the host on which this agent is located.
   572  	HostName string `xml:"hostName" json:"hostName"`
   573  }
   574  
   575  func init() {
   576  	types.Add("eam:AgentIssue", reflect.TypeOf((*AgentIssue)(nil)).Elem())
   577  }
   578  
   579  // The <code>OvfEnvironment</code> is used to assign OVF environment
   580  // properties in the `AgentConfigInfo`.
   581  //
   582  // It specifies the values that
   583  // map to properties in the agent virtual machine's OVF descriptor.
   584  //
   585  // This structure may be used only with operations rendered under `/eam`.
   586  type AgentOvfEnvironmentInfo struct {
   587  	types.DynamicData
   588  
   589  	// The OVF properties that are assigned to the agent virtual machine's OVF
   590  	// environment when it is powered on.
   591  	OvfProperty []AgentOvfEnvironmentInfoOvfProperty `xml:"ovfProperty,omitempty" json:"ovfProperty,omitempty"`
   592  }
   593  
   594  func init() {
   595  	types.Add("eam:AgentOvfEnvironmentInfo", reflect.TypeOf((*AgentOvfEnvironmentInfo)(nil)).Elem())
   596  }
   597  
   598  // One OVF property.
   599  //
   600  // This structure may be used only with operations rendered under `/eam`.
   601  type AgentOvfEnvironmentInfoOvfProperty struct {
   602  	types.DynamicData
   603  
   604  	// The name of the property in the OVF descriptor.
   605  	Key string `xml:"key" json:"key"`
   606  	// The value of the property.
   607  	Value string `xml:"value" json:"value"`
   608  }
   609  
   610  func init() {
   611  	types.Add("eam:AgentOvfEnvironmentInfoOvfProperty", reflect.TypeOf((*AgentOvfEnvironmentInfoOvfProperty)(nil)).Elem())
   612  }
   613  
   614  // Specifies an SSL policy that trusts one specific pinned PEM encoded
   615  // SSL certificate.
   616  //
   617  // This structure may be used only with operations rendered under `/eam`.
   618  type AgentPinnedPemCertificate struct {
   619  	AgentSslTrust
   620  
   621  	// PEM encoded pinned SSL certificate of the server that needs to be
   622  	// trusted.
   623  	SslCertificate string `xml:"sslCertificate" json:"sslCertificate"`
   624  }
   625  
   626  func init() {
   627  	types.Add("eam:AgentPinnedPemCertificate", reflect.TypeOf((*AgentPinnedPemCertificate)(nil)).Elem())
   628  	types.AddMinAPIVersionForType("eam:AgentPinnedPemCertificate", "8.2")
   629  }
   630  
   631  type AgentQueryConfig AgentQueryConfigRequestType
   632  
   633  func init() {
   634  	types.Add("eam:AgentQueryConfig", reflect.TypeOf((*AgentQueryConfig)(nil)).Elem())
   635  }
   636  
   637  type AgentQueryConfigRequestType struct {
   638  	This types.ManagedObjectReference `xml:"_this" json:"_this"`
   639  }
   640  
   641  func init() {
   642  	types.Add("eam:AgentQueryConfigRequestType", reflect.TypeOf((*AgentQueryConfigRequestType)(nil)).Elem())
   643  }
   644  
   645  type AgentQueryConfigResponse struct {
   646  	Returnval AgentConfigInfo `xml:"returnval" json:"returnval"`
   647  }
   648  
   649  type AgentQueryRuntime AgentQueryRuntimeRequestType
   650  
   651  func init() {
   652  	types.Add("eam:AgentQueryRuntime", reflect.TypeOf((*AgentQueryRuntime)(nil)).Elem())
   653  }
   654  
   655  type AgentQueryRuntimeRequestType struct {
   656  	This types.ManagedObjectReference `xml:"_this" json:"_this"`
   657  }
   658  
   659  func init() {
   660  	types.Add("eam:AgentQueryRuntimeRequestType", reflect.TypeOf((*AgentQueryRuntimeRequestType)(nil)).Elem())
   661  }
   662  
   663  type AgentQueryRuntimeResponse struct {
   664  	Returnval AgentRuntimeInfo `xml:"returnval" json:"returnval"`
   665  }
   666  
   667  // Extends <code>RuntimeInfo</code> with information regarding the deployment
   668  // of an agent on a specific host.
   669  //
   670  // This structure may be used only with operations rendered under `/eam`.
   671  type AgentRuntimeInfo struct {
   672  	EamObjectRuntimeInfo
   673  
   674  	// Deprecated get that info calling the virtual machine VIM API.
   675  	//
   676  	// The power state of an agent virtual machine.
   677  	VmPowerState types.VirtualMachinePowerState `xml:"vmPowerState" json:"vmPowerState"`
   678  	// Deprecated get that info calling the virtual machine VIM API.
   679  	//
   680  	// True if the vSphere ESX Agent Manager is receiving heartbeats from the
   681  	// agent virtual machine.
   682  	ReceivingHeartBeat bool `xml:"receivingHeartBeat" json:"receivingHeartBeat"`
   683  	// The agent host.
   684  	//
   685  	// Refers instance of `HostSystem`.
   686  	Host *types.ManagedObjectReference `xml:"host,omitempty" json:"host,omitempty"`
   687  	// The agent virtual machine.
   688  	//
   689  	// Refers instance of `VirtualMachine`.
   690  	Vm *types.ManagedObjectReference `xml:"vm,omitempty" json:"vm,omitempty"`
   691  	// Deprecated get that info calling the virtual machine VIM API.
   692  	//
   693  	// The IP address of the agent virtual machine
   694  	VmIp string `xml:"vmIp,omitempty" json:"vmIp,omitempty"`
   695  	// Deprecated get that info calling the virtual machine VIM API.
   696  	//
   697  	// The name of the agent virtual machine.
   698  	VmName string `xml:"vmName" json:"vmName"`
   699  	// Deprecated in order to retrieve agent resource pool use VIM API.
   700  	//
   701  	// The ESX agent resource pool in which the agent virtual machine resides.
   702  	//
   703  	// Refers instance of `ResourcePool`.
   704  	EsxAgentResourcePool *types.ManagedObjectReference `xml:"esxAgentResourcePool,omitempty" json:"esxAgentResourcePool,omitempty"`
   705  	// Deprecated in order to retrieve agent VM folder use VIM API.
   706  	//
   707  	// The ESX agent folder in which the agent virtual machine resides.
   708  	//
   709  	// Refers instance of `Folder`.
   710  	EsxAgentFolder *types.ManagedObjectReference `xml:"esxAgentFolder,omitempty" json:"esxAgentFolder,omitempty"`
   711  	// Deprecated use `AgentRuntimeInfo.installedVibs` instead.
   712  	//
   713  	// An optional array of IDs of installed bulletins for this agent.
   714  	InstalledBulletin []string `xml:"installedBulletin,omitempty" json:"installedBulletin,omitempty"`
   715  	// Information about the installed vibs on the host.
   716  	InstalledVibs []VibVibInfo `xml:"installedVibs,omitempty" json:"installedVibs,omitempty"`
   717  	// The agency this agent belongs to.
   718  	//
   719  	// Refers instance of `Agency`.
   720  	Agency *types.ManagedObjectReference `xml:"agency,omitempty" json:"agency,omitempty"`
   721  	// Active VM hook.
   722  	//
   723  	// If present agent is actively waiting for `Agent.MarkAsAvailable`.
   724  	// See `AgentVmHook`.
   725  	VmHook *AgentVmHook `xml:"vmHook,omitempty" json:"vmHook,omitempty"`
   726  }
   727  
   728  func init() {
   729  	types.Add("eam:AgentRuntimeInfo", reflect.TypeOf((*AgentRuntimeInfo)(nil)).Elem())
   730  }
   731  
   732  // Specifies an SSL trust policy.
   733  //
   734  // This structure may be used only with operations rendered under `/eam`.
   735  type AgentSslTrust struct {
   736  	types.DynamicData
   737  }
   738  
   739  func init() {
   740  	types.Add("eam:AgentSslTrust", reflect.TypeOf((*AgentSslTrust)(nil)).Elem())
   741  	types.AddMinAPIVersionForType("eam:AgentSslTrust", "8.2")
   742  }
   743  
   744  // Specifies the storage policies configured on Agent VMs.
   745  //
   746  // This structure may be used only with operations rendered under `/eam`.
   747  type AgentStoragePolicy struct {
   748  	types.DynamicData
   749  }
   750  
   751  func init() {
   752  	types.Add("eam:AgentStoragePolicy", reflect.TypeOf((*AgentStoragePolicy)(nil)).Elem())
   753  }
   754  
   755  // Deprecated vIB matching rules are no longer supported by EAM. Same
   756  // overlaps with VIB dependency requirements which reside in each
   757  // VIB's metadata.
   758  //
   759  // Specifies regular expressions for Vib name and version.
   760  //
   761  // This structure may be used only with operations rendered under `/eam`.
   762  type AgentVibMatchingRule struct {
   763  	types.DynamicData
   764  
   765  	// Vib name regular expression.
   766  	VibNameRegex string `xml:"vibNameRegex" json:"vibNameRegex"`
   767  	// Vib version regular expression.
   768  	VibVersionRegex string `xml:"vibVersionRegex" json:"vibVersionRegex"`
   769  }
   770  
   771  func init() {
   772  	types.Add("eam:AgentVibMatchingRule", reflect.TypeOf((*AgentVibMatchingRule)(nil)).Elem())
   773  }
   774  
   775  // Represents an active hook of the VM lifecycle which EAM is waiting on to
   776  // be processed by the client.
   777  //
   778  // The supported hooks are defined by
   779  // `AgencyConfigInfo.manuallyMarkAgentVmAvailableAfterProvisioning`
   780  // and
   781  // `AgencyConfigInfo.manuallyMarkAgentVmAvailableAfterProvisioning`.
   782  // See `Agent.MarkAsAvailable`
   783  //
   784  // This structure may be used only with operations rendered under `/eam`.
   785  type AgentVmHook struct {
   786  	types.DynamicData
   787  
   788  	// The VM for which lifecycle is this hook.
   789  	//
   790  	// This VM may differ from `AgentRuntimeInfo.vm` while an upgrade
   791  	// of the agent VM is in progress.
   792  	//
   793  	// Refers instance of `VirtualMachine`.
   794  	Vm types.ManagedObjectReference `xml:"vm" json:"vm"`
   795  	// The current VM lifecycle state.
   796  	VmState string `xml:"vmState" json:"vmState"`
   797  }
   798  
   799  func init() {
   800  	types.Add("eam:AgentVmHook", reflect.TypeOf((*AgentVmHook)(nil)).Elem())
   801  }
   802  
   803  // Specifies vSAN specific storage policy configured on Agent VMs.
   804  //
   805  // This structure may be used only with operations rendered under `/eam`.
   806  type AgentVsanStoragePolicy struct {
   807  	AgentStoragePolicy
   808  
   809  	// ID of a storage policy profile created by the user.
   810  	//
   811  	// The type of the
   812  	// profile must be `VirtualMachineDefinedProfileSpec`. The ID must be valid
   813  	// `VirtualMachineDefinedProfileSpec.profileId`.
   814  	ProfileId string `xml:"profileId" json:"profileId"`
   815  }
   816  
   817  func init() {
   818  	types.Add("eam:AgentVsanStoragePolicy", reflect.TypeOf((*AgentVsanStoragePolicy)(nil)).Elem())
   819  }
   820  
   821  // A boxed array of `AgencyVMFolder`. To be used in `Any` placeholders.
   822  //
   823  // This structure may be used only with operations rendered under `/eam`.
   824  type ArrayOfAgencyVMFolder struct {
   825  	AgencyVMFolder []AgencyVMFolder `xml:"AgencyVMFolder,omitempty" json:"_value"`
   826  }
   827  
   828  func init() {
   829  	types.Add("eam:ArrayOfAgencyVMFolder", reflect.TypeOf((*ArrayOfAgencyVMFolder)(nil)).Elem())
   830  }
   831  
   832  // A boxed array of `AgencyVMResourcePool`. To be used in `Any` placeholders.
   833  //
   834  // This structure may be used only with operations rendered under `/eam`.
   835  type ArrayOfAgencyVMResourcePool struct {
   836  	AgencyVMResourcePool []AgencyVMResourcePool `xml:"AgencyVMResourcePool,omitempty" json:"_value"`
   837  }
   838  
   839  func init() {
   840  	types.Add("eam:ArrayOfAgencyVMResourcePool", reflect.TypeOf((*ArrayOfAgencyVMResourcePool)(nil)).Elem())
   841  }
   842  
   843  // A boxed array of `AgentConfigInfo`. To be used in `Any` placeholders.
   844  //
   845  // This structure may be used only with operations rendered under `/eam`.
   846  type ArrayOfAgentConfigInfo struct {
   847  	AgentConfigInfo []AgentConfigInfo `xml:"AgentConfigInfo,omitempty" json:"_value"`
   848  }
   849  
   850  func init() {
   851  	types.Add("eam:ArrayOfAgentConfigInfo", reflect.TypeOf((*ArrayOfAgentConfigInfo)(nil)).Elem())
   852  }
   853  
   854  // A boxed array of `AgentOvfEnvironmentInfoOvfProperty`. To be used in `Any` placeholders.
   855  //
   856  // This structure may be used only with operations rendered under `/eam`.
   857  type ArrayOfAgentOvfEnvironmentInfoOvfProperty struct {
   858  	AgentOvfEnvironmentInfoOvfProperty []AgentOvfEnvironmentInfoOvfProperty `xml:"AgentOvfEnvironmentInfoOvfProperty,omitempty" json:"_value"`
   859  }
   860  
   861  func init() {
   862  	types.Add("eam:ArrayOfAgentOvfEnvironmentInfoOvfProperty", reflect.TypeOf((*ArrayOfAgentOvfEnvironmentInfoOvfProperty)(nil)).Elem())
   863  }
   864  
   865  // A boxed array of `AgentStoragePolicy`. To be used in `Any` placeholders.
   866  //
   867  // This structure may be used only with operations rendered under `/eam`.
   868  type ArrayOfAgentStoragePolicy struct {
   869  	AgentStoragePolicy []BaseAgentStoragePolicy `xml:"AgentStoragePolicy,omitempty,typeattr" json:"_value"`
   870  }
   871  
   872  func init() {
   873  	types.Add("eam:ArrayOfAgentStoragePolicy", reflect.TypeOf((*ArrayOfAgentStoragePolicy)(nil)).Elem())
   874  }
   875  
   876  // A boxed array of `AgentVibMatchingRule`. To be used in `Any` placeholders.
   877  //
   878  // This structure may be used only with operations rendered under `/eam`.
   879  type ArrayOfAgentVibMatchingRule struct {
   880  	AgentVibMatchingRule []AgentVibMatchingRule `xml:"AgentVibMatchingRule,omitempty" json:"_value"`
   881  }
   882  
   883  func init() {
   884  	types.Add("eam:ArrayOfAgentVibMatchingRule", reflect.TypeOf((*ArrayOfAgentVibMatchingRule)(nil)).Elem())
   885  }
   886  
   887  // A boxed array of `Issue`. To be used in `Any` placeholders.
   888  //
   889  // This structure may be used only with operations rendered under `/eam`.
   890  type ArrayOfIssue struct {
   891  	Issue []BaseIssue `xml:"Issue,omitempty,typeattr" json:"_value"`
   892  }
   893  
   894  func init() {
   895  	types.Add("eam:ArrayOfIssue", reflect.TypeOf((*ArrayOfIssue)(nil)).Elem())
   896  }
   897  
   898  // A boxed array of `SolutionsClusterSolutionComplianceResult`. To be used in `Any` placeholders.
   899  //
   900  // This structure may be used only with operations rendered under `/eam`.
   901  type ArrayOfSolutionsClusterSolutionComplianceResult struct {
   902  	SolutionsClusterSolutionComplianceResult []SolutionsClusterSolutionComplianceResult `xml:"SolutionsClusterSolutionComplianceResult,omitempty" json:"_value"`
   903  }
   904  
   905  func init() {
   906  	types.Add("eam:ArrayOfSolutionsClusterSolutionComplianceResult", reflect.TypeOf((*ArrayOfSolutionsClusterSolutionComplianceResult)(nil)).Elem())
   907  }
   908  
   909  // A boxed array of `SolutionsDeploymentUnitComplianceResult`. To be used in `Any` placeholders.
   910  //
   911  // This structure may be used only with operations rendered under `/eam`.
   912  type ArrayOfSolutionsDeploymentUnitComplianceResult struct {
   913  	SolutionsDeploymentUnitComplianceResult []SolutionsDeploymentUnitComplianceResult `xml:"SolutionsDeploymentUnitComplianceResult,omitempty" json:"_value"`
   914  }
   915  
   916  func init() {
   917  	types.Add("eam:ArrayOfSolutionsDeploymentUnitComplianceResult", reflect.TypeOf((*ArrayOfSolutionsDeploymentUnitComplianceResult)(nil)).Elem())
   918  }
   919  
   920  // A boxed array of `SolutionsHookConfig`. To be used in `Any` placeholders.
   921  //
   922  // This structure may be used only with operations rendered under `/eam`.
   923  type ArrayOfSolutionsHookConfig struct {
   924  	SolutionsHookConfig []SolutionsHookConfig `xml:"SolutionsHookConfig,omitempty" json:"_value"`
   925  }
   926  
   927  func init() {
   928  	types.Add("eam:ArrayOfSolutionsHookConfig", reflect.TypeOf((*ArrayOfSolutionsHookConfig)(nil)).Elem())
   929  }
   930  
   931  // A boxed array of `SolutionsHookInfo`. To be used in `Any` placeholders.
   932  //
   933  // This structure may be used only with operations rendered under `/eam`.
   934  type ArrayOfSolutionsHookInfo struct {
   935  	SolutionsHookInfo []SolutionsHookInfo `xml:"SolutionsHookInfo,omitempty" json:"_value"`
   936  }
   937  
   938  func init() {
   939  	types.Add("eam:ArrayOfSolutionsHookInfo", reflect.TypeOf((*ArrayOfSolutionsHookInfo)(nil)).Elem())
   940  }
   941  
   942  // A boxed array of `SolutionsHostComplianceResult`. To be used in `Any` placeholders.
   943  //
   944  // This structure may be used only with operations rendered under `/eam`.
   945  type ArrayOfSolutionsHostComplianceResult struct {
   946  	SolutionsHostComplianceResult []SolutionsHostComplianceResult `xml:"SolutionsHostComplianceResult,omitempty" json:"_value"`
   947  }
   948  
   949  func init() {
   950  	types.Add("eam:ArrayOfSolutionsHostComplianceResult", reflect.TypeOf((*ArrayOfSolutionsHostComplianceResult)(nil)).Elem())
   951  }
   952  
   953  // A boxed array of `SolutionsOvfProperty`. To be used in `Any` placeholders.
   954  //
   955  // This structure may be used only with operations rendered under `/eam`.
   956  type ArrayOfSolutionsOvfProperty struct {
   957  	SolutionsOvfProperty []SolutionsOvfProperty `xml:"SolutionsOvfProperty,omitempty" json:"_value"`
   958  }
   959  
   960  func init() {
   961  	types.Add("eam:ArrayOfSolutionsOvfProperty", reflect.TypeOf((*ArrayOfSolutionsOvfProperty)(nil)).Elem())
   962  }
   963  
   964  // A boxed array of `SolutionsSolutionComplianceResult`. To be used in `Any` placeholders.
   965  //
   966  // This structure may be used only with operations rendered under `/eam`.
   967  type ArrayOfSolutionsSolutionComplianceResult struct {
   968  	SolutionsSolutionComplianceResult []SolutionsSolutionComplianceResult `xml:"SolutionsSolutionComplianceResult,omitempty" json:"_value"`
   969  }
   970  
   971  func init() {
   972  	types.Add("eam:ArrayOfSolutionsSolutionComplianceResult", reflect.TypeOf((*ArrayOfSolutionsSolutionComplianceResult)(nil)).Elem())
   973  }
   974  
   975  // A boxed array of `SolutionsSolutionConfig`. To be used in `Any` placeholders.
   976  //
   977  // This structure may be used only with operations rendered under `/eam`.
   978  type ArrayOfSolutionsSolutionConfig struct {
   979  	SolutionsSolutionConfig []SolutionsSolutionConfig `xml:"SolutionsSolutionConfig,omitempty" json:"_value"`
   980  }
   981  
   982  func init() {
   983  	types.Add("eam:ArrayOfSolutionsSolutionConfig", reflect.TypeOf((*ArrayOfSolutionsSolutionConfig)(nil)).Elem())
   984  }
   985  
   986  // A boxed array of `SolutionsSolutionValidationResult`. To be used in `Any` placeholders.
   987  //
   988  // This structure may be used only with operations rendered under `/eam`.
   989  type ArrayOfSolutionsSolutionValidationResult struct {
   990  	SolutionsSolutionValidationResult []SolutionsSolutionValidationResult `xml:"SolutionsSolutionValidationResult,omitempty" json:"_value"`
   991  }
   992  
   993  func init() {
   994  	types.Add("eam:ArrayOfSolutionsSolutionValidationResult", reflect.TypeOf((*ArrayOfSolutionsSolutionValidationResult)(nil)).Elem())
   995  }
   996  
   997  // A boxed array of `SolutionsStoragePolicy`. To be used in `Any` placeholders.
   998  //
   999  // This structure may be used only with operations rendered under `/eam`.
  1000  type ArrayOfSolutionsStoragePolicy struct {
  1001  	SolutionsStoragePolicy []BaseSolutionsStoragePolicy `xml:"SolutionsStoragePolicy,omitempty,typeattr" json:"_value"`
  1002  }
  1003  
  1004  func init() {
  1005  	types.Add("eam:ArrayOfSolutionsStoragePolicy", reflect.TypeOf((*ArrayOfSolutionsStoragePolicy)(nil)).Elem())
  1006  }
  1007  
  1008  // A boxed array of `SolutionsVMNetworkMapping`. To be used in `Any` placeholders.
  1009  //
  1010  // This structure may be used only with operations rendered under `/eam`.
  1011  type ArrayOfSolutionsVMNetworkMapping struct {
  1012  	SolutionsVMNetworkMapping []SolutionsVMNetworkMapping `xml:"SolutionsVMNetworkMapping,omitempty" json:"_value"`
  1013  }
  1014  
  1015  func init() {
  1016  	types.Add("eam:ArrayOfSolutionsVMNetworkMapping", reflect.TypeOf((*ArrayOfSolutionsVMNetworkMapping)(nil)).Elem())
  1017  }
  1018  
  1019  // A boxed array of `VibVibInfo`. To be used in `Any` placeholders.
  1020  //
  1021  // This structure may be used only with operations rendered under `/eam`.
  1022  type ArrayOfVibVibInfo struct {
  1023  	VibVibInfo []VibVibInfo `xml:"VibVibInfo,omitempty" json:"_value"`
  1024  }
  1025  
  1026  func init() {
  1027  	types.Add("eam:ArrayOfVibVibInfo", reflect.TypeOf((*ArrayOfVibVibInfo)(nil)).Elem())
  1028  }
  1029  
  1030  // An agent virtual machine is expected to be deployed on a host, but the agent virtual machine
  1031  // cannot be deployed because the vSphere ESX Agent Manager is unable to access the OVF
  1032  // package for the agent.
  1033  //
  1034  // This typically happens because the Web server providing the
  1035  // OVF package is down. The Web server is often internal to the solution
  1036  // that created the Agency.
  1037  //
  1038  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager redeploys the agent.
  1039  //
  1040  // This structure may be used only with operations rendered under `/eam`.
  1041  type CannotAccessAgentOVF struct {
  1042  	VmNotDeployed
  1043  
  1044  	// The URL from which the OVF could not be downloaded.
  1045  	DownloadUrl string `xml:"downloadUrl" json:"downloadUrl"`
  1046  }
  1047  
  1048  func init() {
  1049  	types.Add("eam:CannotAccessAgentOVF", reflect.TypeOf((*CannotAccessAgentOVF)(nil)).Elem())
  1050  }
  1051  
  1052  // An agent VIB module is expected to be deployed on a host, but the VIM module
  1053  // cannot be deployed because the vSphere ESX Agent Manager is unable to access the VIB
  1054  // package for the agent.
  1055  //
  1056  // This typically happens because the Web server providing the
  1057  // VIB package is down. The Web server is often internal to the solution
  1058  // that created the Agency.
  1059  //
  1060  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager reinstalls the VIB module.
  1061  //
  1062  // This structure may be used only with operations rendered under `/eam`.
  1063  type CannotAccessAgentVib struct {
  1064  	VibNotInstalled
  1065  
  1066  	// The URL from which the VIB package could not be downloaded.
  1067  	DownloadUrl string `xml:"downloadUrl" json:"downloadUrl"`
  1068  }
  1069  
  1070  func init() {
  1071  	types.Add("eam:CannotAccessAgentVib", reflect.TypeOf((*CannotAccessAgentVib)(nil)).Elem())
  1072  }
  1073  
  1074  // This exception is thrown if the certificate provided by the
  1075  // provider is not trusted.
  1076  //
  1077  // This structure may be used only with operations rendered under `/sms`.
  1078  type CertificateNotTrusted struct {
  1079  	AgentIssue
  1080  
  1081  	Url string `xml:"url" json:"url"`
  1082  }
  1083  
  1084  func init() {
  1085  	types.Add("eam:CertificateNotTrusted", reflect.TypeOf((*CertificateNotTrusted)(nil)).Elem())
  1086  }
  1087  
  1088  // An CertificateNotTrusted fault is thrown when an Agency's configuration
  1089  // contains OVF package URL or VIB URL for that vSphere ESX Agent Manager is not
  1090  // able to make successful SSL trust verification of the server's certificate.
  1091  //
  1092  // Reasons for this might be that the certificate provided via the API
  1093  // `AgentConfigInfo.ovfSslTrust` and `AgentConfigInfo.vibSslTrust`
  1094  // or via the script /usr/lib/vmware-eam/bin/eam-utility.py
  1095  //   - is invalid.
  1096  //   - does not match the server's certificate.
  1097  //
  1098  // If there is no provided certificate, the fault is thrown when the server's
  1099  // certificate is not trusted by the system or is invalid - @see
  1100  // `AgentConfigInfo.ovfSslTrust` and
  1101  // `AgentConfigInfo.vibSslTrust`.
  1102  // To enable Agency creation 1) provide a valid certificate used by the
  1103  // server hosting the `AgentConfigInfo.ovfPackageUrl` or
  1104  // `AgentConfigInfo.vibUrl` or 2) ensure the server's certificate is
  1105  // signed by a CA trusted by the system. Then retry the operation, vSphere
  1106  // ESX Agent Manager will retry the SSL trust verification and proceed with
  1107  // reaching the desired state.
  1108  //
  1109  // This structure may be used only with operations rendered under `/eam`.
  1110  type CertificateNotTrustedFault struct {
  1111  	EamAppFault
  1112  
  1113  	// The URL that failed the SSL trust verification.
  1114  	Url string `xml:"url,omitempty" json:"url,omitempty"`
  1115  }
  1116  
  1117  func init() {
  1118  	types.Add("eam:CertificateNotTrustedFault", reflect.TypeOf((*CertificateNotTrustedFault)(nil)).Elem())
  1119  	types.AddMinAPIVersionForType("eam:CertificateNotTrustedFault", "8.2")
  1120  }
  1121  
  1122  type CertificateNotTrustedFaultFault CertificateNotTrustedFault
  1123  
  1124  func init() {
  1125  	types.Add("eam:CertificateNotTrustedFaultFault", reflect.TypeOf((*CertificateNotTrustedFaultFault)(nil)).Elem())
  1126  }
  1127  
  1128  // Base class for all cluster bound agents.
  1129  //
  1130  // This structure may be used only with operations rendered under `/eam`.
  1131  type ClusterAgentAgentIssue struct {
  1132  	AgencyIssue
  1133  
  1134  	// The agent that has this issue.
  1135  	//
  1136  	// Refers instance of `Agent`.
  1137  	Agent types.ManagedObjectReference `xml:"agent" json:"agent"`
  1138  	// The cluster for which this issue is raised.
  1139  	//
  1140  	// Migth be null if the cluster
  1141  	// is missing in vCenter Server inventory.
  1142  	//
  1143  	// Refers instance of `ComputeResource`.
  1144  	Cluster *types.ManagedObjectReference `xml:"cluster,omitempty" json:"cluster,omitempty"`
  1145  }
  1146  
  1147  func init() {
  1148  	types.Add("eam:ClusterAgentAgentIssue", reflect.TypeOf((*ClusterAgentAgentIssue)(nil)).Elem())
  1149  }
  1150  
  1151  // The cluster agent Virtual Machine cannot be deployed, because vSphere ESX
  1152  // Agent Manager is not able to make successful SSL trust verification of the
  1153  // server's certificate, when establishing connection to the provided
  1154  // `AgentConfigInfo.ovfPackageUrl`.
  1155  //
  1156  // Reasons for this might be that the
  1157  // certificate provided via the API `AgentConfigInfo.ovfSslTrust` or via
  1158  // the script /usr/lib/vmware-eam/bin/eam-utility.py
  1159  //   - is invalid.
  1160  //   - does not match the server's certificate.
  1161  //
  1162  // If there is no provided certificate, the issue is raised when the server's
  1163  // certificate is not trusted by the system or invalid - @see
  1164  // `AgentConfigInfo.ovfSslTrust`.
  1165  // To remediate the cluster agent Virtual Machine deployment 1) provide a valid
  1166  // certificate used by the server hosting the
  1167  // `AgentConfigInfo.ovfPackageUrl` or 2) ensure the server's certificate
  1168  // is signed by a CA trusted by the system. Then resolve this issue, vSphere ESX
  1169  // Agent Manager will retry the SSL trust verification and proceed with reaching
  1170  // the desired state.
  1171  //
  1172  // This structure may be used only with operations rendered under `/eam`.
  1173  type ClusterAgentCertificateNotTrusted struct {
  1174  	ClusterAgentVmNotDeployed
  1175  
  1176  	// The URL that failed the SSL trust verification.
  1177  	Url string `xml:"url" json:"url"`
  1178  }
  1179  
  1180  func init() {
  1181  	types.Add("eam:ClusterAgentCertificateNotTrusted", reflect.TypeOf((*ClusterAgentCertificateNotTrusted)(nil)).Elem())
  1182  	types.AddMinAPIVersionForType("eam:ClusterAgentCertificateNotTrusted", "8.2")
  1183  }
  1184  
  1185  type ClusterAgentHostInMaintenanceMode struct {
  1186  	ClusterAgentVmIssue
  1187  }
  1188  
  1189  func init() {
  1190  	types.Add("eam:ClusterAgentHostInMaintenanceMode", reflect.TypeOf((*ClusterAgentHostInMaintenanceMode)(nil)).Elem())
  1191  }
  1192  
  1193  type ClusterAgentHostInPartialMaintenanceMode struct {
  1194  	ClusterAgentVmIssue
  1195  }
  1196  
  1197  func init() {
  1198  	types.Add("eam:ClusterAgentHostInPartialMaintenanceMode", reflect.TypeOf((*ClusterAgentHostInPartialMaintenanceMode)(nil)).Elem())
  1199  }
  1200  
  1201  // The cluster agent Virtual Machine could not be powered-on, because the
  1202  // cluster does not have enough CPU or memory resources.
  1203  //
  1204  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager
  1205  // powers on the agent Virtual Machine. However, the problem is likely to
  1206  // persist until enough CPU and memory resources are made available.
  1207  //
  1208  // This structure may be used only with operations rendered under `/eam`.
  1209  type ClusterAgentInsufficientClusterResources struct {
  1210  	ClusterAgentVmPoweredOff
  1211  }
  1212  
  1213  func init() {
  1214  	types.Add("eam:ClusterAgentInsufficientClusterResources", reflect.TypeOf((*ClusterAgentInsufficientClusterResources)(nil)).Elem())
  1215  }
  1216  
  1217  // The cluster agent Virtual Machine cannot be deployed, because any of the
  1218  // configured datastores does not have enough disk space.
  1219  //
  1220  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager
  1221  // redeploys the agent Virtual Machine. However, the problem is likely to
  1222  // persist until enough disk space is freed up on the cluster datastore.
  1223  //
  1224  // This structure may be used only with operations rendered under `/eam`.
  1225  type ClusterAgentInsufficientClusterSpace struct {
  1226  	ClusterAgentVmNotDeployed
  1227  }
  1228  
  1229  func init() {
  1230  	types.Add("eam:ClusterAgentInsufficientClusterSpace", reflect.TypeOf((*ClusterAgentInsufficientClusterSpace)(nil)).Elem())
  1231  }
  1232  
  1233  // Invalid configuration is preventing a cluster agent virtual machine
  1234  // operation.
  1235  //
  1236  // Typically the attached error indicates the particular reason why
  1237  // vSphere ESX Agent Manager is unable to power on or reconfigure the agent
  1238  // virtual machine.
  1239  //
  1240  // This is a passive remediable issue. To remediate update the virtual machine
  1241  // configuration.
  1242  //
  1243  // This structure may be used only with operations rendered under `/eam`.
  1244  type ClusterAgentInvalidConfig struct {
  1245  	ClusterAgentVmIssue
  1246  
  1247  	// The error, that caused this issue.
  1248  	//
  1249  	// It must be either MethodFault or
  1250  	// RuntimeFault.
  1251  	Error types.AnyType `xml:"error,typeattr" json:"error"`
  1252  }
  1253  
  1254  func init() {
  1255  	types.Add("eam:ClusterAgentInvalidConfig", reflect.TypeOf((*ClusterAgentInvalidConfig)(nil)).Elem())
  1256  }
  1257  
  1258  // The cluster agent Virtual Machine cannot be deployed, because any of the
  1259  // configured datastores does not exist on the cluster.
  1260  //
  1261  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager
  1262  // redeploys the agent Virtual Machine. However, the problem is likely to
  1263  // persist until required Virtual Machine datastores are configured on the
  1264  // cluster.
  1265  //
  1266  // This structure may be used only with operations rendered under `/eam`.
  1267  type ClusterAgentMissingClusterVmDatastore struct {
  1268  	ClusterAgentVmNotDeployed
  1269  
  1270  	// A non-empty array of cluster agent VM datastores that are missing on the
  1271  	// cluster.
  1272  	//
  1273  	// Refers instances of `Datastore`.
  1274  	MissingDatastores []types.ManagedObjectReference `xml:"missingDatastores,omitempty" json:"missingDatastores,omitempty"`
  1275  }
  1276  
  1277  func init() {
  1278  	types.Add("eam:ClusterAgentMissingClusterVmDatastore", reflect.TypeOf((*ClusterAgentMissingClusterVmDatastore)(nil)).Elem())
  1279  }
  1280  
  1281  // The cluster agent Virtual Machine cannot be deployed, because the configured
  1282  // networks do not exist on the cluster.
  1283  //
  1284  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager
  1285  // redeploys the agent Virtual Machine. However, the problem is likely to
  1286  // persist until required Virtual Machine networks are configured on the
  1287  // cluster.
  1288  //
  1289  // This structure may be used only with operations rendered under `/eam`.
  1290  type ClusterAgentMissingClusterVmNetwork struct {
  1291  	ClusterAgentVmNotDeployed
  1292  
  1293  	// A non-empty array of cluster agent VM networks that are required on the
  1294  	// cluster.
  1295  	//
  1296  	// Refers instances of `Network`.
  1297  	MissingNetworks []types.ManagedObjectReference `xml:"missingNetworks,omitempty" json:"missingNetworks,omitempty"`
  1298  	// The names of the cluster agent VM networks.
  1299  	NetworkNames []string `xml:"networkNames,omitempty" json:"networkNames,omitempty"`
  1300  }
  1301  
  1302  func init() {
  1303  	types.Add("eam:ClusterAgentMissingClusterVmNetwork", reflect.TypeOf((*ClusterAgentMissingClusterVmNetwork)(nil)).Elem())
  1304  }
  1305  
  1306  // A cluster agent virtual machine needs to be provisioned, but an OVF property
  1307  // is either missing or has an invalid value.
  1308  //
  1309  // This is a passive remediable issue. To remediate, update the OVF environment
  1310  // in the agent configuration used to provision the agent virtual machine.
  1311  //
  1312  // This structure may be used only with operations rendered under `/eam`.
  1313  type ClusterAgentOvfInvalidProperty struct {
  1314  	ClusterAgentAgentIssue
  1315  
  1316  	// An optional list of errors that caused this issue.
  1317  	//
  1318  	// These errors are
  1319  	// generated by the vCenter server.
  1320  	Error []types.LocalizedMethodFault `xml:"error,omitempty" json:"error,omitempty"`
  1321  }
  1322  
  1323  func init() {
  1324  	types.Add("eam:ClusterAgentOvfInvalidProperty", reflect.TypeOf((*ClusterAgentOvfInvalidProperty)(nil)).Elem())
  1325  }
  1326  
  1327  type ClusterAgentVmHookFailed struct {
  1328  	ClusterAgentVmIssue
  1329  }
  1330  
  1331  func init() {
  1332  	types.Add("eam:ClusterAgentVmHookFailed", reflect.TypeOf((*ClusterAgentVmHookFailed)(nil)).Elem())
  1333  }
  1334  
  1335  type ClusterAgentVmHookTimedout struct {
  1336  	ClusterAgentVmIssue
  1337  }
  1338  
  1339  func init() {
  1340  	types.Add("eam:ClusterAgentVmHookTimedout", reflect.TypeOf((*ClusterAgentVmHookTimedout)(nil)).Elem())
  1341  }
  1342  
  1343  type ClusterAgentVmInaccessible struct {
  1344  	ClusterAgentVmIssue
  1345  }
  1346  
  1347  func init() {
  1348  	types.Add("eam:ClusterAgentVmInaccessible", reflect.TypeOf((*ClusterAgentVmInaccessible)(nil)).Elem())
  1349  }
  1350  
  1351  // Base class for all cluster bound Virtual Machines.
  1352  //
  1353  // This structure may be used only with operations rendered under `/eam`.
  1354  type ClusterAgentVmIssue struct {
  1355  	ClusterAgentAgentIssue
  1356  
  1357  	// The Virtual Machine to which this issue is related.
  1358  	//
  1359  	// Refers instance of `VirtualMachine`.
  1360  	Vm types.ManagedObjectReference `xml:"vm" json:"vm"`
  1361  }
  1362  
  1363  func init() {
  1364  	types.Add("eam:ClusterAgentVmIssue", reflect.TypeOf((*ClusterAgentVmIssue)(nil)).Elem())
  1365  }
  1366  
  1367  // A cluster agent Virtual Machine is expected to be deployed on a cluster, but
  1368  // the cluster agent Virtual Machine has not been deployed or has been exlicitly
  1369  // deleted from the cluster.
  1370  //
  1371  // Typically more specific issue (a subclass of this
  1372  // issue) indicates the particular reason why vSphere ESX Agent Manager was
  1373  // unable to deploy the cluster agent Virtual Machine.
  1374  //
  1375  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager
  1376  // redeploys the cluster agent Virtual Machine.
  1377  //
  1378  // This structure may be used only with operations rendered under `/eam`.
  1379  type ClusterAgentVmNotDeployed struct {
  1380  	ClusterAgentAgentIssue
  1381  }
  1382  
  1383  func init() {
  1384  	types.Add("eam:ClusterAgentVmNotDeployed", reflect.TypeOf((*ClusterAgentVmNotDeployed)(nil)).Elem())
  1385  }
  1386  
  1387  // The cluster agent Virtual Machine can not be removed from a cluster.
  1388  //
  1389  // Typically the description indicates the particular reason why vSphere ESX
  1390  // Agent Manager was unable to remove the cluster agent Virtual Machine.
  1391  //
  1392  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager
  1393  // removes the cluster agent Virtual Machine.
  1394  //
  1395  // This structure may be used only with operations rendered under `/eam`.
  1396  type ClusterAgentVmNotRemoved struct {
  1397  	ClusterAgentVmIssue
  1398  }
  1399  
  1400  func init() {
  1401  	types.Add("eam:ClusterAgentVmNotRemoved", reflect.TypeOf((*ClusterAgentVmNotRemoved)(nil)).Elem())
  1402  }
  1403  
  1404  // A cluster agent Virtual Machine is expected to be powered on, but the agent
  1405  // Virtual Machine is powered off.
  1406  //
  1407  // Typically more specific issue (a subclass of
  1408  // this issue) indicates the particular reason why vSphere ESX Agent Manager was
  1409  // unable to power on the cluster agent Virtual Machine.
  1410  //
  1411  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager
  1412  // powers on the cluster agent Virtual Machine.
  1413  //
  1414  // This structure may be used only with operations rendered under `/eam`.
  1415  type ClusterAgentVmPoweredOff struct {
  1416  	ClusterAgentVmIssue
  1417  }
  1418  
  1419  func init() {
  1420  	types.Add("eam:ClusterAgentVmPoweredOff", reflect.TypeOf((*ClusterAgentVmPoweredOff)(nil)).Elem())
  1421  }
  1422  
  1423  // A cluster agent virtual machine is expected to be powered off, but the agent
  1424  // virtual machine is powered on.
  1425  //
  1426  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager
  1427  // powers off the agent virtual machine.
  1428  //
  1429  // This structure may be used only with operations rendered under `/eam`.
  1430  type ClusterAgentVmPoweredOn struct {
  1431  	ClusterAgentVmIssue
  1432  }
  1433  
  1434  func init() {
  1435  	types.Add("eam:ClusterAgentVmPoweredOn", reflect.TypeOf((*ClusterAgentVmPoweredOn)(nil)).Elem())
  1436  }
  1437  
  1438  type ClusterAgentVmProtected struct {
  1439  	ClusterAgentVmIssue
  1440  }
  1441  
  1442  func init() {
  1443  	types.Add("eam:ClusterAgentVmProtected", reflect.TypeOf((*ClusterAgentVmProtected)(nil)).Elem())
  1444  }
  1445  
  1446  // A cluster agent Virtual Machine is expected to be powered on, but the agent
  1447  // Virtual Machine is suspended.
  1448  //
  1449  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager
  1450  // powers on the cluster agent Virtual Machine.
  1451  //
  1452  // This structure may be used only with operations rendered under `/eam`.
  1453  type ClusterAgentVmSuspended struct {
  1454  	ClusterAgentVmIssue
  1455  }
  1456  
  1457  func init() {
  1458  	types.Add("eam:ClusterAgentVmSuspended", reflect.TypeOf((*ClusterAgentVmSuspended)(nil)).Elem())
  1459  }
  1460  
  1461  type CreateAgency CreateAgencyRequestType
  1462  
  1463  func init() {
  1464  	types.Add("eam:CreateAgency", reflect.TypeOf((*CreateAgency)(nil)).Elem())
  1465  }
  1466  
  1467  // The parameters of `EsxAgentManager.CreateAgency`.
  1468  //
  1469  // This structure may be used only with operations rendered under `/eam`.
  1470  type CreateAgencyRequestType struct {
  1471  	This types.ManagedObjectReference `xml:"_this" json:"_this"`
  1472  	// The configuration that describes how to deploy the agents in the
  1473  	// created agency.
  1474  	AgencyConfigInfo BaseAgencyConfigInfo `xml:"agencyConfigInfo,typeattr" json:"agencyConfigInfo"`
  1475  	// Deprecated. No sence to create agency in other state than
  1476  	// <code>enabled</code>. <code>disabled</code> is deprecated
  1477  	// whereas <code>uninstalled</code> is useless.
  1478  	// The initial goal state of the agency. See
  1479  	// `EamObjectRuntimeInfoGoalState_enum`.
  1480  	InitialGoalState string `xml:"initialGoalState" json:"initialGoalState"`
  1481  }
  1482  
  1483  func init() {
  1484  	types.Add("eam:CreateAgencyRequestType", reflect.TypeOf((*CreateAgencyRequestType)(nil)).Elem())
  1485  }
  1486  
  1487  type CreateAgencyResponse struct {
  1488  	Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"`
  1489  }
  1490  
  1491  type DestroyAgency DestroyAgencyRequestType
  1492  
  1493  func init() {
  1494  	types.Add("eam:DestroyAgency", reflect.TypeOf((*DestroyAgency)(nil)).Elem())
  1495  }
  1496  
  1497  type DestroyAgencyRequestType struct {
  1498  	This types.ManagedObjectReference `xml:"_this" json:"_this"`
  1499  }
  1500  
  1501  func init() {
  1502  	types.Add("eam:DestroyAgencyRequestType", reflect.TypeOf((*DestroyAgencyRequestType)(nil)).Elem())
  1503  }
  1504  
  1505  type DestroyAgencyResponse struct {
  1506  }
  1507  
  1508  // Thrown when trying to modify state over disabled clusters.
  1509  //
  1510  // This structure may be used only with operations rendered under `/eam`.
  1511  type DisabledClusterFault struct {
  1512  	EamAppFault
  1513  
  1514  	// The MoRefs of the disabled compute resources.
  1515  	//
  1516  	// Refers instances of `ComputeResource`.
  1517  	DisabledComputeResource []types.ManagedObjectReference `xml:"disabledComputeResource,omitempty" json:"disabledComputeResource,omitempty"`
  1518  }
  1519  
  1520  func init() {
  1521  	types.Add("eam:DisabledClusterFault", reflect.TypeOf((*DisabledClusterFault)(nil)).Elem())
  1522  	types.AddMinAPIVersionForType("eam:DisabledClusterFault", "7.6")
  1523  }
  1524  
  1525  type DisabledClusterFaultFault DisabledClusterFault
  1526  
  1527  func init() {
  1528  	types.Add("eam:DisabledClusterFaultFault", reflect.TypeOf((*DisabledClusterFaultFault)(nil)).Elem())
  1529  }
  1530  
  1531  // Application related error
  1532  // As opposed to system errors, application ones are always function of the
  1533  // input and the current state.
  1534  //
  1535  // They occur always upon same conditions. In most
  1536  // of the cases they are recoverable, i.e. the client can determine what is
  1537  // wrong and know how to recover.
  1538  // NOTE: Since there is not yet need to distinguish among specific error
  1539  // sub-types then we define a common type. Tomorrow, if necessary, we can add an
  1540  // additional level of detailed exception types and make this one abstract.
  1541  //
  1542  // This structure may be used only with operations rendered under `/eam`.
  1543  type EamAppFault struct {
  1544  	EamRuntimeFault
  1545  }
  1546  
  1547  func init() {
  1548  	types.Add("eam:EamAppFault", reflect.TypeOf((*EamAppFault)(nil)).Elem())
  1549  }
  1550  
  1551  type EamAppFaultFault BaseEamAppFault
  1552  
  1553  func init() {
  1554  	types.Add("eam:EamAppFaultFault", reflect.TypeOf((*EamAppFaultFault)(nil)).Elem())
  1555  }
  1556  
  1557  // The common base type for all vSphere ESX Agent Manager exceptions.
  1558  //
  1559  // # TODO migrate to EamRuntimeFault
  1560  //
  1561  // This structure may be used only with operations rendered under `/eam`.
  1562  type EamFault struct {
  1563  	types.MethodFault
  1564  }
  1565  
  1566  func init() {
  1567  	types.Add("eam:EamFault", reflect.TypeOf((*EamFault)(nil)).Elem())
  1568  }
  1569  
  1570  type EamFaultFault BaseEamFault
  1571  
  1572  func init() {
  1573  	types.Add("eam:EamFaultFault", reflect.TypeOf((*EamFaultFault)(nil)).Elem())
  1574  }
  1575  
  1576  // IO error
  1577  // NOTE: Since this type is a first of system-type errors we do not introduce a
  1578  // common base type for them.
  1579  //
  1580  // Once add a second system type exception though, it
  1581  // should be introduced.
  1582  //
  1583  // This structure may be used only with operations rendered under `/eam`.
  1584  type EamIOFault struct {
  1585  	EamRuntimeFault
  1586  }
  1587  
  1588  func init() {
  1589  	types.Add("eam:EamIOFault", reflect.TypeOf((*EamIOFault)(nil)).Elem())
  1590  }
  1591  
  1592  type EamIOFaultFault EamIOFault
  1593  
  1594  func init() {
  1595  	types.Add("eam:EamIOFaultFault", reflect.TypeOf((*EamIOFaultFault)(nil)).Elem())
  1596  }
  1597  
  1598  // Thrown when a user cannot be authenticated.
  1599  //
  1600  // This structure may be used only with operations rendered under `/eam`.
  1601  type EamInvalidLogin struct {
  1602  	EamRuntimeFault
  1603  }
  1604  
  1605  func init() {
  1606  	types.Add("eam:EamInvalidLogin", reflect.TypeOf((*EamInvalidLogin)(nil)).Elem())
  1607  }
  1608  
  1609  type EamInvalidLoginFault EamInvalidLogin
  1610  
  1611  func init() {
  1612  	types.Add("eam:EamInvalidLoginFault", reflect.TypeOf((*EamInvalidLoginFault)(nil)).Elem())
  1613  }
  1614  
  1615  // Thrown when a user is not allowed to execute an operation.
  1616  //
  1617  // This structure may be used only with operations rendered under `/eam`.
  1618  type EamInvalidState struct {
  1619  	EamAppFault
  1620  }
  1621  
  1622  func init() {
  1623  	types.Add("eam:EamInvalidState", reflect.TypeOf((*EamInvalidState)(nil)).Elem())
  1624  }
  1625  
  1626  type EamInvalidStateFault EamInvalidState
  1627  
  1628  func init() {
  1629  	types.Add("eam:EamInvalidStateFault", reflect.TypeOf((*EamInvalidStateFault)(nil)).Elem())
  1630  }
  1631  
  1632  // Indicates for an invalid or unknown Vib package structure and/or format.
  1633  //
  1634  // This structure may be used only with operations rendered under `/eam`.
  1635  type EamInvalidVibPackage struct {
  1636  	EamRuntimeFault
  1637  }
  1638  
  1639  func init() {
  1640  	types.Add("eam:EamInvalidVibPackage", reflect.TypeOf((*EamInvalidVibPackage)(nil)).Elem())
  1641  }
  1642  
  1643  type EamInvalidVibPackageFault EamInvalidVibPackage
  1644  
  1645  func init() {
  1646  	types.Add("eam:EamInvalidVibPackageFault", reflect.TypeOf((*EamInvalidVibPackageFault)(nil)).Elem())
  1647  }
  1648  
  1649  // The <code>RuntimeInfo</code> represents the runtime information of the vSphere ESX Agent
  1650  // Manager managed
  1651  // objects `Agency` and `Agent`.
  1652  //
  1653  // The runtime information provides
  1654  // two kinds of information, namely, the
  1655  // desired goal state of the entity and the status with regards to conforming
  1656  // to that goal state.
  1657  //
  1658  // This structure may be used only with operations rendered under `/eam`.
  1659  type EamObjectRuntimeInfo struct {
  1660  	types.DynamicData
  1661  
  1662  	// The health of the managed entity.
  1663  	//
  1664  	// This denotes how well the entity conforms to the
  1665  	// goal state.
  1666  	//
  1667  	// See also `EamObjectRuntimeInfoStatus_enum`.
  1668  	Status string `xml:"status" json:"status"`
  1669  	// Current issues that have been detected for this entity.
  1670  	//
  1671  	// Each issue can be remediated
  1672  	// by invoking `EamObject.Resolve` or `EamObject.ResolveAll`.
  1673  	Issue []BaseIssue `xml:"issue,omitempty,typeattr" json:"issue,omitempty"`
  1674  	// The desired state of the entity.
  1675  	//
  1676  	// See also `EamObjectRuntimeInfoGoalState_enum`.
  1677  	GoalState string `xml:"goalState" json:"goalState"`
  1678  	// The `Agent` or `Agency` with which this <code>RuntimeInfo</code> object is associated.
  1679  	//
  1680  	// Refers instance of `EamObject`.
  1681  	Entity types.ManagedObjectReference `xml:"entity" json:"entity"`
  1682  }
  1683  
  1684  func init() {
  1685  	types.Add("eam:EamObjectRuntimeInfo", reflect.TypeOf((*EamObjectRuntimeInfo)(nil)).Elem())
  1686  }
  1687  
  1688  // The common base type for all vSphere ESX Agent Manager runtime exceptions.
  1689  //
  1690  // This structure may be used only with operations rendered under `/eam`.
  1691  type EamRuntimeFault struct {
  1692  	types.RuntimeFault
  1693  }
  1694  
  1695  func init() {
  1696  	types.Add("eam:EamRuntimeFault", reflect.TypeOf((*EamRuntimeFault)(nil)).Elem())
  1697  }
  1698  
  1699  type EamRuntimeFaultFault BaseEamRuntimeFault
  1700  
  1701  func init() {
  1702  	types.Add("eam:EamRuntimeFaultFault", reflect.TypeOf((*EamRuntimeFaultFault)(nil)).Elem())
  1703  }
  1704  
  1705  // Thrown when calling vSphere ESX Agent Manager when it is not fully
  1706  // initialized.
  1707  //
  1708  // This structure may be used only with operations rendered under `/eam`.
  1709  type EamServiceNotInitialized struct {
  1710  	EamRuntimeFault
  1711  }
  1712  
  1713  func init() {
  1714  	types.Add("eam:EamServiceNotInitialized", reflect.TypeOf((*EamServiceNotInitialized)(nil)).Elem())
  1715  }
  1716  
  1717  type EamServiceNotInitializedFault EamServiceNotInitialized
  1718  
  1719  func init() {
  1720  	types.Add("eam:EamServiceNotInitializedFault", reflect.TypeOf((*EamServiceNotInitializedFault)(nil)).Elem())
  1721  }
  1722  
  1723  // System fault.
  1724  //
  1725  // This structure may be used only with operations rendered under `/eam`.
  1726  type EamSystemFault struct {
  1727  	EamRuntimeFault
  1728  }
  1729  
  1730  func init() {
  1731  	types.Add("eam:EamSystemFault", reflect.TypeOf((*EamSystemFault)(nil)).Elem())
  1732  }
  1733  
  1734  type EamSystemFaultFault EamSystemFault
  1735  
  1736  func init() {
  1737  	types.Add("eam:EamSystemFaultFault", reflect.TypeOf((*EamSystemFaultFault)(nil)).Elem())
  1738  }
  1739  
  1740  // Extensible issue class used by solutions to add custom issues to agents.
  1741  //
  1742  // When resolved, the issue is removed from the agent and an event is generated.
  1743  //
  1744  // This structure may be used only with operations rendered under `/eam`.
  1745  type ExtensibleIssue struct {
  1746  	Issue
  1747  
  1748  	// Unique string for this type of issue.
  1749  	//
  1750  	// The type must match an event registered
  1751  	// by the solution as part of its extension.
  1752  	TypeId string `xml:"typeId" json:"typeId"`
  1753  	// Arguments associated with the typeId.
  1754  	Argument []types.KeyAnyValue `xml:"argument,omitempty" json:"argument,omitempty"`
  1755  	// A managed object reference to the object this issue is related to.
  1756  	//
  1757  	// Refers instance of `ManagedEntity`.
  1758  	Target *types.ManagedObjectReference `xml:"target,omitempty" json:"target,omitempty"`
  1759  	// An optional agent this issue pertains
  1760  	//
  1761  	// Refers instance of `Agent`.
  1762  	Agent *types.ManagedObjectReference `xml:"agent,omitempty" json:"agent,omitempty"`
  1763  	// An optional agency this issue pertains
  1764  	//
  1765  	// Refers instance of `Agency`.
  1766  	Agency *types.ManagedObjectReference `xml:"agency,omitempty" json:"agency,omitempty"`
  1767  }
  1768  
  1769  func init() {
  1770  	types.Add("eam:ExtensibleIssue", reflect.TypeOf((*ExtensibleIssue)(nil)).Elem())
  1771  }
  1772  
  1773  type GetMaintenanceModePolicy GetMaintenanceModePolicyRequestType
  1774  
  1775  func init() {
  1776  	types.Add("eam:GetMaintenanceModePolicy", reflect.TypeOf((*GetMaintenanceModePolicy)(nil)).Elem())
  1777  }
  1778  
  1779  type GetMaintenanceModePolicyRequestType struct {
  1780  	This types.ManagedObjectReference `xml:"_this" json:"_this"`
  1781  }
  1782  
  1783  func init() {
  1784  	types.Add("eam:GetMaintenanceModePolicyRequestType", reflect.TypeOf((*GetMaintenanceModePolicyRequestType)(nil)).Elem())
  1785  }
  1786  
  1787  type GetMaintenanceModePolicyResponse struct {
  1788  	Returnval string `xml:"returnval" json:"returnval"`
  1789  }
  1790  
  1791  // Limits the hooks reported to the user.
  1792  //
  1793  // This structure may be used only with operations rendered under `/eam`.
  1794  type HooksHookListSpec struct {
  1795  	types.DynamicData
  1796  
  1797  	// If specified - will report hooks only for agents from the specified
  1798  	// solutions, otherwise - will report hooks for agents from all solutions.
  1799  	Solutions []string `xml:"solutions,omitempty" json:"solutions,omitempty"`
  1800  	// If specified - will report hooks only for agents on the specified
  1801  	// hosts, otherwise - will report hooks for agents on all hosts.
  1802  	//
  1803  	// Refers instances of `HostSystem`.
  1804  	Hosts []types.ManagedObjectReference `xml:"hosts,omitempty" json:"hosts,omitempty"`
  1805  }
  1806  
  1807  func init() {
  1808  	types.Add("eam:HooksHookListSpec", reflect.TypeOf((*HooksHookListSpec)(nil)).Elem())
  1809  }
  1810  
  1811  // Specification for marking a raised hook on an agent Virtual Machine as
  1812  // processed.
  1813  //
  1814  // This structure may be used only with operations rendered under `/eam`.
  1815  type HooksMarkAsProcessedSpec struct {
  1816  	types.DynamicData
  1817  
  1818  	// Virtual Machine to mark a hook as processed.
  1819  	//
  1820  	// Refers instance of `VirtualMachine`.
  1821  	Vm types.ManagedObjectReference `xml:"vm" json:"vm"`
  1822  	// Type of hook to be marked as processed `HooksHookType_enum`.
  1823  	HookType string `xml:"hookType" json:"hookType"`
  1824  	// `True` - if the hook was processed successfully, `False` -
  1825  	// if the hook could not be processed.
  1826  	Success bool `xml:"success" json:"success"`
  1827  }
  1828  
  1829  func init() {
  1830  	types.Add("eam:HooksMarkAsProcessedSpec", reflect.TypeOf((*HooksMarkAsProcessedSpec)(nil)).Elem())
  1831  }
  1832  
  1833  // An agent virtual machine operation is expected to be initiated on host, but
  1834  // the agent virtual machine operation has not been initiated.
  1835  //
  1836  // The reason is
  1837  // that the host is in maintenance mode.
  1838  //
  1839  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager
  1840  // takes the host out of maintenance mode and initiates the agent virtual
  1841  // machine operation.
  1842  //
  1843  // Resolving this issue in vSphere Lifecyle Manager environemnt will be no-op.
  1844  // In those cases user must take the host out of Maintenance Mode manually or
  1845  // wait vSphere Lifecycle Maanger cluster remediation to complete (if any).
  1846  //
  1847  // This structure may be used only with operations rendered under `/eam`.
  1848  type HostInMaintenanceMode struct {
  1849  	VmDeployed
  1850  }
  1851  
  1852  func init() {
  1853  	types.Add("eam:HostInMaintenanceMode", reflect.TypeOf((*HostInMaintenanceMode)(nil)).Elem())
  1854  }
  1855  
  1856  type HostInPartialMaintenanceMode struct {
  1857  	AgentIssue
  1858  
  1859  	Vm *types.ManagedObjectReference `xml:"vm,omitempty" json:"vm,omitempty"`
  1860  }
  1861  
  1862  func init() {
  1863  	types.Add("eam:HostInPartialMaintenanceMode", reflect.TypeOf((*HostInPartialMaintenanceMode)(nil)).Elem())
  1864  }
  1865  
  1866  // An agent virtual machine is expected to be removed from a host, but the agent virtual machine has not
  1867  // been removed.
  1868  //
  1869  // The reason is that the host is in standby mode.
  1870  //
  1871  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager puts the host in standby mode
  1872  // and removes the agent virtual machine.
  1873  //
  1874  // This structure may be used only with operations rendered under `/eam`.
  1875  type HostInStandbyMode struct {
  1876  	VmDeployed
  1877  }
  1878  
  1879  func init() {
  1880  	types.Add("eam:HostInStandbyMode", reflect.TypeOf((*HostInStandbyMode)(nil)).Elem())
  1881  }
  1882  
  1883  // Deprecated all host issues were removed.
  1884  //
  1885  // Base class for all host issues.
  1886  //
  1887  // This structure may be used only with operations rendered under `/eam`.
  1888  type HostIssue struct {
  1889  	Issue
  1890  
  1891  	// The host to which the issue is related.
  1892  	//
  1893  	// Refers instance of `HostSystem`.
  1894  	Host types.ManagedObjectReference `xml:"host" json:"host"`
  1895  }
  1896  
  1897  func init() {
  1898  	types.Add("eam:HostIssue", reflect.TypeOf((*HostIssue)(nil)).Elem())
  1899  }
  1900  
  1901  // Deprecated hostPoweredOff will no longer be used, instead
  1902  // `ManagedHostNotReachable` will be raised.
  1903  //
  1904  // An agent virtual machine is expected to be removed from a host, but the agent
  1905  // virtual machine has not been removed.
  1906  //
  1907  // The reason is that the host is powered
  1908  // off.
  1909  //
  1910  // This is not a remediable issue. To remediate, power on the host.
  1911  //
  1912  // This structure may be used only with operations rendered under `/eam`.
  1913  type HostPoweredOff struct {
  1914  	VmDeployed
  1915  }
  1916  
  1917  func init() {
  1918  	types.Add("eam:HostPoweredOff", reflect.TypeOf((*HostPoweredOff)(nil)).Elem())
  1919  }
  1920  
  1921  // Live VIB operation failed.
  1922  //
  1923  // An immediate reboot is required to clear live VIB
  1924  // operation failure.
  1925  //
  1926  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager
  1927  // puts the host into maintenance mode and reboots it.
  1928  //
  1929  // This structure may be used only with operations rendered under `/eam`.
  1930  type ImmediateHostRebootRequired struct {
  1931  	VibIssue
  1932  }
  1933  
  1934  func init() {
  1935  	types.Add("eam:ImmediateHostRebootRequired", reflect.TypeOf((*ImmediateHostRebootRequired)(nil)).Elem())
  1936  }
  1937  
  1938  // An agent virtual machine is expected to be deployed on a host, but the agent could not be
  1939  // deployed because it was incompatible with the host.
  1940  //
  1941  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager redeployes the agent. However,
  1942  // the problem is likely to persist until either the host or the solution has been
  1943  // upgraded, so that the agent will become compatible with the host.
  1944  //
  1945  // This structure may be used only with operations rendered under `/eam`.
  1946  type IncompatibleHostVersion struct {
  1947  	VmNotDeployed
  1948  }
  1949  
  1950  func init() {
  1951  	types.Add("eam:IncompatibleHostVersion", reflect.TypeOf((*IncompatibleHostVersion)(nil)).Elem())
  1952  }
  1953  
  1954  // Deprecated this issue is no longer raised by EAM. It is replaced by
  1955  // `InvalidConfig`.
  1956  //
  1957  // An agent virtual machine is expected to be powered on, but there are no free IP addresses in the
  1958  // agent's pool of virtual machine IP addresses.
  1959  //
  1960  // To remediate, free some IP addresses or add some more to the IP pool and invoke
  1961  // <code>resolve</code>.
  1962  //
  1963  // This structure may be used only with operations rendered under `/eam`.
  1964  type InsufficientIpAddresses struct {
  1965  	VmPoweredOff
  1966  
  1967  	// The agent virtual machine network.
  1968  	//
  1969  	// Refers instance of `Network`.
  1970  	Network types.ManagedObjectReference `xml:"network" json:"network"`
  1971  }
  1972  
  1973  func init() {
  1974  	types.Add("eam:InsufficientIpAddresses", reflect.TypeOf((*InsufficientIpAddresses)(nil)).Elem())
  1975  }
  1976  
  1977  // An agent virtual machine is expected to be deployed on a host, but the agent virtual machine could not be
  1978  // deployed because the host does not have enough free CPU or memory resources.
  1979  //
  1980  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager redeploys the agent virtual machine. However,
  1981  // the problem is likely to persist until enough CPU and memory resources are made available.
  1982  //
  1983  // This structure may be used only with operations rendered under `/eam`.
  1984  type InsufficientResources struct {
  1985  	VmNotDeployed
  1986  }
  1987  
  1988  func init() {
  1989  	types.Add("eam:InsufficientResources", reflect.TypeOf((*InsufficientResources)(nil)).Elem())
  1990  }
  1991  
  1992  // An agent virtual machine is expected to be deployed on a host, but the agent virtual machine could not be
  1993  // deployed because the host's agent datastore did not have enough free space.
  1994  //
  1995  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager redeploys the agent virtual machine. However,
  1996  // the problem is likely to persist until either space is freed up on the host's agent
  1997  // virtual machine datastore or a new agent virtual machine datastore with enough free space is configured.
  1998  //
  1999  // This structure may be used only with operations rendered under `/eam`.
  2000  type InsufficientSpace struct {
  2001  	VmNotDeployed
  2002  }
  2003  
  2004  func init() {
  2005  	types.Add("eam:InsufficientSpace", reflect.TypeOf((*InsufficientSpace)(nil)).Elem())
  2006  }
  2007  
  2008  // Cannot remove the Baseline associated with an Agency from VUM.
  2009  //
  2010  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager
  2011  // retries the delete operation.
  2012  // Note: In future this issue will denote also the removal of the Agency
  2013  // software (VIBs) from VUM software depot once VUM provides an API for that.
  2014  //
  2015  // This structure may be used only with operations rendered under `/eam`.
  2016  type IntegrityAgencyCannotDeleteSoftware struct {
  2017  	IntegrityAgencyVUMIssue
  2018  }
  2019  
  2020  func init() {
  2021  	types.Add("eam:IntegrityAgencyCannotDeleteSoftware", reflect.TypeOf((*IntegrityAgencyCannotDeleteSoftware)(nil)).Elem())
  2022  }
  2023  
  2024  // The software defined by an Agency cannot be staged in VUM.
  2025  //
  2026  // The staging
  2027  // operation consists of the following steps:
  2028  //   - Upload the Agency software (VIBs) to the VUM depot.
  2029  //   - Create or update a VUM Baseline with the Agency software and scope.
  2030  //
  2031  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager
  2032  // retries the stage operation.
  2033  //
  2034  // This structure may be used only with operations rendered under `/eam`.
  2035  type IntegrityAgencyCannotStageSoftware struct {
  2036  	IntegrityAgencyVUMIssue
  2037  }
  2038  
  2039  func init() {
  2040  	types.Add("eam:IntegrityAgencyCannotStageSoftware", reflect.TypeOf((*IntegrityAgencyCannotStageSoftware)(nil)).Elem())
  2041  }
  2042  
  2043  // Base class for all issues which occurred during EAM communication with
  2044  // vSphere Update Manager (VUM).
  2045  //
  2046  // This structure may be used only with operations rendered under `/eam`.
  2047  type IntegrityAgencyVUMIssue struct {
  2048  	AgencyIssue
  2049  }
  2050  
  2051  func init() {
  2052  	types.Add("eam:IntegrityAgencyVUMIssue", reflect.TypeOf((*IntegrityAgencyVUMIssue)(nil)).Elem())
  2053  }
  2054  
  2055  // VUM service is not available - its registered SOAP endpoint cannot be
  2056  // accessed or it is malfunctioning.
  2057  //
  2058  // This is an active and passive remediable issue. To remediate, vSphere ESX
  2059  // Agent Manager retries to access VUM service.
  2060  //
  2061  // This structure may be used only with operations rendered under `/eam`.
  2062  type IntegrityAgencyVUMUnavailable struct {
  2063  	IntegrityAgencyVUMIssue
  2064  }
  2065  
  2066  func init() {
  2067  	types.Add("eam:IntegrityAgencyVUMUnavailable", reflect.TypeOf((*IntegrityAgencyVUMUnavailable)(nil)).Elem())
  2068  }
  2069  
  2070  // An <code>InvalidAgencyScope</code> fault is thrown when the scope in an
  2071  // `AgencyConfigInfo` is invalid.
  2072  //
  2073  // See also `AgencyConfigInfo`.
  2074  //
  2075  // This structure may be used only with operations rendered under `/eam`.
  2076  type InvalidAgencyScope struct {
  2077  	EamFault
  2078  
  2079  	// The MoRefs of the unknown compute resources.
  2080  	//
  2081  	// Refers instances of `ComputeResource`.
  2082  	UnknownComputeResource []types.ManagedObjectReference `xml:"unknownComputeResource,omitempty" json:"unknownComputeResource,omitempty"`
  2083  }
  2084  
  2085  func init() {
  2086  	types.Add("eam:InvalidAgencyScope", reflect.TypeOf((*InvalidAgencyScope)(nil)).Elem())
  2087  }
  2088  
  2089  type InvalidAgencyScopeFault InvalidAgencyScope
  2090  
  2091  func init() {
  2092  	types.Add("eam:InvalidAgencyScopeFault", reflect.TypeOf((*InvalidAgencyScopeFault)(nil)).Elem())
  2093  }
  2094  
  2095  // An <code>InvalidAgentConfiguration</code> fault is thrown when the agent
  2096  // configuration of an agency configuration is empty or invalid.
  2097  //
  2098  // See also `AgencyConfigInfo`.
  2099  //
  2100  // This structure may be used only with operations rendered under `/eam`.
  2101  type InvalidAgentConfiguration struct {
  2102  	EamFault
  2103  
  2104  	// An optional invalid agent configuration.
  2105  	InvalidAgentConfiguration *AgentConfigInfo `xml:"invalidAgentConfiguration,omitempty" json:"invalidAgentConfiguration,omitempty"`
  2106  	// The invalid field.
  2107  	InvalidField string `xml:"invalidField,omitempty" json:"invalidField,omitempty"`
  2108  }
  2109  
  2110  func init() {
  2111  	types.Add("eam:InvalidAgentConfiguration", reflect.TypeOf((*InvalidAgentConfiguration)(nil)).Elem())
  2112  }
  2113  
  2114  type InvalidAgentConfigurationFault InvalidAgentConfiguration
  2115  
  2116  func init() {
  2117  	types.Add("eam:InvalidAgentConfigurationFault", reflect.TypeOf((*InvalidAgentConfigurationFault)(nil)).Elem())
  2118  }
  2119  
  2120  // Invalid configuration is preventing a virtual machine operation.
  2121  //
  2122  // Typically
  2123  // the attached error indicates the particular reason why vSphere ESX Agent
  2124  // Manager is unable to power on or reconfigure the agent virtual machine.
  2125  //
  2126  // This is a passive remediable issue. To remediate update the virtual machine
  2127  // configuration.
  2128  //
  2129  // This structure may be used only with operations rendered under `/eam`.
  2130  type InvalidConfig struct {
  2131  	VmIssue
  2132  
  2133  	// The error, that caused this issue.
  2134  	//
  2135  	// It must be either MethodFault or
  2136  	// RuntimeFault.
  2137  	Error types.AnyType `xml:"error,typeattr" json:"error"`
  2138  }
  2139  
  2140  func init() {
  2141  	types.Add("eam:InvalidConfig", reflect.TypeOf((*InvalidConfig)(nil)).Elem())
  2142  }
  2143  
  2144  // This exception is thrown if `VasaProviderSpec.url` is malformed.
  2145  //
  2146  // This structure may be used only with operations rendered under `/sms`.
  2147  type InvalidUrl struct {
  2148  	EamFault
  2149  
  2150  	// Provider `VasaProviderSpec.url`
  2151  	Url               string `xml:"url" json:"url"`
  2152  	MalformedUrl      bool   `xml:"malformedUrl" json:"malformedUrl"`
  2153  	UnknownHost       bool   `xml:"unknownHost" json:"unknownHost"`
  2154  	ConnectionRefused bool   `xml:"connectionRefused" json:"connectionRefused"`
  2155  	ResponseCode      int32  `xml:"responseCode,omitempty" json:"responseCode,omitempty"`
  2156  }
  2157  
  2158  func init() {
  2159  	types.Add("eam:InvalidUrl", reflect.TypeOf((*InvalidUrl)(nil)).Elem())
  2160  }
  2161  
  2162  type InvalidUrlFault InvalidUrl
  2163  
  2164  func init() {
  2165  	types.Add("eam:InvalidUrlFault", reflect.TypeOf((*InvalidUrlFault)(nil)).Elem())
  2166  }
  2167  
  2168  // An issue represents a problem encountered while deploying and configurating agents
  2169  // in a vCenter installation.
  2170  //
  2171  // An issue conveys the type of problem and the
  2172  // entitity on which the problem has been encountered. Most issues are related to agents,
  2173  // but they can also relate to an agency or a host.
  2174  //
  2175  // The set of issues provided by the vSphere ESX Agent Manager describes the discrepency between
  2176  // the _desired_ agent deployment state, as defined by the agency configurations,
  2177  // and the _actual_ deployment. The (@link EamObject.RuntimeInfo.Status.status)
  2178  // of an agency or agent is green if it has reached its goal state. It is
  2179  // marked as yellow if the vSphere ESX Agent Manager is actively working to bring the object
  2180  // to its goal state. It is red if there is a discrepency between the current state and
  2181  // the desired state. In the red state, a set of issues are filed on the object that
  2182  // describe the reason for the discrepency between the desired and actual states.
  2183  //
  2184  // Issues are characterized as either active or passive remediable issues. For an active
  2185  // remediable issue, the vSphere ESX Agent Manager can actively try to solve the issue. For
  2186  // example, by deploying a new agent, removing an agent, changing its power state, and so
  2187  // on. For a passive remediable issue, the vSphere ESX Agent Manager is not able to solve the
  2188  // problem directly, and can only report the problem. For example, this could be
  2189  // caused by an incomplete host configuration.
  2190  //
  2191  // When <code>resolve</code> is called for an active remediable issue, the vSphere ESX Agent Manager
  2192  // starts performing the appropiate remediation steps for the particular issue. For a passive
  2193  // remediable issue, the EAM manager simply checks if the condition
  2194  // still exists, and if not it removes the issue.
  2195  //
  2196  // The vSphere ESX Agent Manager actively monitors most conditions relating to both
  2197  // active and passive issues. Thus, it often automatically discovers when an
  2198  // issue has been remediated and removes the issue without needing to explicitly
  2199  // call <code>resolve</code> on an issue.
  2200  //
  2201  // The complete Issue hierarchy is shown below:
  2202  //   - `Issue`
  2203  //   - `AgencyIssue`
  2204  //   - `AgentIssue`
  2205  //   - `ManagedHostNotReachable`
  2206  //   - `VmNotDeployed`
  2207  //   - `CannotAccessAgentOVF`
  2208  //   - `IncompatibleHostVersion`
  2209  //   - `InsufficientResources`
  2210  //   - `InsufficientSpace`
  2211  //   - `OvfInvalidFormat`
  2212  //   - `NoAgentVmDatastore`
  2213  //   - `NoAgentVmNetwork`
  2214  //   - `VmIssue`
  2215  //   - `OvfInvalidProperty`
  2216  //   - `VmDeployed`
  2217  //   - `HostInMaintenanceMode`
  2218  //   - `HostInStandbyMode`
  2219  //   - `VmCorrupted`
  2220  //   - `VmOrphaned`
  2221  //   - `VmPoweredOff`
  2222  //   - `InsufficientIpAddresses`
  2223  //   - `MissingAgentIpPool`
  2224  //   - `VmPoweredOn`
  2225  //   - `VmSuspended`
  2226  //   - `VibIssue`
  2227  //   - `VibCannotPutHostInMaintenanceMode`
  2228  //   - `VibNotInstalled`
  2229  //   - `CannotAccessAgentVib`
  2230  //   - `VibDependenciesNotMetByHost`
  2231  //   - `VibInvalidFormat`
  2232  //   - `VibRequirementsNotMetByHost`
  2233  //   - `VibRequiresHostInMaintenanceMode`
  2234  //   - `VibRequiresHostReboot`
  2235  //   - `VibRequiresManualInstallation`
  2236  //   - `VibRequiresManualUninstallation`
  2237  //   - `ImmediateHostRebootRequired`
  2238  //   - `OrphanedAgency`
  2239  //   - `IntegrityAgencyVUMIssue`
  2240  //   - `IntegrityAgencyVUMUnavailable`
  2241  //   - `IntegrityAgencyCannotStageSoftware`
  2242  //   - `IntegrityAgencyCannotDeleteSoftware`
  2243  //   - `ClusterAgentAgentIssue`
  2244  //   - `ClusterAgentVmIssue`
  2245  //   - `ClusterAgentVmNotRemoved`
  2246  //   - `ClusterAgentVmPoweredOff`
  2247  //   - `ClusterAgentInsufficientClusterResources`
  2248  //   - `ClusterAgentVmNotDeployed`
  2249  //   - `ClusterAgentInsufficientClusterSpace`
  2250  //   - `ClusterAgentMissingClusterVmDatastore`
  2251  //   - `ClusterAgentMissingClusterVmNetwork`
  2252  //
  2253  // See also `EamObject.Resolve`, `EamObject.ResolveAll`.
  2254  //
  2255  // This structure may be used only with operations rendered under `/eam`.
  2256  type Issue struct {
  2257  	types.DynamicData
  2258  
  2259  	// A unique identifier per <code>Issue</code> instance.
  2260  	Key int32 `xml:"key" json:"key"`
  2261  	// A localized message describing the issue.
  2262  	Description string `xml:"description" json:"description"`
  2263  	// The point in time when this issue was generated.
  2264  	//
  2265  	// Note that issues can be
  2266  	// regenerated periodically, so this time does not neccessarily reflect the
  2267  	// first time the issue was detected.
  2268  	Time time.Time `xml:"time" json:"time"`
  2269  }
  2270  
  2271  func init() {
  2272  	types.Add("eam:Issue", reflect.TypeOf((*Issue)(nil)).Elem())
  2273  }
  2274  
  2275  // Managed ESXi Server is unreachable from vCenter Server or vSphere ESX Agent
  2276  // Manager.
  2277  //
  2278  // Currently all operations on the affected host are imposible. Reasons
  2279  // for this might be :
  2280  //   - ESXi Server is not connected from vCenter Server
  2281  //   - ESXi Server powered off
  2282  //
  2283  // This is not a remediable issue. To remediate, connect, power on or reboot the
  2284  // host.
  2285  //
  2286  // This structure may be used only with operations rendered under `/eam`.
  2287  type ManagedHostNotReachable struct {
  2288  	AgentIssue
  2289  }
  2290  
  2291  func init() {
  2292  	types.Add("eam:ManagedHostNotReachable", reflect.TypeOf((*ManagedHostNotReachable)(nil)).Elem())
  2293  }
  2294  
  2295  type MarkAsAvailable MarkAsAvailableRequestType
  2296  
  2297  func init() {
  2298  	types.Add("eam:MarkAsAvailable", reflect.TypeOf((*MarkAsAvailable)(nil)).Elem())
  2299  }
  2300  
  2301  type MarkAsAvailableRequestType struct {
  2302  	This types.ManagedObjectReference `xml:"_this" json:"_this"`
  2303  }
  2304  
  2305  func init() {
  2306  	types.Add("eam:MarkAsAvailableRequestType", reflect.TypeOf((*MarkAsAvailableRequestType)(nil)).Elem())
  2307  }
  2308  
  2309  type MarkAsAvailableResponse struct {
  2310  }
  2311  
  2312  // Deprecated this issue is no longer raised by EAM. It is replaced by
  2313  // `InvalidConfig`.
  2314  //
  2315  // An agent virtual machine is expected to be powered on, but the agent virtual machine is powered off because
  2316  // there there are no IP addresses defined on the agent's virtual machine network.
  2317  //
  2318  // To remediate, create an IP pool on the agent's virtual machine network and invoke <code>resolve</code>.
  2319  //
  2320  // This structure may be used only with operations rendered under `/eam`.
  2321  type MissingAgentIpPool struct {
  2322  	VmPoweredOff
  2323  
  2324  	// The agent virtual machine network.
  2325  	//
  2326  	// Refers instance of `Network`.
  2327  	Network types.ManagedObjectReference `xml:"network" json:"network"`
  2328  }
  2329  
  2330  func init() {
  2331  	types.Add("eam:MissingAgentIpPool", reflect.TypeOf((*MissingAgentIpPool)(nil)).Elem())
  2332  }
  2333  
  2334  // Deprecated dvFilters are no longer supported by EAM.
  2335  //
  2336  // The agent is using the dvFilter API on the ESX host, but no dvFilter switch
  2337  // has been configured on the host.
  2338  //
  2339  // This can happen due to host communication
  2340  // failures or if the dvSwitch was (presumably accidentally) deleted from the
  2341  // host configuration.
  2342  //
  2343  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager
  2344  // recreates the dvFilter switch.
  2345  //
  2346  // This structure may be used only with operations rendered under `/eam`.
  2347  type MissingDvFilterSwitch struct {
  2348  	AgentIssue
  2349  }
  2350  
  2351  func init() {
  2352  	types.Add("eam:MissingDvFilterSwitch", reflect.TypeOf((*MissingDvFilterSwitch)(nil)).Elem())
  2353  }
  2354  
  2355  // An agent virtual machine is expected to be deployed on a host, but the agent cannot be
  2356  // deployed because the agent datastore has not been configured on the host.
  2357  //
  2358  // This is a passive remediable issue. The administrator must configure
  2359  // the agent virtual machine datastore on the host.
  2360  //
  2361  // This structure may be used only with operations rendered under `/eam`.
  2362  type NoAgentVmDatastore struct {
  2363  	VmNotDeployed
  2364  }
  2365  
  2366  func init() {
  2367  	types.Add("eam:NoAgentVmDatastore", reflect.TypeOf((*NoAgentVmDatastore)(nil)).Elem())
  2368  }
  2369  
  2370  // An agent virtual machine is expected to be deployed on a host, but the agent cannot be
  2371  // deployed because the agent network has not been configured on the host.
  2372  //
  2373  // This is a passive remediable issue. The administrator must configure
  2374  // the agent virtual machine network on the host.
  2375  //
  2376  // This structure may be used only with operations rendered under `/eam`.
  2377  type NoAgentVmNetwork struct {
  2378  	VmNotDeployed
  2379  }
  2380  
  2381  func init() {
  2382  	types.Add("eam:NoAgentVmNetwork", reflect.TypeOf((*NoAgentVmNetwork)(nil)).Elem())
  2383  }
  2384  
  2385  // Thrown when calling vSphere ESX Agent Manager when it is not connected to the vCenter server.
  2386  //
  2387  // This structure may be used only with operations rendered under `/eam`.
  2388  type NoConnectionToVCenter struct {
  2389  	EamRuntimeFault
  2390  }
  2391  
  2392  func init() {
  2393  	types.Add("eam:NoConnectionToVCenter", reflect.TypeOf((*NoConnectionToVCenter)(nil)).Elem())
  2394  }
  2395  
  2396  type NoConnectionToVCenterFault NoConnectionToVCenter
  2397  
  2398  func init() {
  2399  	types.Add("eam:NoConnectionToVCenterFault", reflect.TypeOf((*NoConnectionToVCenterFault)(nil)).Elem())
  2400  }
  2401  
  2402  // An agent virtual machine is expected to be deployed on a host, but the agent cannot be
  2403  // deployed because the agent datastore has not been configured on the host.
  2404  //
  2405  // The host
  2406  // needs to be added to one of the datastores listed in customAgentVmDatastore.
  2407  //
  2408  // This is a passive remediable issue. The administrator must add one of the datastores
  2409  // customAgentVmDatastore to the host.
  2410  //
  2411  // This structure may be used only with operations rendered under `/eam`.
  2412  type NoCustomAgentVmDatastore struct {
  2413  	NoAgentVmDatastore
  2414  
  2415  	// A non-empty array of agent VM datastores that is required on the host.
  2416  	//
  2417  	// Refers instances of `Datastore`.
  2418  	CustomAgentVmDatastore []types.ManagedObjectReference `xml:"customAgentVmDatastore" json:"customAgentVmDatastore"`
  2419  	// The names of the agent VM datastores.
  2420  	CustomAgentVmDatastoreName []string `xml:"customAgentVmDatastoreName" json:"customAgentVmDatastoreName"`
  2421  }
  2422  
  2423  func init() {
  2424  	types.Add("eam:NoCustomAgentVmDatastore", reflect.TypeOf((*NoCustomAgentVmDatastore)(nil)).Elem())
  2425  }
  2426  
  2427  // An agent virtual machine is expected to be deployed on a host, but the agent cannot be
  2428  // deployed because the agent network has not been configured on the host.
  2429  //
  2430  // The host
  2431  // needs to be added to one of the networks listed in customAgentVmNetwork.
  2432  //
  2433  // This is a passive remediable issue. The administrator must add one of the networks
  2434  // customAgentVmNetwork to the host.
  2435  //
  2436  // This structure may be used only with operations rendered under `/eam`.
  2437  type NoCustomAgentVmNetwork struct {
  2438  	NoAgentVmNetwork
  2439  
  2440  	// A non-empty array of agent VM networks that is required on the host.
  2441  	//
  2442  	// Refers instances of `Network`.
  2443  	CustomAgentVmNetwork []types.ManagedObjectReference `xml:"customAgentVmNetwork" json:"customAgentVmNetwork"`
  2444  	// The names of the agent VM networks.
  2445  	CustomAgentVmNetworkName []string `xml:"customAgentVmNetworkName" json:"customAgentVmNetworkName"`
  2446  }
  2447  
  2448  func init() {
  2449  	types.Add("eam:NoCustomAgentVmNetwork", reflect.TypeOf((*NoCustomAgentVmNetwork)(nil)).Elem())
  2450  }
  2451  
  2452  // An agent virtual machine is expected to be deployed on a host, but the
  2453  // agent cannot be deployed because the agent VM datastore could not be
  2454  // discovered, as per defined selection policy, on the host.
  2455  //
  2456  // This issue can be remediated passively if the administrator configures
  2457  // new datastores on the host.
  2458  //
  2459  // This structure may be used only with operations rendered under `/eam`.
  2460  type NoDiscoverableAgentVmDatastore struct {
  2461  	VmNotDeployed
  2462  }
  2463  
  2464  func init() {
  2465  	types.Add("eam:NoDiscoverableAgentVmDatastore", reflect.TypeOf((*NoDiscoverableAgentVmDatastore)(nil)).Elem())
  2466  }
  2467  
  2468  // An agent virtual machine is expected to be deployed on a host, but the
  2469  // agent cannot be deployed because the agent VM network could not be
  2470  // discovered, as per defined selection policy, on the host.
  2471  //
  2472  // This issue can be remediated passively if the administrator configures
  2473  // new networks on the host.
  2474  //
  2475  // This structure may be used only with operations rendered under `/eam`.
  2476  type NoDiscoverableAgentVmNetwork struct {
  2477  	VmNotDeployed
  2478  }
  2479  
  2480  func init() {
  2481  	types.Add("eam:NoDiscoverableAgentVmNetwork", reflect.TypeOf((*NoDiscoverableAgentVmNetwork)(nil)).Elem())
  2482  }
  2483  
  2484  // Thrown when an a user cannot be authorized.
  2485  //
  2486  // This structure may be used only with operations rendered under `/eam`.
  2487  type NotAuthorized struct {
  2488  	EamRuntimeFault
  2489  }
  2490  
  2491  func init() {
  2492  	types.Add("eam:NotAuthorized", reflect.TypeOf((*NotAuthorized)(nil)).Elem())
  2493  }
  2494  
  2495  type NotAuthorizedFault NotAuthorized
  2496  
  2497  func init() {
  2498  	types.Add("eam:NotAuthorizedFault", reflect.TypeOf((*NotAuthorizedFault)(nil)).Elem())
  2499  }
  2500  
  2501  // Deprecated eAM no longer raises this issue. If agecny is getting orphaned
  2502  // EAM simply destroys it.
  2503  //
  2504  // The solution that created the agency is no longer registered with the vCenter
  2505  // server.
  2506  //
  2507  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager
  2508  // undeploys and removes the agency.
  2509  //
  2510  // This structure may be used only with operations rendered under `/eam`.
  2511  type OrphanedAgency struct {
  2512  	AgencyIssue
  2513  }
  2514  
  2515  func init() {
  2516  	types.Add("eam:OrphanedAgency", reflect.TypeOf((*OrphanedAgency)(nil)).Elem())
  2517  }
  2518  
  2519  // Deprecated dvFilters are no longer supported by EAM.
  2520  //
  2521  // A dvFilter switch exists on a host but no agents on the host depend on
  2522  // dvFilter.
  2523  //
  2524  // This typically happens if a host is disconnected when an agency
  2525  // configuration changed.
  2526  //
  2527  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager
  2528  // removes the dvFilterSwitch.
  2529  //
  2530  // This structure may be used only with operations rendered under `/eam`.
  2531  type OrphanedDvFilterSwitch struct {
  2532  	HostIssue
  2533  }
  2534  
  2535  func init() {
  2536  	types.Add("eam:OrphanedDvFilterSwitch", reflect.TypeOf((*OrphanedDvFilterSwitch)(nil)).Elem())
  2537  }
  2538  
  2539  // An Agent virtual machine is expected to be provisioned on a host, but it failed to do so
  2540  // because the provisioning of the OVF package failed.
  2541  //
  2542  // The provisioning is unlikely to
  2543  // succeed until the solution that provides the OVF package has been upgraded or
  2544  // patched to provide a valid OVF package for the agent virtual machine.
  2545  //
  2546  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager attempts the OVF provisioning again.
  2547  //
  2548  // This structure may be used only with operations rendered under `/eam`.
  2549  type OvfInvalidFormat struct {
  2550  	VmNotDeployed
  2551  
  2552  	// An optional list of errors that caused this issue.
  2553  	//
  2554  	// These errors are generated by the
  2555  	// vCenter server.
  2556  	Error []types.LocalizedMethodFault `xml:"error,omitempty" json:"error,omitempty"`
  2557  }
  2558  
  2559  func init() {
  2560  	types.Add("eam:OvfInvalidFormat", reflect.TypeOf((*OvfInvalidFormat)(nil)).Elem())
  2561  }
  2562  
  2563  // An agent virtual machine needs to be provisioned or reconfigured, but an OVF
  2564  // property is either missing or has an invalid value.
  2565  //
  2566  // This is a passive remediable issue. To remediate, update the OVF environment
  2567  // in the agent configuration used to provision the agent virtual machine.
  2568  //
  2569  // This structure may be used only with operations rendered under `/eam`.
  2570  type OvfInvalidProperty struct {
  2571  	AgentIssue
  2572  
  2573  	// An optional list of errors that caused this issue.
  2574  	//
  2575  	// These errors are
  2576  	// generated by the vCenter server.
  2577  	Error []types.LocalizedMethodFault `xml:"error,omitempty" json:"error,omitempty"`
  2578  }
  2579  
  2580  func init() {
  2581  	types.Add("eam:OvfInvalidProperty", reflect.TypeOf((*OvfInvalidProperty)(nil)).Elem())
  2582  }
  2583  
  2584  // EAM was unable to set its required compute resource configuration in PM.
  2585  //
  2586  // EAM configuration needs to be updated or PM needs to be repaired manually to
  2587  // allow the configuration.
  2588  //
  2589  // This structure may be used only with operations rendered under `/eam`.
  2590  type PersonalityAgencyCannotConfigureSolutions struct {
  2591  	PersonalityAgencyPMIssue
  2592  
  2593  	// Compute resource that couldn't be configured
  2594  	//
  2595  	// Refers instance of `ComputeResource`.
  2596  	Cr types.ManagedObjectReference `xml:"cr" json:"cr"`
  2597  	// Names of the solutions attempted to be modified
  2598  	SolutionsToModify []string `xml:"solutionsToModify,omitempty" json:"solutionsToModify,omitempty"`
  2599  	// Names of the solutions attempted to be removed
  2600  	SolutionsToRemove []string `xml:"solutionsToRemove,omitempty" json:"solutionsToRemove,omitempty"`
  2601  }
  2602  
  2603  func init() {
  2604  	types.Add("eam:PersonalityAgencyCannotConfigureSolutions", reflect.TypeOf((*PersonalityAgencyCannotConfigureSolutions)(nil)).Elem())
  2605  }
  2606  
  2607  // The offline depot could not be uploaded in Personality Manager.
  2608  //
  2609  // This structure may be used only with operations rendered under `/eam`.
  2610  type PersonalityAgencyCannotUploadDepot struct {
  2611  	PersonalityAgencyDepotIssue
  2612  
  2613  	// URL EAM hosted the offline bundle as in vCenter.
  2614  	LocalDepotUrl string `xml:"localDepotUrl" json:"localDepotUrl"`
  2615  }
  2616  
  2617  func init() {
  2618  	types.Add("eam:PersonalityAgencyCannotUploadDepot", reflect.TypeOf((*PersonalityAgencyCannotUploadDepot)(nil)).Elem())
  2619  }
  2620  
  2621  // Base class for all offline depot (VIB) issues while communicating with
  2622  // Personality Manager.
  2623  //
  2624  // This structure may be used only with operations rendered under `/eam`.
  2625  type PersonalityAgencyDepotIssue struct {
  2626  	PersonalityAgencyPMIssue
  2627  
  2628  	// URL the offline bundle is configured in EAM.
  2629  	RemoteDepotUrl string `xml:"remoteDepotUrl" json:"remoteDepotUrl"`
  2630  }
  2631  
  2632  func init() {
  2633  	types.Add("eam:PersonalityAgencyDepotIssue", reflect.TypeOf((*PersonalityAgencyDepotIssue)(nil)).Elem())
  2634  }
  2635  
  2636  // The offline depot was not available for download during communicating with
  2637  // Personality Manager.
  2638  //
  2639  // This structure may be used only with operations rendered under `/eam`.
  2640  type PersonalityAgencyInaccessibleDepot struct {
  2641  	PersonalityAgencyDepotIssue
  2642  }
  2643  
  2644  func init() {
  2645  	types.Add("eam:PersonalityAgencyInaccessibleDepot", reflect.TypeOf((*PersonalityAgencyInaccessibleDepot)(nil)).Elem())
  2646  }
  2647  
  2648  // The offline depot has missing or invalid metadata to be usable by
  2649  // Personality Manager.
  2650  //
  2651  // This structure may be used only with operations rendered under `/eam`.
  2652  type PersonalityAgencyInvalidDepot struct {
  2653  	PersonalityAgencyDepotIssue
  2654  }
  2655  
  2656  func init() {
  2657  	types.Add("eam:PersonalityAgencyInvalidDepot", reflect.TypeOf((*PersonalityAgencyInvalidDepot)(nil)).Elem())
  2658  }
  2659  
  2660  // Base class for all issues which occurred during EAM communication with
  2661  // Personality Manager.
  2662  //
  2663  // This structure may be used only with operations rendered under `/eam`.
  2664  type PersonalityAgencyPMIssue struct {
  2665  	AgencyIssue
  2666  }
  2667  
  2668  func init() {
  2669  	types.Add("eam:PersonalityAgencyPMIssue", reflect.TypeOf((*PersonalityAgencyPMIssue)(nil)).Elem())
  2670  }
  2671  
  2672  // PM service is not available - its endpoint cannot be accessed or it is
  2673  // malfunctioning.
  2674  //
  2675  // This is an active and passive remediable issue. To remediate, vSphere ESX
  2676  // Agent Manager retries to access PM service.
  2677  //
  2678  // This structure may be used only with operations rendered under `/eam`.
  2679  type PersonalityAgencyPMUnavailable struct {
  2680  	PersonalityAgencyPMIssue
  2681  }
  2682  
  2683  func init() {
  2684  	types.Add("eam:PersonalityAgencyPMUnavailable", reflect.TypeOf((*PersonalityAgencyPMUnavailable)(nil)).Elem())
  2685  }
  2686  
  2687  // The agent workflow is blocked until its' required solutions are re-mediated
  2688  // externally in Personality Manager.
  2689  //
  2690  // This issue is only passively remediable. The desired state has to be applied
  2691  // in PM by an user.
  2692  //
  2693  // This structure may be used only with operations rendered under `/eam`.
  2694  type PersonalityAgentAwaitingPMRemediation struct {
  2695  	PersonalityAgentPMIssue
  2696  }
  2697  
  2698  func init() {
  2699  	types.Add("eam:PersonalityAgentAwaitingPMRemediation", reflect.TypeOf((*PersonalityAgentAwaitingPMRemediation)(nil)).Elem())
  2700  }
  2701  
  2702  // The agent workflow is blocked by a failed agency operation with
  2703  // Personality Manager.
  2704  //
  2705  // This issue is only passively remediable. The agency's PM related issue has to
  2706  // be resolved.
  2707  //
  2708  // This structure may be used only with operations rendered under `/eam`.
  2709  type PersonalityAgentBlockedByAgencyOperation struct {
  2710  	PersonalityAgentPMIssue
  2711  }
  2712  
  2713  func init() {
  2714  	types.Add("eam:PersonalityAgentBlockedByAgencyOperation", reflect.TypeOf((*PersonalityAgentBlockedByAgencyOperation)(nil)).Elem())
  2715  }
  2716  
  2717  // Base class for all issues which occurred during EAM communication with
  2718  // Personality Manager.
  2719  //
  2720  // This structure may be used only with operations rendered under `/eam`.
  2721  type PersonalityAgentPMIssue struct {
  2722  	AgentIssue
  2723  }
  2724  
  2725  func init() {
  2726  	types.Add("eam:PersonalityAgentPMIssue", reflect.TypeOf((*PersonalityAgentPMIssue)(nil)).Elem())
  2727  }
  2728  
  2729  type QueryAgency QueryAgencyRequestType
  2730  
  2731  func init() {
  2732  	types.Add("eam:QueryAgency", reflect.TypeOf((*QueryAgency)(nil)).Elem())
  2733  }
  2734  
  2735  type QueryAgencyRequestType struct {
  2736  	This types.ManagedObjectReference `xml:"_this" json:"_this"`
  2737  }
  2738  
  2739  func init() {
  2740  	types.Add("eam:QueryAgencyRequestType", reflect.TypeOf((*QueryAgencyRequestType)(nil)).Elem())
  2741  }
  2742  
  2743  type QueryAgencyResponse struct {
  2744  	Returnval []types.ManagedObjectReference `xml:"returnval,omitempty" json:"returnval,omitempty"`
  2745  }
  2746  
  2747  type QueryAgent QueryAgentRequestType
  2748  
  2749  func init() {
  2750  	types.Add("eam:QueryAgent", reflect.TypeOf((*QueryAgent)(nil)).Elem())
  2751  }
  2752  
  2753  type QueryAgentRequestType struct {
  2754  	This types.ManagedObjectReference `xml:"_this" json:"_this"`
  2755  }
  2756  
  2757  func init() {
  2758  	types.Add("eam:QueryAgentRequestType", reflect.TypeOf((*QueryAgentRequestType)(nil)).Elem())
  2759  }
  2760  
  2761  type QueryAgentResponse struct {
  2762  	Returnval []types.ManagedObjectReference `xml:"returnval,omitempty" json:"returnval,omitempty"`
  2763  }
  2764  
  2765  type QueryConfig QueryConfigRequestType
  2766  
  2767  func init() {
  2768  	types.Add("eam:QueryConfig", reflect.TypeOf((*QueryConfig)(nil)).Elem())
  2769  }
  2770  
  2771  type QueryConfigRequestType struct {
  2772  	This types.ManagedObjectReference `xml:"_this" json:"_this"`
  2773  }
  2774  
  2775  func init() {
  2776  	types.Add("eam:QueryConfigRequestType", reflect.TypeOf((*QueryConfigRequestType)(nil)).Elem())
  2777  }
  2778  
  2779  type QueryConfigResponse struct {
  2780  	Returnval BaseAgencyConfigInfo `xml:"returnval,typeattr" json:"returnval"`
  2781  }
  2782  
  2783  type QueryIssue QueryIssueRequestType
  2784  
  2785  func init() {
  2786  	types.Add("eam:QueryIssue", reflect.TypeOf((*QueryIssue)(nil)).Elem())
  2787  }
  2788  
  2789  // The parameters of `EamObject.QueryIssue`.
  2790  //
  2791  // This structure may be used only with operations rendered under `/eam`.
  2792  type QueryIssueRequestType struct {
  2793  	This types.ManagedObjectReference `xml:"_this" json:"_this"`
  2794  	// An optional array of issue keys. If not set, all issues for this
  2795  	// entity are returned.
  2796  	IssueKey []int32 `xml:"issueKey,omitempty" json:"issueKey,omitempty"`
  2797  }
  2798  
  2799  func init() {
  2800  	types.Add("eam:QueryIssueRequestType", reflect.TypeOf((*QueryIssueRequestType)(nil)).Elem())
  2801  }
  2802  
  2803  type QueryIssueResponse struct {
  2804  	Returnval []BaseIssue `xml:"returnval,omitempty,typeattr" json:"returnval,omitempty"`
  2805  }
  2806  
  2807  type QuerySolutionId QuerySolutionIdRequestType
  2808  
  2809  func init() {
  2810  	types.Add("eam:QuerySolutionId", reflect.TypeOf((*QuerySolutionId)(nil)).Elem())
  2811  }
  2812  
  2813  type QuerySolutionIdRequestType struct {
  2814  	This types.ManagedObjectReference `xml:"_this" json:"_this"`
  2815  }
  2816  
  2817  func init() {
  2818  	types.Add("eam:QuerySolutionIdRequestType", reflect.TypeOf((*QuerySolutionIdRequestType)(nil)).Elem())
  2819  }
  2820  
  2821  type QuerySolutionIdResponse struct {
  2822  	Returnval string `xml:"returnval" json:"returnval"`
  2823  }
  2824  
  2825  type RegisterAgentVm RegisterAgentVmRequestType
  2826  
  2827  func init() {
  2828  	types.Add("eam:RegisterAgentVm", reflect.TypeOf((*RegisterAgentVm)(nil)).Elem())
  2829  }
  2830  
  2831  // The parameters of `Agency.RegisterAgentVm`.
  2832  //
  2833  // This structure may be used only with operations rendered under `/eam`.
  2834  type RegisterAgentVmRequestType struct {
  2835  	This types.ManagedObjectReference `xml:"_this" json:"_this"`
  2836  	// The managed object reference to the agent VM.
  2837  	//
  2838  	// Refers instance of `VirtualMachine`.
  2839  	AgentVm types.ManagedObjectReference `xml:"agentVm" json:"agentVm"`
  2840  }
  2841  
  2842  func init() {
  2843  	types.Add("eam:RegisterAgentVmRequestType", reflect.TypeOf((*RegisterAgentVmRequestType)(nil)).Elem())
  2844  }
  2845  
  2846  type RegisterAgentVmResponse struct {
  2847  	Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"`
  2848  }
  2849  
  2850  type Resolve ResolveRequestType
  2851  
  2852  func init() {
  2853  	types.Add("eam:Resolve", reflect.TypeOf((*Resolve)(nil)).Elem())
  2854  }
  2855  
  2856  type ResolveAll ResolveAllRequestType
  2857  
  2858  func init() {
  2859  	types.Add("eam:ResolveAll", reflect.TypeOf((*ResolveAll)(nil)).Elem())
  2860  }
  2861  
  2862  type ResolveAllRequestType struct {
  2863  	This types.ManagedObjectReference `xml:"_this" json:"_this"`
  2864  }
  2865  
  2866  func init() {
  2867  	types.Add("eam:ResolveAllRequestType", reflect.TypeOf((*ResolveAllRequestType)(nil)).Elem())
  2868  }
  2869  
  2870  type ResolveAllResponse struct {
  2871  }
  2872  
  2873  // The parameters of `EamObject.Resolve`.
  2874  //
  2875  // This structure may be used only with operations rendered under `/eam`.
  2876  type ResolveRequestType struct {
  2877  	This types.ManagedObjectReference `xml:"_this" json:"_this"`
  2878  	// A non-empty array of issue keys.
  2879  	IssueKey []int32 `xml:"issueKey" json:"issueKey"`
  2880  }
  2881  
  2882  func init() {
  2883  	types.Add("eam:ResolveRequestType", reflect.TypeOf((*ResolveRequestType)(nil)).Elem())
  2884  }
  2885  
  2886  type ResolveResponse struct {
  2887  	Returnval []int32 `xml:"returnval,omitempty" json:"returnval,omitempty"`
  2888  }
  2889  
  2890  type ScanForUnknownAgentVm ScanForUnknownAgentVmRequestType
  2891  
  2892  func init() {
  2893  	types.Add("eam:ScanForUnknownAgentVm", reflect.TypeOf((*ScanForUnknownAgentVm)(nil)).Elem())
  2894  }
  2895  
  2896  type ScanForUnknownAgentVmRequestType struct {
  2897  	This types.ManagedObjectReference `xml:"_this" json:"_this"`
  2898  }
  2899  
  2900  func init() {
  2901  	types.Add("eam:ScanForUnknownAgentVmRequestType", reflect.TypeOf((*ScanForUnknownAgentVmRequestType)(nil)).Elem())
  2902  }
  2903  
  2904  type ScanForUnknownAgentVmResponse struct {
  2905  }
  2906  
  2907  type SetMaintenanceModePolicy SetMaintenanceModePolicyRequestType
  2908  
  2909  func init() {
  2910  	types.Add("eam:SetMaintenanceModePolicy", reflect.TypeOf((*SetMaintenanceModePolicy)(nil)).Elem())
  2911  }
  2912  
  2913  // The parameters of `EsxAgentManager.SetMaintenanceModePolicy`.
  2914  //
  2915  // This structure may be used only with operations rendered under `/eam`.
  2916  type SetMaintenanceModePolicyRequestType struct {
  2917  	This types.ManagedObjectReference `xml:"_this" json:"_this"`
  2918  	// The policy to use.
  2919  	Policy string `xml:"policy" json:"policy"`
  2920  }
  2921  
  2922  func init() {
  2923  	types.Add("eam:SetMaintenanceModePolicyRequestType", reflect.TypeOf((*SetMaintenanceModePolicyRequestType)(nil)).Elem())
  2924  	types.AddMinAPIVersionForType("eam:SetMaintenanceModePolicyRequestType", "7.4")
  2925  }
  2926  
  2927  type SetMaintenanceModePolicyResponse struct {
  2928  }
  2929  
  2930  // Specification describing a desired state to be applied.
  2931  //
  2932  // This structure may be used only with operations rendered under `/eam`.
  2933  type SolutionsApplySpec struct {
  2934  	types.DynamicData
  2935  
  2936  	// Complete desired state to be applied on the target entity.
  2937  	//
  2938  	// the `*solutions*` member limits which parts of this desired state to
  2939  	// be applied
  2940  	//
  2941  	//	  If the `*solutions*` member is omitted.
  2942  	//	- Any solution described in this structure will be applied on the
  2943  	//	  target entity
  2944  	//	- Any solution already existing on the target entity, but missing
  2945  	//	  from this structure, will be deleted from the target entity
  2946  	DesiredState []SolutionsSolutionConfig `xml:"desiredState,omitempty" json:"desiredState,omitempty"`
  2947  	// If provided, limits the parts of the `*desiredState*` structure to
  2948  	// be applied on the target entity.
  2949  	//   - solutions that are also present in the `*desiredState*`
  2950  	//     structure will be applied on the target entity.
  2951  	//   - solutions that are missing from the `*desiredState*` structure
  2952  	//     will be deleted from the target entity.
  2953  	Solutions []string `xml:"solutions,omitempty" json:"solutions,omitempty"`
  2954  	// Specifies exact hosts to apply the desired state to, instead of every
  2955  	// host in the cluster.
  2956  	//
  2957  	// Applicable only to solutions with
  2958  	// `SolutionsHostBoundSolutionConfig`.
  2959  	//
  2960  	// Refers instances of `HostSystem`.
  2961  	Hosts []types.ManagedObjectReference `xml:"hosts,omitempty" json:"hosts,omitempty"`
  2962  	// Deployment units on which solutions that are specified by the this
  2963  	// structure need to be applied.
  2964  	//
  2965  	// Applicable only to solutions with
  2966  	// `SolutionsClusterBoundSolutionConfig`.
  2967  	//
  2968  	// The deployment unit represents a single VM instance deployment. It is
  2969  	// returned by the `Solutions.Compliance` operation.
  2970  	//
  2971  	// If omitted - the configured solutions by `SolutionsApplySpec.solutions` are applied
  2972  	// on all of the deployment units in the cluster.
  2973  	DeploymentUnits []string `xml:"deploymentUnits,omitempty" json:"deploymentUnits,omitempty"`
  2974  }
  2975  
  2976  func init() {
  2977  	types.Add("eam:SolutionsApplySpec", reflect.TypeOf((*SolutionsApplySpec)(nil)).Elem())
  2978  }
  2979  
  2980  // Specifies cluster-bound solution configuration.
  2981  //
  2982  // This structure may be used only with operations rendered under `/eam`.
  2983  type SolutionsClusterBoundSolutionConfig struct {
  2984  	SolutionsTypeSpecificSolutionConfig
  2985  
  2986  	// The number of instances of the specified VM to be deployed across the
  2987  	// cluster.
  2988  	VmCount int32 `xml:"vmCount" json:"vmCount"`
  2989  	// VM placement policies to be configured on the VMs
  2990  	// `SolutionsVmPlacementPolicy_enum` If omitted - no VM placement
  2991  	// policies are configured.
  2992  	VmPlacementPolicies []string `xml:"vmPlacementPolicies,omitempty" json:"vmPlacementPolicies,omitempty"`
  2993  	// Networks to be configured on the VMs.
  2994  	//
  2995  	// If omitted - no VM networks are
  2996  	// configured.
  2997  	VmNetworks []SolutionsVMNetworkMapping `xml:"vmNetworks,omitempty" json:"vmNetworks,omitempty"`
  2998  	// Datastores to be configured as a storage of the VMs.
  2999  	//
  3000  	// The first
  3001  	// available datastore in the cluster is used. The collection cannot
  3002  	// contain duplicate elements.
  3003  	//
  3004  	// Refers instances of `Datastore`.
  3005  	Datastores []types.ManagedObjectReference  `xml:"datastores,omitempty" json:"datastores,omitempty"`
  3006  	Devices    *types.VirtualMachineConfigSpec `xml:"devices,omitempty" json:"devices,omitempty"`
  3007  }
  3008  
  3009  func init() {
  3010  	types.Add("eam:SolutionsClusterBoundSolutionConfig", reflect.TypeOf((*SolutionsClusterBoundSolutionConfig)(nil)).Elem())
  3011  }
  3012  
  3013  // Result of a compliance check of a desired state for a solution with
  3014  // `SolutionsClusterBoundSolutionConfig`.
  3015  //
  3016  // This structure may be used only with operations rendered under `/eam`.
  3017  type SolutionsClusterSolutionComplianceResult struct {
  3018  	types.DynamicData
  3019  
  3020  	// The solution being checked for compliance.
  3021  	Solution string `xml:"solution" json:"solution"`
  3022  	// `True` if the solution is compliant with the described desired
  3023  	// state, `False` - otherwise.
  3024  	Compliant bool `xml:"compliant" json:"compliant"`
  3025  	// Detailed per deployment-unit compliance result.
  3026  	DeploymentUnits []SolutionsDeploymentUnitComplianceResult `xml:"deploymentUnits,omitempty" json:"deploymentUnits,omitempty"`
  3027  }
  3028  
  3029  func init() {
  3030  	types.Add("eam:SolutionsClusterSolutionComplianceResult", reflect.TypeOf((*SolutionsClusterSolutionComplianceResult)(nil)).Elem())
  3031  }
  3032  
  3033  // Result of a compliance check of a desired state on a compute resource.
  3034  //
  3035  // This structure may be used only with operations rendered under `/eam`.
  3036  type SolutionsComplianceResult struct {
  3037  	types.DynamicData
  3038  
  3039  	// `True` if the compute resource is compliant with the described
  3040  	// desired state, `False` - otherwise.
  3041  	Compliant bool `xml:"compliant" json:"compliant"`
  3042  	// Detailed per-host compliance result of the compute resource for
  3043  	// solutions with `SolutionsHostBoundSolutionConfig`.
  3044  	Hosts []SolutionsHostComplianceResult `xml:"hosts,omitempty" json:"hosts,omitempty"`
  3045  	// Detailed per-solution unit compliance result of the compute resource
  3046  	// for solutions with `SolutionsClusterBoundSolutionConfig`.
  3047  	ClusterSolutionsCompliance []SolutionsClusterSolutionComplianceResult `xml:"clusterSolutionsCompliance,omitempty" json:"clusterSolutionsCompliance,omitempty"`
  3048  }
  3049  
  3050  func init() {
  3051  	types.Add("eam:SolutionsComplianceResult", reflect.TypeOf((*SolutionsComplianceResult)(nil)).Elem())
  3052  }
  3053  
  3054  // Specification describing how to calculate compliance of a compute resource
  3055  // against a desired state.
  3056  //
  3057  // This structure may be used only with operations rendered under `/eam`.
  3058  type SolutionsComplianceSpec struct {
  3059  	types.DynamicData
  3060  
  3061  	// Desired state to be checked for compliance.
  3062  	//
  3063  	// May be incomplete if exact
  3064  	// solutions to be checked are provided. Empty desired state means all
  3065  	// present solutions must be removed.
  3066  	DesiredState []SolutionsSolutionConfig `xml:"desiredState,omitempty" json:"desiredState,omitempty"`
  3067  	// Specifies exact solutions to be checked for compliance instead of the
  3068  	// complete desired state.
  3069  	Solutions []string `xml:"solutions,omitempty" json:"solutions,omitempty"`
  3070  	// Specifies exact hosts to be checked for compliance of all solutions
  3071  	// with `SolutionsHostBoundSolutionConfig`.
  3072  	//
  3073  	// If omitted - the compliance is checked for all hosts in the cluster.
  3074  	//
  3075  	// Refers instances of `HostSystem`.
  3076  	Hosts []types.ManagedObjectReference `xml:"hosts,omitempty" json:"hosts,omitempty"`
  3077  	// Identifiers of the deployment units that to be checked for compliance
  3078  	// of all solutions with `SolutionsClusterBoundSolutionConfig`.
  3079  	//
  3080  	// The deployment unit represents a single VM instance deployment.
  3081  	//
  3082  	// If omitted - the compliance is checked for all deployment units in the
  3083  	// cluster.
  3084  	DeploymentUnits []string `xml:"deploymentUnits,omitempty" json:"deploymentUnits,omitempty"`
  3085  }
  3086  
  3087  func init() {
  3088  	types.Add("eam:SolutionsComplianceSpec", reflect.TypeOf((*SolutionsComplianceSpec)(nil)).Elem())
  3089  }
  3090  
  3091  // Result of a compliance check of a deployment unit.
  3092  //
  3093  // This structure may be used only with operations rendered under `/eam`.
  3094  type SolutionsDeploymentUnitComplianceResult struct {
  3095  	types.DynamicData
  3096  
  3097  	// The deployment unit being checked for compliance.
  3098  	DeploymentUnit string `xml:"deploymentUnit" json:"deploymentUnit"`
  3099  	// `True` if the deployment unit is compliant with the described
  3100  	// desired state, `False` - otherwise.
  3101  	Compliant bool `xml:"compliant" json:"compliant"`
  3102  	// Detailed compliance result of the deployment unit.
  3103  	Compliance *SolutionsSolutionComplianceResult `xml:"compliance,omitempty" json:"compliance,omitempty"`
  3104  }
  3105  
  3106  func init() {
  3107  	types.Add("eam:SolutionsDeploymentUnitComplianceResult", reflect.TypeOf((*SolutionsDeploymentUnitComplianceResult)(nil)).Elem())
  3108  }
  3109  
  3110  // Specifies the acknowledgement type of a configured System Virtual
  3111  // Machine's lifecycle hook.
  3112  //
  3113  // This structure may be used only with operations rendered under `/eam`.
  3114  type SolutionsHookAcknowledgeConfig struct {
  3115  	types.DynamicData
  3116  }
  3117  
  3118  func init() {
  3119  	types.Add("eam:SolutionsHookAcknowledgeConfig", reflect.TypeOf((*SolutionsHookAcknowledgeConfig)(nil)).Elem())
  3120  }
  3121  
  3122  // Configuration for System Virtual Machine's lifecycle hooks.
  3123  //
  3124  // This structure may be used only with operations rendered under `/eam`.
  3125  type SolutionsHookConfig struct {
  3126  	types.DynamicData
  3127  
  3128  	// Type of the configured hook, possible values - `HooksHookType_enum`.
  3129  	Type string `xml:"type" json:"type"`
  3130  	// Type of acknoledgement of the configured hook.
  3131  	Acknowledgement BaseSolutionsHookAcknowledgeConfig `xml:"acknowledgement,typeattr" json:"acknowledgement"`
  3132  	// The maximum time in seconds to wait for a hook to be processed.
  3133  	//
  3134  	// An
  3135  	// issue is raised if the time elapsed and the hook is still not
  3136  	// processed.
  3137  	// If omitted - defaults to 10 hours.
  3138  	Timeout int64 `xml:"timeout,omitempty" json:"timeout,omitempty"`
  3139  }
  3140  
  3141  func init() {
  3142  	types.Add("eam:SolutionsHookConfig", reflect.TypeOf((*SolutionsHookConfig)(nil)).Elem())
  3143  }
  3144  
  3145  // Contains information for a raised hook.
  3146  //
  3147  // This structure may be used only with operations rendered under `/eam`.
  3148  type SolutionsHookInfo struct {
  3149  	types.DynamicData
  3150  
  3151  	// Virtual Machine, the hook was raised for.
  3152  	//
  3153  	// Refers instance of `VirtualMachine`.
  3154  	Vm types.ManagedObjectReference `xml:"vm" json:"vm"`
  3155  	// Solution the Virtual Machine belongs to.
  3156  	Solution string `xml:"solution" json:"solution"`
  3157  	// Configuration of the hook.
  3158  	Config SolutionsHookConfig `xml:"config" json:"config"`
  3159  	// Time the hook was raised.
  3160  	RaisedAt time.Time `xml:"raisedAt" json:"raisedAt"`
  3161  }
  3162  
  3163  func init() {
  3164  	types.Add("eam:SolutionsHookInfo", reflect.TypeOf((*SolutionsHookInfo)(nil)).Elem())
  3165  }
  3166  
  3167  // Specifies host-bound solution configuration.
  3168  //
  3169  // This structure may be used only with operations rendered under `/eam`.
  3170  type SolutionsHostBoundSolutionConfig struct {
  3171  	SolutionsTypeSpecificSolutionConfig
  3172  
  3173  	// If set to true - default network and datastore configured on host will
  3174  	// take precedence over
  3175  	// `SolutionsHostBoundSolutionConfig.datastores` and
  3176  	// `SolutionsHostBoundSolutionConfig.networks`.
  3177  	PreferHostConfiguration *bool `xml:"preferHostConfiguration" json:"preferHostConfiguration,omitempty"`
  3178  	// networks to satisfy system Virtual Machine network adapter
  3179  	// requirements.
  3180  	//
  3181  	// If omitted - default configured network on the host will
  3182  	// be used.
  3183  	//
  3184  	// Refers instances of `Network`.
  3185  	Networks []types.ManagedObjectReference `xml:"networks,omitempty" json:"networks,omitempty"`
  3186  	// Datastores to be configured as a storage of the VMs.
  3187  	//
  3188  	// The first
  3189  	// available datastore on the host is used. The collection cannot contain
  3190  	// duplicate elements. If omitted - default configured datastore on the
  3191  	// host will be used.
  3192  	//
  3193  	// Refers instances of `Datastore`.
  3194  	Datastores []types.ManagedObjectReference `xml:"datastores,omitempty" json:"datastores,omitempty"`
  3195  	// VMCI to be allowed access from the system Virtual Machine.
  3196  	Vmci []string `xml:"vmci,omitempty" json:"vmci,omitempty"`
  3197  }
  3198  
  3199  func init() {
  3200  	types.Add("eam:SolutionsHostBoundSolutionConfig", reflect.TypeOf((*SolutionsHostBoundSolutionConfig)(nil)).Elem())
  3201  }
  3202  
  3203  // Result of a compliance check of a desired state on a host.
  3204  //
  3205  // This structure may be used only with operations rendered under `/eam`.
  3206  type SolutionsHostComplianceResult struct {
  3207  	types.DynamicData
  3208  
  3209  	// The host being checked for compliance.
  3210  	//
  3211  	// Refers instance of `HostSystem`.
  3212  	Host types.ManagedObjectReference `xml:"host" json:"host"`
  3213  	// `True` if the compute host is compliant with the described
  3214  	// desired state, `False` - otherwise.
  3215  	Compliant bool `xml:"compliant" json:"compliant"`
  3216  	// Detailed per-solution compliance result of the host.
  3217  	Solutions []SolutionsSolutionComplianceResult `xml:"solutions,omitempty" json:"solutions,omitempty"`
  3218  }
  3219  
  3220  func init() {
  3221  	types.Add("eam:SolutionsHostComplianceResult", reflect.TypeOf((*SolutionsHostComplianceResult)(nil)).Elem())
  3222  }
  3223  
  3224  // The user will have to (manually) invoke an API
  3225  // (`Hooks.MarkAsProcessed`) to acknowledge, the user operations for
  3226  // this lifecycle hook have been completed.
  3227  //
  3228  // This structure may be used only with operations rendered under `/eam`.
  3229  type SolutionsInteractiveHookAcknowledgeConfig struct {
  3230  	SolutionsHookAcknowledgeConfig
  3231  }
  3232  
  3233  func init() {
  3234  	types.Add("eam:SolutionsInteractiveHookAcknowledgeConfig", reflect.TypeOf((*SolutionsInteractiveHookAcknowledgeConfig)(nil)).Elem())
  3235  }
  3236  
  3237  // One OVF Property.
  3238  //
  3239  // This structure may be used only with operations rendered under `/eam`.
  3240  type SolutionsOvfProperty struct {
  3241  	types.DynamicData
  3242  
  3243  	// The name of the property in the OVF descriptor.
  3244  	Key string `xml:"key" json:"key"`
  3245  	// The value of the property.
  3246  	Value string `xml:"value" json:"value"`
  3247  }
  3248  
  3249  func init() {
  3250  	types.Add("eam:SolutionsOvfProperty", reflect.TypeOf((*SolutionsOvfProperty)(nil)).Elem())
  3251  }
  3252  
  3253  // Specifies a user defined profile ID to be applied during Virtual Machine
  3254  // creation.
  3255  //
  3256  // This structure may be used only with operations rendered under `/eam`.
  3257  type SolutionsProfileIdStoragePolicy struct {
  3258  	SolutionsStoragePolicy
  3259  
  3260  	// ID of a storage policy profile created by the user.
  3261  	//
  3262  	// The type of the
  3263  	// profile must be `VirtualMachineDefinedProfileSpec`. The ID must be valid
  3264  	// `VirtualMachineDefinedProfileSpec.profileId`.
  3265  	ProfileId string `xml:"profileId" json:"profileId"`
  3266  }
  3267  
  3268  func init() {
  3269  	types.Add("eam:SolutionsProfileIdStoragePolicy", reflect.TypeOf((*SolutionsProfileIdStoragePolicy)(nil)).Elem())
  3270  }
  3271  
  3272  // Result of a compliance check of a desired state dor a solution(on a host).
  3273  //
  3274  // This structure may be used only with operations rendered under `/eam`.
  3275  type SolutionsSolutionComplianceResult struct {
  3276  	types.DynamicData
  3277  
  3278  	// Solution checked for compliance.
  3279  	Solution string `xml:"solution" json:"solution"`
  3280  	// `True` if the compute solution is compliant with the described
  3281  	// desired state, `False` - otherwise.
  3282  	Compliant bool `xml:"compliant" json:"compliant"`
  3283  	// Reason the solution is non-compliant
  3284  	// `SolutionsNonComplianceReason_enum`.
  3285  	NonComplianceReason string `xml:"nonComplianceReason,omitempty" json:"nonComplianceReason,omitempty"`
  3286  	// system Virtual Machine created for the solution.
  3287  	//
  3288  	// Refers instance of `VirtualMachine`.
  3289  	Vm *types.ManagedObjectReference `xml:"vm,omitempty" json:"vm,omitempty"`
  3290  	// system Virtual Machine created for upgrading the obsoleted system
  3291  	// Virtual Machine.
  3292  	//
  3293  	// Refers instance of `VirtualMachine`.
  3294  	UpgradingVm *types.ManagedObjectReference `xml:"upgradingVm,omitempty" json:"upgradingVm,omitempty"`
  3295  	// Hook, ESX Agent Manager is awaiting to be processed for this solution.
  3296  	Hook *SolutionsHookInfo `xml:"hook,omitempty" json:"hook,omitempty"`
  3297  	// Issues, ESX Agent Manager has encountered while attempting to acheive
  3298  	// the solution's requested desired state.
  3299  	Issues []BaseIssue `xml:"issues,omitempty,typeattr" json:"issues,omitempty"`
  3300  	// Last desired state for the solution, requested from ESX Agent Manager,
  3301  	// for application.
  3302  	SolutionConfig *SolutionsSolutionConfig `xml:"solutionConfig,omitempty" json:"solutionConfig,omitempty"`
  3303  }
  3304  
  3305  func init() {
  3306  	types.Add("eam:SolutionsSolutionComplianceResult", reflect.TypeOf((*SolutionsSolutionComplianceResult)(nil)).Elem())
  3307  }
  3308  
  3309  // Configuration for a solution's required system Virtual Machine.
  3310  //
  3311  // This structure may be used only with operations rendered under `/eam`.
  3312  type SolutionsSolutionConfig struct {
  3313  	types.DynamicData
  3314  
  3315  	// Solution, this configuration belongs to.
  3316  	Solution string `xml:"solution" json:"solution"`
  3317  	// Display name of the solution.
  3318  	DisplayName string `xml:"displayName" json:"displayName"`
  3319  	// Display version of the solution.
  3320  	DisplayVersion string `xml:"displayVersion" json:"displayVersion"`
  3321  	// Source of the system Virtual Machine files.
  3322  	VmSource BaseSolutionsVMSource `xml:"vmSource,typeattr" json:"vmSource"`
  3323  	// VM name prefix.
  3324  	PrefixVmName string `xml:"prefixVmName" json:"prefixVmName"`
  3325  	// If set to `True` - will insert an UUID in the system Virtual
  3326  	// Machines' names created for the solution, otherwise - no additional
  3327  	// UUID will be inserted in the system Virtual Machines' names.
  3328  	UuidVmName bool `xml:"uuidVmName" json:"uuidVmName"`
  3329  	// Resource pool to place the system Virtual Machine in.
  3330  	//
  3331  	// If omitted a
  3332  	// default resource pool will be used.
  3333  	//
  3334  	// Refers instance of `ResourcePool`.
  3335  	ResourcePool *types.ManagedObjectReference `xml:"resourcePool,omitempty" json:"resourcePool,omitempty"`
  3336  	// Folder to place the system Virtual Machine in.
  3337  	//
  3338  	// If omitted a default
  3339  	// folder will be used.
  3340  	//
  3341  	// Refers instance of `Folder`.
  3342  	Folder *types.ManagedObjectReference `xml:"folder,omitempty" json:"folder,omitempty"`
  3343  	// User configurable OVF properties to be assigned during system Virtual
  3344  	// Machine creation.
  3345  	OvfProperties []SolutionsOvfProperty `xml:"ovfProperties,omitempty" json:"ovfProperties,omitempty"`
  3346  	// Storage policies to be applied during system Virtual Machine creation.
  3347  	StoragePolicies []BaseSolutionsStoragePolicy `xml:"storagePolicies,omitempty,typeattr" json:"storagePolicies,omitempty"`
  3348  	// Provisioning type for the system Virtual Machines
  3349  	// `SolutionsVMDiskProvisioning_enum`.
  3350  	//
  3351  	// Default provisioning will be used
  3352  	// if not specified.
  3353  	VmDiskProvisioning string `xml:"vmDiskProvisioning,omitempty" json:"vmDiskProvisioning,omitempty"`
  3354  	// Optimization strategy for deploying Virtual Machines
  3355  	// `SolutionsVMDeploymentOptimization_enum`.
  3356  	//
  3357  	// Default optimization will
  3358  	// be selected if not specified.
  3359  	VmDeploymentOptimization string `xml:"vmDeploymentOptimization,omitempty" json:"vmDeploymentOptimization,omitempty"`
  3360  	// Solution type-specific configuration.
  3361  	TypeSpecificConfig BaseSolutionsTypeSpecificSolutionConfig `xml:"typeSpecificConfig,typeattr" json:"typeSpecificConfig"`
  3362  	// Lifecycle hooks for the solution's virtual machines.
  3363  	Hooks []SolutionsHookConfig `xml:"hooks,omitempty" json:"hooks,omitempty"`
  3364  	// VMs resource configuration.
  3365  	//
  3366  	// If omitted - the default resource
  3367  	// configuration specified in the OVF descriptor is used.
  3368  	VmResourceSpec *SolutionsVmResourceSpec `xml:"vmResourceSpec,omitempty" json:"vmResourceSpec,omitempty"`
  3369  }
  3370  
  3371  func init() {
  3372  	types.Add("eam:SolutionsSolutionConfig", reflect.TypeOf((*SolutionsSolutionConfig)(nil)).Elem())
  3373  }
  3374  
  3375  // Result of validation, of a solution, for application.
  3376  //
  3377  // This structure may be used only with operations rendered under `/eam`.
  3378  type SolutionsSolutionValidationResult struct {
  3379  	types.DynamicData
  3380  
  3381  	// Validated solution.
  3382  	Solution string `xml:"solution" json:"solution"`
  3383  	// `True` - if the solution is valid for application, `False`
  3384  	// \- otherwise.
  3385  	Valid bool `xml:"valid" json:"valid"`
  3386  	// Populated with the reason the solution is not valid for application
  3387  	// `SolutionsInvalidReason_enum`.
  3388  	InvalidReason string `xml:"invalidReason,omitempty" json:"invalidReason,omitempty"`
  3389  }
  3390  
  3391  func init() {
  3392  	types.Add("eam:SolutionsSolutionValidationResult", reflect.TypeOf((*SolutionsSolutionValidationResult)(nil)).Elem())
  3393  }
  3394  
  3395  // Storage policy to be applied during system Virtual Machine creation.
  3396  //
  3397  // This structure may be used only with operations rendered under `/eam`.
  3398  type SolutionsStoragePolicy struct {
  3399  	types.DynamicData
  3400  }
  3401  
  3402  func init() {
  3403  	types.Add("eam:SolutionsStoragePolicy", reflect.TypeOf((*SolutionsStoragePolicy)(nil)).Elem())
  3404  }
  3405  
  3406  // Specification necessary to transition a solution from an existing legacy
  3407  // agency.
  3408  //
  3409  // This structure may be used only with operations rendered under `/eam`.
  3410  type SolutionsTransitionSpec struct {
  3411  	types.DynamicData
  3412  
  3413  	// Solution to transition from an old legacy agency.
  3414  	Solution string `xml:"solution" json:"solution"`
  3415  	// Old legacy agency ID to transition from.
  3416  	AgencyId string `xml:"agencyId" json:"agencyId"`
  3417  }
  3418  
  3419  func init() {
  3420  	types.Add("eam:SolutionsTransitionSpec", reflect.TypeOf((*SolutionsTransitionSpec)(nil)).Elem())
  3421  }
  3422  
  3423  // Specifies the specific solution configuration based on its type.
  3424  //
  3425  // This structure may be used only with operations rendered under `/eam`.
  3426  type SolutionsTypeSpecificSolutionConfig struct {
  3427  	types.DynamicData
  3428  }
  3429  
  3430  func init() {
  3431  	types.Add("eam:SolutionsTypeSpecificSolutionConfig", reflect.TypeOf((*SolutionsTypeSpecificSolutionConfig)(nil)).Elem())
  3432  }
  3433  
  3434  // Specified the system Virtual Machine sources are to be obtained from an
  3435  // URL.
  3436  //
  3437  // This structure may be used only with operations rendered under `/eam`.
  3438  type SolutionsUrlVMSource struct {
  3439  	SolutionsVMSource
  3440  
  3441  	// URL to the solution's system Virtual Machine OVF.
  3442  	OvfUrl string `xml:"ovfUrl" json:"ovfUrl"`
  3443  	// Overrides the OVF URL certificate validation.
  3444  	//
  3445  	// If `True` or
  3446  	// `<unset>` - the certificate will be subject to standard trust
  3447  	// validation, if `False` - any certificate will be considered
  3448  	// trusted.
  3449  	CertificateValidation *bool `xml:"certificateValidation" json:"certificateValidation,omitempty"`
  3450  	// PEM encoded certificate to use to trust the URL.
  3451  	//
  3452  	// If omitted - URL will
  3453  	// be trusted using well known methods.
  3454  	CertificatePEM string `xml:"certificatePEM,omitempty" json:"certificatePEM,omitempty"`
  3455  }
  3456  
  3457  func init() {
  3458  	types.Add("eam:SolutionsUrlVMSource", reflect.TypeOf((*SolutionsUrlVMSource)(nil)).Elem())
  3459  }
  3460  
  3461  // Represents the mapping of the logical network defined in the OVF
  3462  // descriptor to the Virtual Infrastructure (VI) network.
  3463  //
  3464  // This structure may be used only with operations rendered under `/eam`.
  3465  type SolutionsVMNetworkMapping struct {
  3466  	types.DynamicData
  3467  
  3468  	// Logical network name defined in the OVF descriptor.
  3469  	Name string `xml:"name" json:"name"`
  3470  	// VM network identifier.
  3471  	//
  3472  	// Refers instance of `Network`.
  3473  	Id types.ManagedObjectReference `xml:"id" json:"id"`
  3474  }
  3475  
  3476  func init() {
  3477  	types.Add("eam:SolutionsVMNetworkMapping", reflect.TypeOf((*SolutionsVMNetworkMapping)(nil)).Elem())
  3478  }
  3479  
  3480  // Specifies how to find the files of the system Virtual Machine to be
  3481  // created.
  3482  //
  3483  // This structure may be used only with operations rendered under `/eam`.
  3484  type SolutionsVMSource struct {
  3485  	types.DynamicData
  3486  }
  3487  
  3488  func init() {
  3489  	types.Add("eam:SolutionsVMSource", reflect.TypeOf((*SolutionsVMSource)(nil)).Elem())
  3490  }
  3491  
  3492  // Specification describing a desired state to be validated for application.
  3493  //
  3494  // This structure may be used only with operations rendered under `/eam`.
  3495  type SolutionsValidateSpec struct {
  3496  	types.DynamicData
  3497  
  3498  	// Desired state to be validated.
  3499  	DesiredState []SolutionsSolutionConfig `xml:"desiredState" json:"desiredState"`
  3500  }
  3501  
  3502  func init() {
  3503  	types.Add("eam:SolutionsValidateSpec", reflect.TypeOf((*SolutionsValidateSpec)(nil)).Elem())
  3504  }
  3505  
  3506  // Result of validation, of a desired state, for application.
  3507  //
  3508  // This structure may be used only with operations rendered under `/eam`.
  3509  type SolutionsValidationResult struct {
  3510  	types.DynamicData
  3511  
  3512  	// `True` - if the desired state is valid for application,
  3513  	// `False` - otherwise.
  3514  	Valid bool `xml:"valid" json:"valid"`
  3515  	// Detailed per-solution result of the validation.
  3516  	SolutionResult []SolutionsSolutionValidationResult `xml:"solutionResult,omitempty" json:"solutionResult,omitempty"`
  3517  }
  3518  
  3519  func init() {
  3520  	types.Add("eam:SolutionsValidationResult", reflect.TypeOf((*SolutionsValidationResult)(nil)).Elem())
  3521  }
  3522  
  3523  // Specifies the VM resource configurations.
  3524  //
  3525  // This structure may be used only with operations rendered under `/eam`.
  3526  type SolutionsVmResourceSpec struct {
  3527  	types.DynamicData
  3528  
  3529  	// The VM deployment option that corresponds to the Configuration element
  3530  	// of the DeploymentOptionSection in the OVF descriptor (e.g.
  3531  	//
  3532  	// "small",
  3533  	// "medium", "large").
  3534  	// If omitted - the default deployment option as specified in the OVF
  3535  	// descriptor is used.
  3536  	OvfDeploymentOption string `xml:"ovfDeploymentOption,omitempty" json:"ovfDeploymentOption,omitempty"`
  3537  }
  3538  
  3539  func init() {
  3540  	types.Add("eam:SolutionsVmResourceSpec", reflect.TypeOf((*SolutionsVmResourceSpec)(nil)).Elem())
  3541  }
  3542  
  3543  type Uninstall UninstallRequestType
  3544  
  3545  func init() {
  3546  	types.Add("eam:Uninstall", reflect.TypeOf((*Uninstall)(nil)).Elem())
  3547  }
  3548  
  3549  type UninstallRequestType struct {
  3550  	This types.ManagedObjectReference `xml:"_this" json:"_this"`
  3551  }
  3552  
  3553  func init() {
  3554  	types.Add("eam:UninstallRequestType", reflect.TypeOf((*UninstallRequestType)(nil)).Elem())
  3555  }
  3556  
  3557  type UninstallResponse struct {
  3558  }
  3559  
  3560  // Deprecated presence of unknown VMs is no more acceptable.
  3561  //
  3562  // An agent virtual machine has been found in the vCenter inventory that does
  3563  // not belong to any agency in this vSphere ESX Agent Manager server instance.
  3564  //
  3565  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager
  3566  // powers off (if powered on) and deletes the agent virtual machine.
  3567  //
  3568  // This structure may be used only with operations rendered under `/eam`.
  3569  type UnknownAgentVm struct {
  3570  	HostIssue
  3571  
  3572  	// The unknown agent virtual machine.
  3573  	//
  3574  	// Refers instance of `VirtualMachine`.
  3575  	Vm types.ManagedObjectReference `xml:"vm" json:"vm"`
  3576  }
  3577  
  3578  func init() {
  3579  	types.Add("eam:UnknownAgentVm", reflect.TypeOf((*UnknownAgentVm)(nil)).Elem())
  3580  }
  3581  
  3582  type UnregisterAgentVm UnregisterAgentVmRequestType
  3583  
  3584  func init() {
  3585  	types.Add("eam:UnregisterAgentVm", reflect.TypeOf((*UnregisterAgentVm)(nil)).Elem())
  3586  }
  3587  
  3588  // The parameters of `Agency.UnregisterAgentVm`.
  3589  //
  3590  // This structure may be used only with operations rendered under `/eam`.
  3591  type UnregisterAgentVmRequestType struct {
  3592  	This types.ManagedObjectReference `xml:"_this" json:"_this"`
  3593  	// The managed object reference to the agent VM.
  3594  	//
  3595  	// Refers instance of `VirtualMachine`.
  3596  	AgentVm types.ManagedObjectReference `xml:"agentVm" json:"agentVm"`
  3597  }
  3598  
  3599  func init() {
  3600  	types.Add("eam:UnregisterAgentVmRequestType", reflect.TypeOf((*UnregisterAgentVmRequestType)(nil)).Elem())
  3601  }
  3602  
  3603  type UnregisterAgentVmResponse struct {
  3604  }
  3605  
  3606  type Update UpdateRequestType
  3607  
  3608  func init() {
  3609  	types.Add("eam:Update", reflect.TypeOf((*Update)(nil)).Elem())
  3610  }
  3611  
  3612  // The parameters of `Agency.Update`.
  3613  //
  3614  // This structure may be used only with operations rendered under `/eam`.
  3615  type UpdateRequestType struct {
  3616  	This types.ManagedObjectReference `xml:"_this" json:"_this"`
  3617  	// The new configuration for this <code>Agency</code>
  3618  	Config BaseAgencyConfigInfo `xml:"config,typeattr" json:"config"`
  3619  }
  3620  
  3621  func init() {
  3622  	types.Add("eam:UpdateRequestType", reflect.TypeOf((*UpdateRequestType)(nil)).Elem())
  3623  }
  3624  
  3625  type UpdateResponse struct {
  3626  }
  3627  
  3628  // A VIB module requires the host to be in maintenance mode, but the vSphere ESX Agent Manager
  3629  // is unable toput the host in maintenance mode.
  3630  //
  3631  // This can happen if there are virtual machines running on the host that cannot
  3632  // be moved and must be stopped before the host can enter maintenance mode.
  3633  //
  3634  // This is an active remediable issue. To remediate, the vSphere ESX Agent Manager will try again
  3635  // to put the host into maintenance mode. However, the vSphere ESX Agent Manager will not power
  3636  // off or move any virtual machines to put the host into maintenance mode. This must be
  3637  // done by the client.
  3638  //
  3639  // This structure may be used only with operations rendered under `/eam`.
  3640  type VibCannotPutHostInMaintenanceMode struct {
  3641  	VibIssue
  3642  }
  3643  
  3644  func init() {
  3645  	types.Add("eam:VibCannotPutHostInMaintenanceMode", reflect.TypeOf((*VibCannotPutHostInMaintenanceMode)(nil)).Elem())
  3646  }
  3647  
  3648  // ESXi host is in Maintenance Mode.
  3649  //
  3650  // This prevents powering on and
  3651  // re-configuring Agent Virtual Machines. Also if the host's entering in
  3652  // Maintenance Mode was initiated by vSphere Esx Agent Manager, the same is
  3653  // responsible to initiate exit Maintenance Mode.
  3654  //
  3655  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager
  3656  // puts the host out of Maintenance Mode.
  3657  //
  3658  // This structure may be used only with operations rendered under `/eam`.
  3659  type VibCannotPutHostOutOfMaintenanceMode struct {
  3660  	VibIssue
  3661  }
  3662  
  3663  func init() {
  3664  	types.Add("eam:VibCannotPutHostOutOfMaintenanceMode", reflect.TypeOf((*VibCannotPutHostOutOfMaintenanceMode)(nil)).Elem())
  3665  }
  3666  
  3667  // A VIB module is expected to be installed on a host, but the dependencies,
  3668  // describred within the module, were not satisfied by the host.
  3669  //
  3670  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager
  3671  // attempts the VIB installation again.
  3672  //
  3673  // This structure may be used only with operations rendered under `/eam`.
  3674  type VibDependenciesNotMetByHost struct {
  3675  	VibNotInstalled
  3676  }
  3677  
  3678  func init() {
  3679  	types.Add("eam:VibDependenciesNotMetByHost", reflect.TypeOf((*VibDependenciesNotMetByHost)(nil)).Elem())
  3680  }
  3681  
  3682  // A VIB module is expected to be installed on a host, but it failed to install
  3683  // since the VIB package is in an invalid format.
  3684  //
  3685  // The installation is unlikely to
  3686  // succeed until the solution provding the bundle has been upgraded or patched to
  3687  // provide a valid VIB package.
  3688  //
  3689  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager attempts the VIB installation again.
  3690  //
  3691  // This structure may be used only with operations rendered under `/eam`.
  3692  type VibInvalidFormat struct {
  3693  	VibNotInstalled
  3694  }
  3695  
  3696  func init() {
  3697  	types.Add("eam:VibInvalidFormat", reflect.TypeOf((*VibInvalidFormat)(nil)).Elem())
  3698  }
  3699  
  3700  // Base class for all issues related to the VIB modules that belong to an agent.
  3701  //
  3702  // This structure may be used only with operations rendered under `/eam`.
  3703  type VibIssue struct {
  3704  	AgentIssue
  3705  }
  3706  
  3707  func init() {
  3708  	types.Add("eam:VibIssue", reflect.TypeOf((*VibIssue)(nil)).Elem())
  3709  }
  3710  
  3711  // A VIB module is expected to be installed/removed on a host, but it has not
  3712  // been installed/removed.
  3713  //
  3714  // Typically, a more specific issue (a subclass of this
  3715  // issue) indicates the particular reason why the VIB module operation failed.
  3716  //
  3717  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager
  3718  // attempts the VIB operation again.
  3719  // In case of unreachable host vSphere ESX Agent Manager will remediate the
  3720  // issue automatically when the host becomes reachable.
  3721  //
  3722  // This structure may be used only with operations rendered under `/eam`.
  3723  type VibNotInstalled struct {
  3724  	VibIssue
  3725  }
  3726  
  3727  func init() {
  3728  	types.Add("eam:VibNotInstalled", reflect.TypeOf((*VibNotInstalled)(nil)).Elem())
  3729  }
  3730  
  3731  // A VIB module is expected to be installed on a host, but the system
  3732  // requirements, describred within the module, were not satisfied by the host.
  3733  //
  3734  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager
  3735  // attempts the VIB installation again.
  3736  //
  3737  // This structure may be used only with operations rendered under `/eam`.
  3738  type VibRequirementsNotMetByHost struct {
  3739  	VibNotInstalled
  3740  }
  3741  
  3742  func init() {
  3743  	types.Add("eam:VibRequirementsNotMetByHost", reflect.TypeOf((*VibRequirementsNotMetByHost)(nil)).Elem())
  3744  }
  3745  
  3746  // A VIB module has been uploaded to the host, but will not be fully installed
  3747  // until the host has been put in maintenance mode.
  3748  //
  3749  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager puts the host into maintenance
  3750  // mode.
  3751  //
  3752  // This structure may be used only with operations rendered under `/eam`.
  3753  type VibRequiresHostInMaintenanceMode struct {
  3754  	VibIssue
  3755  }
  3756  
  3757  func init() {
  3758  	types.Add("eam:VibRequiresHostInMaintenanceMode", reflect.TypeOf((*VibRequiresHostInMaintenanceMode)(nil)).Elem())
  3759  }
  3760  
  3761  // A VIB module has been uploaded to the host, but will not be activated
  3762  // until the host is rebooted.
  3763  //
  3764  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager puts the host into maintenance
  3765  // mode and reboots it.
  3766  //
  3767  // This structure may be used only with operations rendered under `/eam`.
  3768  type VibRequiresHostReboot struct {
  3769  	VibIssue
  3770  }
  3771  
  3772  func init() {
  3773  	types.Add("eam:VibRequiresHostReboot", reflect.TypeOf((*VibRequiresHostReboot)(nil)).Elem())
  3774  }
  3775  
  3776  // A VIB module failed to install, but failed to do so because automatic installation
  3777  // by vSphere ESX Agent Manager is not allowed on the host.
  3778  //
  3779  // This is a passive remediable issue. To remediate, go to VMware Update Manager
  3780  // and install the required bulletins on the host or add the bulletins to the
  3781  // host's image profile.
  3782  //
  3783  // This structure may be used only with operations rendered under `/eam`.
  3784  type VibRequiresManualInstallation struct {
  3785  	VibIssue
  3786  
  3787  	// A non-empty array of bulletins required to be installed on the host.
  3788  	Bulletin []string `xml:"bulletin" json:"bulletin"`
  3789  }
  3790  
  3791  func init() {
  3792  	types.Add("eam:VibRequiresManualInstallation", reflect.TypeOf((*VibRequiresManualInstallation)(nil)).Elem())
  3793  }
  3794  
  3795  // A VIB module failed to uninstall, but failed to do so because automatic uninstallation
  3796  // by vSphere ESX Agent Manager is not allowed on the host.
  3797  //
  3798  // This is a passive remediable issue. To remediate, go to VMware Update Manager
  3799  // and uninstall the required bulletins on the host or remove the bulletins from the
  3800  // host's image profile.
  3801  //
  3802  // This structure may be used only with operations rendered under `/eam`.
  3803  type VibRequiresManualUninstallation struct {
  3804  	VibIssue
  3805  
  3806  	// A non-empty array of bulletins required to be uninstalled on the host.
  3807  	Bulletin []string `xml:"bulletin" json:"bulletin"`
  3808  }
  3809  
  3810  func init() {
  3811  	types.Add("eam:VibRequiresManualUninstallation", reflect.TypeOf((*VibRequiresManualUninstallation)(nil)).Elem())
  3812  }
  3813  
  3814  // A data entity providing information about a VIB.
  3815  //
  3816  // This abstraction contains only those of the VIB attributes which convey
  3817  // important information for the client to identify, preview and select VIBs.
  3818  //
  3819  // This structure may be used only with operations rendered under `/eam`.
  3820  type VibVibInfo struct {
  3821  	types.DynamicData
  3822  
  3823  	Id           string                  `xml:"id" json:"id"`
  3824  	Name         string                  `xml:"name" json:"name"`
  3825  	Version      string                  `xml:"version" json:"version"`
  3826  	Vendor       string                  `xml:"vendor" json:"vendor"`
  3827  	Summary      string                  `xml:"summary" json:"summary"`
  3828  	SoftwareTags *VibVibInfoSoftwareTags `xml:"softwareTags,omitempty" json:"softwareTags,omitempty"`
  3829  	ReleaseDate  time.Time               `xml:"releaseDate" json:"releaseDate"`
  3830  }
  3831  
  3832  func init() {
  3833  	types.Add("eam:VibVibInfo", reflect.TypeOf((*VibVibInfo)(nil)).Elem())
  3834  }
  3835  
  3836  // A data entity providing information about software tags of a VIB
  3837  //
  3838  // This structure may be used only with operations rendered under `/eam`.
  3839  type VibVibInfoSoftwareTags struct {
  3840  	types.DynamicData
  3841  
  3842  	Tags []string `xml:"tags,omitempty" json:"tags,omitempty"`
  3843  }
  3844  
  3845  func init() {
  3846  	types.Add("eam:VibVibInfoSoftwareTags", reflect.TypeOf((*VibVibInfoSoftwareTags)(nil)).Elem())
  3847  }
  3848  
  3849  // Specifies an SSL policy that trusts any SSL certificate.
  3850  //
  3851  // This structure may be used only with operations rendered under `/eam`.
  3852  type VibVibServicesAnyCertificate struct {
  3853  	VibVibServicesSslTrust
  3854  }
  3855  
  3856  func init() {
  3857  	types.Add("eam:VibVibServicesAnyCertificate", reflect.TypeOf((*VibVibServicesAnyCertificate)(nil)).Elem())
  3858  	types.AddMinAPIVersionForType("eam:VibVibServicesAnyCertificate", "8.2")
  3859  }
  3860  
  3861  // Specifies an SSL policy that trusts one specific pinned PEM encoded SSL
  3862  // certificate.
  3863  //
  3864  // This structure may be used only with operations rendered under `/eam`.
  3865  type VibVibServicesPinnedPemCertificate struct {
  3866  	VibVibServicesSslTrust
  3867  
  3868  	// PEM encoded pinned SSL certificate of the server that needs to be
  3869  	// trusted.
  3870  	SslCertificate string `xml:"sslCertificate" json:"sslCertificate"`
  3871  }
  3872  
  3873  func init() {
  3874  	types.Add("eam:VibVibServicesPinnedPemCertificate", reflect.TypeOf((*VibVibServicesPinnedPemCertificate)(nil)).Elem())
  3875  	types.AddMinAPIVersionForType("eam:VibVibServicesPinnedPemCertificate", "8.2")
  3876  }
  3877  
  3878  // This structure may be used only with operations rendered under `/eam`.
  3879  type VibVibServicesSslTrust struct {
  3880  	types.DynamicData
  3881  }
  3882  
  3883  func init() {
  3884  	types.Add("eam:VibVibServicesSslTrust", reflect.TypeOf((*VibVibServicesSslTrust)(nil)).Elem())
  3885  	types.AddMinAPIVersionForType("eam:VibVibServicesSslTrust", "8.2")
  3886  }
  3887  
  3888  // An agent virtual machine is corrupted.
  3889  //
  3890  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager deletes and
  3891  // reprovisions the agent virtual machine. To remediate manually, fix the missing file issue and power on the
  3892  // agent virtual machine.
  3893  //
  3894  // This structure may be used only with operations rendered under `/eam`.
  3895  type VmCorrupted struct {
  3896  	VmIssue
  3897  
  3898  	// An optional path for a missing file.
  3899  	MissingFile string `xml:"missingFile,omitempty" json:"missingFile,omitempty"`
  3900  }
  3901  
  3902  func init() {
  3903  	types.Add("eam:VmCorrupted", reflect.TypeOf((*VmCorrupted)(nil)).Elem())
  3904  }
  3905  
  3906  // An agent virtual machine is expected to be removed from a host, but the agent virtual machine has not
  3907  // been removed.
  3908  //
  3909  // Typically, a more specific issue (a subclass of this issue)
  3910  // indicates the particular reason why vSphere ESX Agent Manager was unable to remove the
  3911  // agent virtual machine, such as the host is in maintenance mode, powered off or in standby
  3912  // mode.
  3913  //
  3914  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager redeploys the agent.
  3915  //
  3916  // This structure may be used only with operations rendered under `/eam`.
  3917  type VmDeployed struct {
  3918  	VmIssue
  3919  }
  3920  
  3921  func init() {
  3922  	types.Add("eam:VmDeployed", reflect.TypeOf((*VmDeployed)(nil)).Elem())
  3923  }
  3924  
  3925  type VmHookFailed struct {
  3926  	VmIssue
  3927  }
  3928  
  3929  func init() {
  3930  	types.Add("eam:VmHookFailed", reflect.TypeOf((*VmHookFailed)(nil)).Elem())
  3931  }
  3932  
  3933  type VmHookTimedout struct {
  3934  	VmIssue
  3935  }
  3936  
  3937  func init() {
  3938  	types.Add("eam:VmHookTimedout", reflect.TypeOf((*VmHookTimedout)(nil)).Elem())
  3939  }
  3940  
  3941  type VmInaccessible struct {
  3942  	VmIssue
  3943  }
  3944  
  3945  func init() {
  3946  	types.Add("eam:VmInaccessible", reflect.TypeOf((*VmInaccessible)(nil)).Elem())
  3947  }
  3948  
  3949  // Base class for all issues related to the deployed virtual machine for a
  3950  // particular agent.
  3951  //
  3952  // This structure may be used only with operations rendered under `/eam`.
  3953  type VmIssue struct {
  3954  	AgentIssue
  3955  
  3956  	// The virtual machine to which this issue is related.
  3957  	//
  3958  	// Refers instance of `VirtualMachine`.
  3959  	Vm types.ManagedObjectReference `xml:"vm" json:"vm"`
  3960  }
  3961  
  3962  func init() {
  3963  	types.Add("eam:VmIssue", reflect.TypeOf((*VmIssue)(nil)).Elem())
  3964  }
  3965  
  3966  // Deprecated template agent VMs are not used anymore by VM deployment and
  3967  // monitoring.
  3968  //
  3969  // An agent virtual machine is a virtual machine template.
  3970  //
  3971  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager
  3972  // converts the agent virtual machine template to a virtual machine.
  3973  //
  3974  // This structure may be used only with operations rendered under `/eam`.
  3975  type VmMarkedAsTemplate struct {
  3976  	VmIssue
  3977  }
  3978  
  3979  func init() {
  3980  	types.Add("eam:VmMarkedAsTemplate", reflect.TypeOf((*VmMarkedAsTemplate)(nil)).Elem())
  3981  }
  3982  
  3983  // An agent virtual machine is expected to be deployed on a host, but the agent virtual machine has not
  3984  // been deployed.
  3985  //
  3986  // Typically, a more specific issue (a subclass of this issue)
  3987  // indicates the particular reason why vSphere ESX Agent Manager was unable to deploy the
  3988  // agent, such as being unable to access the OVF package for the agent or a missing host
  3989  // configuration. This issue can also happen if the agent virtual machine is explicitly deleted
  3990  // from the host.
  3991  //
  3992  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager redeploys the agent virtual machine.
  3993  //
  3994  // This structure may be used only with operations rendered under `/eam`.
  3995  type VmNotDeployed struct {
  3996  	AgentIssue
  3997  }
  3998  
  3999  func init() {
  4000  	types.Add("eam:VmNotDeployed", reflect.TypeOf((*VmNotDeployed)(nil)).Elem())
  4001  }
  4002  
  4003  // An agent virtual machine exists on a host, but the host is no longer part of scope for the
  4004  // agency.
  4005  //
  4006  // This typically happens if a host is disconnected when the agency
  4007  // configuration is changed.
  4008  //
  4009  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager deletes the agent virtual machine.
  4010  //
  4011  // This structure may be used only with operations rendered under `/eam`.
  4012  type VmOrphaned struct {
  4013  	VmIssue
  4014  }
  4015  
  4016  func init() {
  4017  	types.Add("eam:VmOrphaned", reflect.TypeOf((*VmOrphaned)(nil)).Elem())
  4018  }
  4019  
  4020  // An agent virtual machine is expected to be powered on, but the agent virtual machine is powered off.
  4021  //
  4022  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager
  4023  // powers on the agent virtual machine.
  4024  //
  4025  // This structure may be used only with operations rendered under `/eam`.
  4026  type VmPoweredOff struct {
  4027  	VmIssue
  4028  }
  4029  
  4030  func init() {
  4031  	types.Add("eam:VmPoweredOff", reflect.TypeOf((*VmPoweredOff)(nil)).Elem())
  4032  }
  4033  
  4034  // An agent virtual machine is expected to be powered off, but the agent virtual machine is powered on.
  4035  //
  4036  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager
  4037  // powers off the agent virtual machine.
  4038  //
  4039  // This structure may be used only with operations rendered under `/eam`.
  4040  type VmPoweredOn struct {
  4041  	VmIssue
  4042  }
  4043  
  4044  func init() {
  4045  	types.Add("eam:VmPoweredOn", reflect.TypeOf((*VmPoweredOn)(nil)).Elem())
  4046  }
  4047  
  4048  type VmProtected struct {
  4049  	VmIssue
  4050  }
  4051  
  4052  func init() {
  4053  	types.Add("eam:VmProtected", reflect.TypeOf((*VmProtected)(nil)).Elem())
  4054  }
  4055  
  4056  // An agent virtual machine is expected to be deployed on a host, but the agent
  4057  // virtual machine cannot be deployed because the host is in Maintenance Mode.
  4058  //
  4059  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager
  4060  // takes the host out of Maintenance Mode and deploys the agent virtual machine.
  4061  //
  4062  // Resolving this issue in vSphere Lifecyle Manager environemnt will be no-op.
  4063  // In those cases user must take the host out of Maintenance Mode manually or
  4064  // wait vSphere Lifecycle Maanger cluster remediation to complete (if any).
  4065  //
  4066  // This structure may be used only with operations rendered under `/eam`.
  4067  type VmRequiresHostOutOfMaintenanceMode struct {
  4068  	VmNotDeployed
  4069  }
  4070  
  4071  func init() {
  4072  	types.Add("eam:VmRequiresHostOutOfMaintenanceMode", reflect.TypeOf((*VmRequiresHostOutOfMaintenanceMode)(nil)).Elem())
  4073  	types.AddMinAPIVersionForType("eam:VmRequiresHostOutOfMaintenanceMode", "7.2")
  4074  }
  4075  
  4076  // An agent virtual machine is expected to be powered on, but the agent virtual machine is suspended.
  4077  //
  4078  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager powers on the agent virtual machine.
  4079  //
  4080  // This structure may be used only with operations rendered under `/eam`.
  4081  type VmSuspended struct {
  4082  	VmIssue
  4083  }
  4084  
  4085  func init() {
  4086  	types.Add("eam:VmSuspended", reflect.TypeOf((*VmSuspended)(nil)).Elem())
  4087  }
  4088  
  4089  // Deprecated eAM does not try to override any action powerfull user has taken.
  4090  //
  4091  // An agent virtual machine is expected to be located in a designated agent
  4092  // virtual machine folder, but is found in a different folder.
  4093  //
  4094  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager
  4095  // moves the agent virtual machine back into the designated agent folder.
  4096  //
  4097  // This structure may be used only with operations rendered under `/eam`.
  4098  type VmWrongFolder struct {
  4099  	VmIssue
  4100  
  4101  	// The folder in which the virtual machine currently resides.
  4102  	//
  4103  	// Refers instance of `Folder`.
  4104  	CurrentFolder types.ManagedObjectReference `xml:"currentFolder" json:"currentFolder"`
  4105  	// The ESX agent folder in which the virtual machine should reside.
  4106  	//
  4107  	// Refers instance of `Folder`.
  4108  	RequiredFolder types.ManagedObjectReference `xml:"requiredFolder" json:"requiredFolder"`
  4109  }
  4110  
  4111  func init() {
  4112  	types.Add("eam:VmWrongFolder", reflect.TypeOf((*VmWrongFolder)(nil)).Elem())
  4113  }
  4114  
  4115  // Deprecated eAM does not try to override any action powerfull user has taken.
  4116  //
  4117  // An agent virtual machine is expected to be located in a designated agent
  4118  // virtual machine resource pool, but is found in a different resource pool.
  4119  //
  4120  // This is an active remediable issue. To remediate, vSphere ESX Agent Manager
  4121  // moves the agent virtual machine back into the designated agent resource pool.
  4122  //
  4123  // This structure may be used only with operations rendered under `/eam`.
  4124  type VmWrongResourcePool struct {
  4125  	VmIssue
  4126  
  4127  	// The resource pool in which the VM currently resides.
  4128  	//
  4129  	// Refers instance of `ResourcePool`.
  4130  	CurrentResourcePool types.ManagedObjectReference `xml:"currentResourcePool" json:"currentResourcePool"`
  4131  	// The ESX agent resource pool in which the VM should reside.
  4132  	//
  4133  	// Refers instance of `ResourcePool`.
  4134  	RequiredResourcePool types.ManagedObjectReference `xml:"requiredResourcePool" json:"requiredResourcePool"`
  4135  }
  4136  
  4137  func init() {
  4138  	types.Add("eam:VmWrongResourcePool", reflect.TypeOf((*VmWrongResourcePool)(nil)).Elem())
  4139  }
  4140  
  4141  type VersionURI string
  4142  
  4143  func init() {
  4144  	types.Add("eam:versionURI", reflect.TypeOf((*VersionURI)(nil)).Elem())
  4145  }