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

     1  /*
     2  Copyright (c) 2014-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  
    22  	"github.com/vmware/govmomi/vim25/types"
    23  )
    24  
    25  type PbmAssociateAndApplyPolicyStatusPolicyStatus string
    26  
    27  const (
    28  	// Policy applied successfully.
    29  	PbmAssociateAndApplyPolicyStatusPolicyStatusSuccess = PbmAssociateAndApplyPolicyStatusPolicyStatus("success")
    30  	// Policy cannot be applied
    31  	PbmAssociateAndApplyPolicyStatusPolicyStatusFailed = PbmAssociateAndApplyPolicyStatusPolicyStatus("failed")
    32  	// Policy cannot be applied
    33  	PbmAssociateAndApplyPolicyStatusPolicyStatusInvalid = PbmAssociateAndApplyPolicyStatusPolicyStatus("invalid")
    34  )
    35  
    36  func (e PbmAssociateAndApplyPolicyStatusPolicyStatus) Values() []PbmAssociateAndApplyPolicyStatusPolicyStatus {
    37  	return []PbmAssociateAndApplyPolicyStatusPolicyStatus{
    38  		PbmAssociateAndApplyPolicyStatusPolicyStatusSuccess,
    39  		PbmAssociateAndApplyPolicyStatusPolicyStatusFailed,
    40  		PbmAssociateAndApplyPolicyStatusPolicyStatusInvalid,
    41  	}
    42  }
    43  
    44  func (e PbmAssociateAndApplyPolicyStatusPolicyStatus) Strings() []string {
    45  	return types.EnumValuesAsStrings(e.Values())
    46  }
    47  
    48  func init() {
    49  	types.Add("pbm:PbmAssociateAndApplyPolicyStatusPolicyStatus", reflect.TypeOf((*PbmAssociateAndApplyPolicyStatusPolicyStatus)(nil)).Elem())
    50  }
    51  
    52  // The `PbmBuiltinGenericType_enum` enumerated type defines the list
    53  // of builtin generic datatypes.
    54  //
    55  // See
    56  // `PbmCapabilityGenericTypeInfo*.*PbmCapabilityGenericTypeInfo.genericTypeName`.
    57  //
    58  // A generic datatype indicates how to interpret a collection of values
    59  // of a specific datatype (`PbmCapabilityTypeInfo.typeName`).
    60  type PbmBuiltinGenericType string
    61  
    62  const (
    63  	// Indicates a full or partial range of values (`PbmCapabilityRange`).
    64  	//
    65  	// A full range specifies both <code>min</code> and <code>max</code> values.
    66  	// A partial range specifies one or the other, <code>min</code> or <code>max</code>.
    67  	PbmBuiltinGenericTypeVMW_RANGE = PbmBuiltinGenericType("VMW_RANGE")
    68  	// Indicates a single value or a discrete set of values
    69  	// (`PbmCapabilityDiscreteSet`).
    70  	PbmBuiltinGenericTypeVMW_SET = PbmBuiltinGenericType("VMW_SET")
    71  )
    72  
    73  func (e PbmBuiltinGenericType) Values() []PbmBuiltinGenericType {
    74  	return []PbmBuiltinGenericType{
    75  		PbmBuiltinGenericTypeVMW_RANGE,
    76  		PbmBuiltinGenericTypeVMW_SET,
    77  	}
    78  }
    79  
    80  func (e PbmBuiltinGenericType) Strings() []string {
    81  	return types.EnumValuesAsStrings(e.Values())
    82  }
    83  
    84  func init() {
    85  	types.Add("pbm:PbmBuiltinGenericType", reflect.TypeOf((*PbmBuiltinGenericType)(nil)).Elem())
    86  }
    87  
    88  // The `PbmBuiltinType_enum` enumerated type defines datatypes
    89  // for storage profiles.
    90  //
    91  // Property metadata
    92  // (`PbmCapabilityPropertyMetadata`) uses the builtin types
    93  // to define data types for storage capabilities and requirements.
    94  // It may also specify the semantics that are applied to a collection
    95  // of builtin type values. See `PbmCapabilityTypeInfo`.
    96  // These semantics are specified as a generic builtin type.
    97  // See `PbmCapabilityGenericTypeInfo`.
    98  // The type information determines how capability constraints are interpreted
    99  // `PbmCapabilityPropertyInstance.value`).
   100  type PbmBuiltinType string
   101  
   102  const (
   103  	// Unsigned long value.
   104  	//
   105  	// This datatype supports the following constraint values.
   106  	//   - Single value
   107  	//   - Full or partial range of values (`PbmCapabilityRange`)
   108  	//   - Discrete set of values (`PbmCapabilityDiscreteSet`)
   109  	PbmBuiltinTypeXSD_LONG = PbmBuiltinType("XSD_LONG")
   110  	// Datatype not supported.
   111  	PbmBuiltinTypeXSD_SHORT = PbmBuiltinType("XSD_SHORT")
   112  	// Datatype not supported.
   113  	//
   114  	// Use XSD\_INT instead.
   115  	PbmBuiltinTypeXSD_INTEGER = PbmBuiltinType("XSD_INTEGER")
   116  	// Integer value.
   117  	//
   118  	// This datatype supports the following constraint values.
   119  	//   - Single value
   120  	//   - Full or partial range of values (`PbmCapabilityRange`)
   121  	//   - Discrete set of values (`PbmCapabilityDiscreteSet`)
   122  	PbmBuiltinTypeXSD_INT = PbmBuiltinType("XSD_INT")
   123  	// String value.
   124  	//
   125  	// This datatype supports a single value
   126  	// or a discrete set of values (`PbmCapabilityDiscreteSet`).
   127  	PbmBuiltinTypeXSD_STRING = PbmBuiltinType("XSD_STRING")
   128  	// Boolean value.
   129  	PbmBuiltinTypeXSD_BOOLEAN = PbmBuiltinType("XSD_BOOLEAN")
   130  	// Double precision floating point value.
   131  	//
   132  	// This datatype supports the following
   133  	// constraint values.
   134  	//   - Single value
   135  	//   - Full or partial range of values (`PbmCapabilityRange`)
   136  	//   - Discrete set of values (`PbmCapabilityDiscreteSet`)
   137  	PbmBuiltinTypeXSD_DOUBLE = PbmBuiltinType("XSD_DOUBLE")
   138  	// Date and time value.
   139  	PbmBuiltinTypeXSD_DATETIME = PbmBuiltinType("XSD_DATETIME")
   140  	// Timespan value (`PbmCapabilityTimeSpan`).
   141  	//
   142  	// This datatype supports
   143  	// the following constraint values.
   144  	//   - Single value
   145  	//   - Full or partial range of values (`PbmCapabilityRange`)
   146  	//   - Discrete set of values (`PbmCapabilityDiscreteSet`)
   147  	PbmBuiltinTypeVMW_TIMESPAN = PbmBuiltinType("VMW_TIMESPAN")
   148  	PbmBuiltinTypeVMW_POLICY   = PbmBuiltinType("VMW_POLICY")
   149  )
   150  
   151  func (e PbmBuiltinType) Values() []PbmBuiltinType {
   152  	return []PbmBuiltinType{
   153  		PbmBuiltinTypeXSD_LONG,
   154  		PbmBuiltinTypeXSD_SHORT,
   155  		PbmBuiltinTypeXSD_INTEGER,
   156  		PbmBuiltinTypeXSD_INT,
   157  		PbmBuiltinTypeXSD_STRING,
   158  		PbmBuiltinTypeXSD_BOOLEAN,
   159  		PbmBuiltinTypeXSD_DOUBLE,
   160  		PbmBuiltinTypeXSD_DATETIME,
   161  		PbmBuiltinTypeVMW_TIMESPAN,
   162  		PbmBuiltinTypeVMW_POLICY,
   163  	}
   164  }
   165  
   166  func (e PbmBuiltinType) Strings() []string {
   167  	return types.EnumValuesAsStrings(e.Values())
   168  }
   169  
   170  func init() {
   171  	types.Add("pbm:PbmBuiltinType", reflect.TypeOf((*PbmBuiltinType)(nil)).Elem())
   172  }
   173  
   174  // List of operators that are supported for constructing policy.
   175  //
   176  // Currently only tag based properties can use this operator.
   177  // Other operators can be added as required.
   178  type PbmCapabilityOperator string
   179  
   180  const (
   181  	PbmCapabilityOperatorNOT = PbmCapabilityOperator("NOT")
   182  )
   183  
   184  func (e PbmCapabilityOperator) Values() []PbmCapabilityOperator {
   185  	return []PbmCapabilityOperator{
   186  		PbmCapabilityOperatorNOT,
   187  	}
   188  }
   189  
   190  func (e PbmCapabilityOperator) Strings() []string {
   191  	return types.EnumValuesAsStrings(e.Values())
   192  }
   193  
   194  func init() {
   195  	types.Add("pbm:PbmCapabilityOperator", reflect.TypeOf((*PbmCapabilityOperator)(nil)).Elem())
   196  }
   197  
   198  // The `PbmCapabilityTimeUnitType_enum` enumeration type
   199  // defines the supported list of time units for profiles that specify
   200  // time span capabilities and constraints.
   201  //
   202  // See `PbmCapabilityTimeSpan`.
   203  type PbmCapabilityTimeUnitType string
   204  
   205  const (
   206  	// Constraints and capabilities expressed in units of seconds.
   207  	PbmCapabilityTimeUnitTypeSECONDS = PbmCapabilityTimeUnitType("SECONDS")
   208  	// Constraints and capabilities expressed in units of minutes.
   209  	PbmCapabilityTimeUnitTypeMINUTES = PbmCapabilityTimeUnitType("MINUTES")
   210  	// Constraints and capabilities expressed in units of hours.
   211  	PbmCapabilityTimeUnitTypeHOURS = PbmCapabilityTimeUnitType("HOURS")
   212  	// Constraints and capabilities expressed in units of days.
   213  	PbmCapabilityTimeUnitTypeDAYS = PbmCapabilityTimeUnitType("DAYS")
   214  	// Constraints and capabilities expressed in units of weeks.
   215  	PbmCapabilityTimeUnitTypeWEEKS = PbmCapabilityTimeUnitType("WEEKS")
   216  	// Constraints and capabilities expressed in units of months.
   217  	PbmCapabilityTimeUnitTypeMONTHS = PbmCapabilityTimeUnitType("MONTHS")
   218  	// Constraints and capabilities expressed in units of years.
   219  	PbmCapabilityTimeUnitTypeYEARS = PbmCapabilityTimeUnitType("YEARS")
   220  )
   221  
   222  func (e PbmCapabilityTimeUnitType) Values() []PbmCapabilityTimeUnitType {
   223  	return []PbmCapabilityTimeUnitType{
   224  		PbmCapabilityTimeUnitTypeSECONDS,
   225  		PbmCapabilityTimeUnitTypeMINUTES,
   226  		PbmCapabilityTimeUnitTypeHOURS,
   227  		PbmCapabilityTimeUnitTypeDAYS,
   228  		PbmCapabilityTimeUnitTypeWEEKS,
   229  		PbmCapabilityTimeUnitTypeMONTHS,
   230  		PbmCapabilityTimeUnitTypeYEARS,
   231  	}
   232  }
   233  
   234  func (e PbmCapabilityTimeUnitType) Strings() []string {
   235  	return types.EnumValuesAsStrings(e.Values())
   236  }
   237  
   238  func init() {
   239  	types.Add("pbm:PbmCapabilityTimeUnitType", reflect.TypeOf((*PbmCapabilityTimeUnitType)(nil)).Elem())
   240  }
   241  
   242  // The `PbmComplianceResultComplianceTaskStatus_enum`
   243  // enumeration type defines the set of task status for compliance
   244  // operations.
   245  //
   246  // See `PbmComplianceResult` and
   247  // `PbmRollupComplianceResult`.
   248  type PbmComplianceResultComplianceTaskStatus string
   249  
   250  const (
   251  	// Compliance calculation is in progress.
   252  	PbmComplianceResultComplianceTaskStatusInProgress = PbmComplianceResultComplianceTaskStatus("inProgress")
   253  	// Compliance calculation has succeeded.
   254  	PbmComplianceResultComplianceTaskStatusSuccess = PbmComplianceResultComplianceTaskStatus("success")
   255  	// Compliance calculation failed due to some exception.
   256  	PbmComplianceResultComplianceTaskStatusFailed = PbmComplianceResultComplianceTaskStatus("failed")
   257  )
   258  
   259  func (e PbmComplianceResultComplianceTaskStatus) Values() []PbmComplianceResultComplianceTaskStatus {
   260  	return []PbmComplianceResultComplianceTaskStatus{
   261  		PbmComplianceResultComplianceTaskStatusInProgress,
   262  		PbmComplianceResultComplianceTaskStatusSuccess,
   263  		PbmComplianceResultComplianceTaskStatusFailed,
   264  	}
   265  }
   266  
   267  func (e PbmComplianceResultComplianceTaskStatus) Strings() []string {
   268  	return types.EnumValuesAsStrings(e.Values())
   269  }
   270  
   271  func init() {
   272  	types.Add("pbm:PbmComplianceResultComplianceTaskStatus", reflect.TypeOf((*PbmComplianceResultComplianceTaskStatus)(nil)).Elem())
   273  }
   274  
   275  // The `PbmComplianceStatus_enum`
   276  // enumeration type defines the set of status values
   277  // for compliance operations.
   278  //
   279  // See `PbmComplianceResult` and
   280  // `PbmRollupComplianceResult`.
   281  type PbmComplianceStatus string
   282  
   283  const (
   284  	// Entity is in compliance.
   285  	PbmComplianceStatusCompliant = PbmComplianceStatus("compliant")
   286  	// Entity is out of compliance.
   287  	PbmComplianceStatusNonCompliant = PbmComplianceStatus("nonCompliant")
   288  	// Compliance status of the entity is not known.
   289  	PbmComplianceStatusUnknown = PbmComplianceStatus("unknown")
   290  	// Compliance computation is not applicable for this entity,
   291  	// because it does not have any storage requirements that
   292  	// apply to the object-based datastore on which this entity is placed.
   293  	PbmComplianceStatusNotApplicable = PbmComplianceStatus("notApplicable")
   294  	// This is the same as `PbmComplianceResult.mismatch`
   295  	// variable.
   296  	//
   297  	// Compliance status becomes out-of-date when the profile
   298  	// associated with the entity is edited and not applied. The compliance
   299  	// status will remain in out-of-date compliance status until the latest
   300  	// policy is applied to the entity.
   301  	PbmComplianceStatusOutOfDate = PbmComplianceStatus("outOfDate")
   302  )
   303  
   304  func (e PbmComplianceStatus) Values() []PbmComplianceStatus {
   305  	return []PbmComplianceStatus{
   306  		PbmComplianceStatusCompliant,
   307  		PbmComplianceStatusNonCompliant,
   308  		PbmComplianceStatusUnknown,
   309  		PbmComplianceStatusNotApplicable,
   310  		PbmComplianceStatusOutOfDate,
   311  	}
   312  }
   313  
   314  func (e PbmComplianceStatus) Strings() []string {
   315  	return types.EnumValuesAsStrings(e.Values())
   316  }
   317  
   318  func init() {
   319  	types.Add("pbm:PbmComplianceStatus", reflect.TypeOf((*PbmComplianceStatus)(nil)).Elem())
   320  }
   321  
   322  // This enum corresponds to the keystores used by
   323  // sps.
   324  type PbmDebugManagerKeystoreName string
   325  
   326  const (
   327  	// Refers to SMS keystore
   328  	PbmDebugManagerKeystoreNameSMS = PbmDebugManagerKeystoreName("SMS")
   329  	// Refers to TRUSTED\_ROOTS keystore.
   330  	PbmDebugManagerKeystoreNameTRUSTED_ROOTS = PbmDebugManagerKeystoreName("TRUSTED_ROOTS")
   331  )
   332  
   333  func (e PbmDebugManagerKeystoreName) Values() []PbmDebugManagerKeystoreName {
   334  	return []PbmDebugManagerKeystoreName{
   335  		PbmDebugManagerKeystoreNameSMS,
   336  		PbmDebugManagerKeystoreNameTRUSTED_ROOTS,
   337  	}
   338  }
   339  
   340  func (e PbmDebugManagerKeystoreName) Strings() []string {
   341  	return types.EnumValuesAsStrings(e.Values())
   342  }
   343  
   344  func init() {
   345  	types.Add("pbm:PbmDebugManagerKeystoreName", reflect.TypeOf((*PbmDebugManagerKeystoreName)(nil)).Elem())
   346  }
   347  
   348  // The enumeration type defines the set of health status values for an entity
   349  // that is part of entity health operation.
   350  type PbmHealthStatusForEntity string
   351  
   352  const (
   353  	// For file share: 'red' if the file server for this file share is in error
   354  	// state or any of its backing vSAN objects are degraded.
   355  	//
   356  	// For FCD: 'red' if the datastore on which the FCD resides is not
   357  	// accessible from any of the hosts it is mounted.
   358  	PbmHealthStatusForEntityRed = PbmHealthStatusForEntity("red")
   359  	// For file share: 'yellow' if some backing objects are repairing, i.e.
   360  	//
   361  	// warning state.
   362  	// For FCD: 'yellow' if the datastore on which the entity resides is
   363  	// accessible only from some of the hosts it is mounted but not all.
   364  	PbmHealthStatusForEntityYellow = PbmHealthStatusForEntity("yellow")
   365  	// For file share: 'green' if the file server for this file share is
   366  	// running properly and all its backing vSAN objects are healthy.
   367  	//
   368  	// For FCD: 'green' if the datastore on which the entity resides
   369  	// is accessible from all the hosts it is mounted.
   370  	PbmHealthStatusForEntityGreen = PbmHealthStatusForEntity("green")
   371  	// If the health status of a file share is unknown, not valid for FCD.
   372  	PbmHealthStatusForEntityUnknown = PbmHealthStatusForEntity("unknown")
   373  )
   374  
   375  func (e PbmHealthStatusForEntity) Values() []PbmHealthStatusForEntity {
   376  	return []PbmHealthStatusForEntity{
   377  		PbmHealthStatusForEntityRed,
   378  		PbmHealthStatusForEntityYellow,
   379  		PbmHealthStatusForEntityGreen,
   380  		PbmHealthStatusForEntityUnknown,
   381  	}
   382  }
   383  
   384  func (e PbmHealthStatusForEntity) Strings() []string {
   385  	return types.EnumValuesAsStrings(e.Values())
   386  }
   387  
   388  func init() {
   389  	types.Add("pbm:PbmHealthStatusForEntity", reflect.TypeOf((*PbmHealthStatusForEntity)(nil)).Elem())
   390  }
   391  
   392  // Recognized types of an IO Filter.
   393  //
   394  // String constant used in `IofilterInfo#filterType`.
   395  // These should match(upper case) the IO Filter classes as defined by IO Filter framework.
   396  // See https://opengrok.eng.vmware.com/source/xref/vmcore-main.perforce.1666/bora/scons/apps/esx/iofilterApps.sc#33
   397  type PbmIofilterInfoFilterType string
   398  
   399  const (
   400  	PbmIofilterInfoFilterTypeINSPECTION         = PbmIofilterInfoFilterType("INSPECTION")
   401  	PbmIofilterInfoFilterTypeCOMPRESSION        = PbmIofilterInfoFilterType("COMPRESSION")
   402  	PbmIofilterInfoFilterTypeENCRYPTION         = PbmIofilterInfoFilterType("ENCRYPTION")
   403  	PbmIofilterInfoFilterTypeREPLICATION        = PbmIofilterInfoFilterType("REPLICATION")
   404  	PbmIofilterInfoFilterTypeCACHE              = PbmIofilterInfoFilterType("CACHE")
   405  	PbmIofilterInfoFilterTypeDATAPROVIDER       = PbmIofilterInfoFilterType("DATAPROVIDER")
   406  	PbmIofilterInfoFilterTypeDATASTOREIOCONTROL = PbmIofilterInfoFilterType("DATASTOREIOCONTROL")
   407  )
   408  
   409  func (e PbmIofilterInfoFilterType) Values() []PbmIofilterInfoFilterType {
   410  	return []PbmIofilterInfoFilterType{
   411  		PbmIofilterInfoFilterTypeINSPECTION,
   412  		PbmIofilterInfoFilterTypeCOMPRESSION,
   413  		PbmIofilterInfoFilterTypeENCRYPTION,
   414  		PbmIofilterInfoFilterTypeREPLICATION,
   415  		PbmIofilterInfoFilterTypeCACHE,
   416  		PbmIofilterInfoFilterTypeDATAPROVIDER,
   417  		PbmIofilterInfoFilterTypeDATASTOREIOCONTROL,
   418  	}
   419  }
   420  
   421  func (e PbmIofilterInfoFilterType) Strings() []string {
   422  	return types.EnumValuesAsStrings(e.Values())
   423  }
   424  
   425  func init() {
   426  	types.Add("pbm:PbmIofilterInfoFilterType", reflect.TypeOf((*PbmIofilterInfoFilterType)(nil)).Elem())
   427  }
   428  
   429  // Denotes the line of service of a schema.
   430  type PbmLineOfServiceInfoLineOfServiceEnum string
   431  
   432  const (
   433  	PbmLineOfServiceInfoLineOfServiceEnumINSPECTION           = PbmLineOfServiceInfoLineOfServiceEnum("INSPECTION")
   434  	PbmLineOfServiceInfoLineOfServiceEnumCOMPRESSION          = PbmLineOfServiceInfoLineOfServiceEnum("COMPRESSION")
   435  	PbmLineOfServiceInfoLineOfServiceEnumENCRYPTION           = PbmLineOfServiceInfoLineOfServiceEnum("ENCRYPTION")
   436  	PbmLineOfServiceInfoLineOfServiceEnumREPLICATION          = PbmLineOfServiceInfoLineOfServiceEnum("REPLICATION")
   437  	PbmLineOfServiceInfoLineOfServiceEnumCACHING              = PbmLineOfServiceInfoLineOfServiceEnum("CACHING")
   438  	PbmLineOfServiceInfoLineOfServiceEnumPERSISTENCE          = PbmLineOfServiceInfoLineOfServiceEnum("PERSISTENCE")
   439  	PbmLineOfServiceInfoLineOfServiceEnumDATA_PROVIDER        = PbmLineOfServiceInfoLineOfServiceEnum("DATA_PROVIDER")
   440  	PbmLineOfServiceInfoLineOfServiceEnumDATASTORE_IO_CONTROL = PbmLineOfServiceInfoLineOfServiceEnum("DATASTORE_IO_CONTROL")
   441  	PbmLineOfServiceInfoLineOfServiceEnumDATA_PROTECTION      = PbmLineOfServiceInfoLineOfServiceEnum("DATA_PROTECTION")
   442  	PbmLineOfServiceInfoLineOfServiceEnumSTRETCHED_CLUSTER    = PbmLineOfServiceInfoLineOfServiceEnum("STRETCHED_CLUSTER")
   443  )
   444  
   445  func (e PbmLineOfServiceInfoLineOfServiceEnum) Values() []PbmLineOfServiceInfoLineOfServiceEnum {
   446  	return []PbmLineOfServiceInfoLineOfServiceEnum{
   447  		PbmLineOfServiceInfoLineOfServiceEnumINSPECTION,
   448  		PbmLineOfServiceInfoLineOfServiceEnumCOMPRESSION,
   449  		PbmLineOfServiceInfoLineOfServiceEnumENCRYPTION,
   450  		PbmLineOfServiceInfoLineOfServiceEnumREPLICATION,
   451  		PbmLineOfServiceInfoLineOfServiceEnumCACHING,
   452  		PbmLineOfServiceInfoLineOfServiceEnumPERSISTENCE,
   453  		PbmLineOfServiceInfoLineOfServiceEnumDATA_PROVIDER,
   454  		PbmLineOfServiceInfoLineOfServiceEnumDATASTORE_IO_CONTROL,
   455  		PbmLineOfServiceInfoLineOfServiceEnumDATA_PROTECTION,
   456  		PbmLineOfServiceInfoLineOfServiceEnumSTRETCHED_CLUSTER,
   457  	}
   458  }
   459  
   460  func (e PbmLineOfServiceInfoLineOfServiceEnum) Strings() []string {
   461  	return types.EnumValuesAsStrings(e.Values())
   462  }
   463  
   464  func init() {
   465  	types.Add("pbm:PbmLineOfServiceInfoLineOfServiceEnum", reflect.TypeOf((*PbmLineOfServiceInfoLineOfServiceEnum)(nil)).Elem())
   466  }
   467  
   468  // This enum corresponds to the different packages whose logging
   469  // is configured independently by sps service.
   470  type PbmLoggingConfigurationComponent string
   471  
   472  const (
   473  	// Modifies logging level of com.vmware.pbm package.
   474  	PbmLoggingConfigurationComponentPbm = PbmLoggingConfigurationComponent("pbm")
   475  	// Modifies logging level of com.vmware.vslm package.
   476  	PbmLoggingConfigurationComponentVslm = PbmLoggingConfigurationComponent("vslm")
   477  	// Modifies logging level of com.vmware.vim.sms package.
   478  	PbmLoggingConfigurationComponentSms = PbmLoggingConfigurationComponent("sms")
   479  	// Modifies logging level of com.vmware.spbm package.
   480  	PbmLoggingConfigurationComponentSpbm = PbmLoggingConfigurationComponent("spbm")
   481  	// Modifies logging level of com.vmware.sps package.
   482  	PbmLoggingConfigurationComponentSps = PbmLoggingConfigurationComponent("sps")
   483  	// Modifies logging level of httpclient wire header.
   484  	PbmLoggingConfigurationComponentHttpclient_header = PbmLoggingConfigurationComponent("httpclient_header")
   485  	// Modifies logging level of httpclient wire content.
   486  	PbmLoggingConfigurationComponentHttpclient_content = PbmLoggingConfigurationComponent("httpclient_content")
   487  	// Modifies logging level of com.vmware.vim.vmomi package.
   488  	PbmLoggingConfigurationComponentVmomi = PbmLoggingConfigurationComponent("vmomi")
   489  )
   490  
   491  func (e PbmLoggingConfigurationComponent) Values() []PbmLoggingConfigurationComponent {
   492  	return []PbmLoggingConfigurationComponent{
   493  		PbmLoggingConfigurationComponentPbm,
   494  		PbmLoggingConfigurationComponentVslm,
   495  		PbmLoggingConfigurationComponentSms,
   496  		PbmLoggingConfigurationComponentSpbm,
   497  		PbmLoggingConfigurationComponentSps,
   498  		PbmLoggingConfigurationComponentHttpclient_header,
   499  		PbmLoggingConfigurationComponentHttpclient_content,
   500  		PbmLoggingConfigurationComponentVmomi,
   501  	}
   502  }
   503  
   504  func (e PbmLoggingConfigurationComponent) Strings() []string {
   505  	return types.EnumValuesAsStrings(e.Values())
   506  }
   507  
   508  func init() {
   509  	types.Add("pbm:PbmLoggingConfigurationComponent", reflect.TypeOf((*PbmLoggingConfigurationComponent)(nil)).Elem())
   510  }
   511  
   512  // This enum corresponds to the different log levels supported
   513  // by sps service.
   514  type PbmLoggingConfigurationLogLevel string
   515  
   516  const (
   517  	// Refers to INFO level logging
   518  	PbmLoggingConfigurationLogLevelINFO = PbmLoggingConfigurationLogLevel("INFO")
   519  	// Refers to DEBUG level logging.
   520  	PbmLoggingConfigurationLogLevelDEBUG = PbmLoggingConfigurationLogLevel("DEBUG")
   521  	// Refers to TRACE level logging.
   522  	PbmLoggingConfigurationLogLevelTRACE = PbmLoggingConfigurationLogLevel("TRACE")
   523  )
   524  
   525  func (e PbmLoggingConfigurationLogLevel) Values() []PbmLoggingConfigurationLogLevel {
   526  	return []PbmLoggingConfigurationLogLevel{
   527  		PbmLoggingConfigurationLogLevelINFO,
   528  		PbmLoggingConfigurationLogLevelDEBUG,
   529  		PbmLoggingConfigurationLogLevelTRACE,
   530  	}
   531  }
   532  
   533  func (e PbmLoggingConfigurationLogLevel) Strings() []string {
   534  	return types.EnumValuesAsStrings(e.Values())
   535  }
   536  
   537  func init() {
   538  	types.Add("pbm:PbmLoggingConfigurationLogLevel", reflect.TypeOf((*PbmLoggingConfigurationLogLevel)(nil)).Elem())
   539  }
   540  
   541  // The `PbmObjectType_enum` enumerated type
   542  // defines vSphere Server object types that are known
   543  // to the Storage Policy Server.
   544  //
   545  // See `PbmServerObjectRef*.*PbmServerObjectRef.objectType`.
   546  type PbmObjectType string
   547  
   548  const (
   549  	// Indicates a virtual machine, not including the disks, identified by the virtual machine
   550  	// identifier _virtual-machine-mor_.
   551  	PbmObjectTypeVirtualMachine = PbmObjectType("virtualMachine")
   552  	// Indicates the virtual machine and all its disks, identified by the virtual machine
   553  	// identifier _virtual-machine-mor_.
   554  	PbmObjectTypeVirtualMachineAndDisks = PbmObjectType("virtualMachineAndDisks")
   555  	// Indicates a virtual disk, identified by disk key
   556  	// (_virtual-machine-mor_:_disk-key_).
   557  	PbmObjectTypeVirtualDiskId = PbmObjectType("virtualDiskId")
   558  	// Indicates a virtual disk, identified by UUID - for First Class Storage Object support.
   559  	PbmObjectTypeVirtualDiskUUID = PbmObjectType("virtualDiskUUID")
   560  	// Indicates a datastore.
   561  	PbmObjectTypeDatastore = PbmObjectType("datastore")
   562  	// Indicates a VSAN object
   563  	PbmObjectTypeVsanObjectId = PbmObjectType("vsanObjectId")
   564  	// Indicates a file service
   565  	PbmObjectTypeFileShareId = PbmObjectType("fileShareId")
   566  	// Unknown object type.
   567  	PbmObjectTypeUnknown = PbmObjectType("unknown")
   568  )
   569  
   570  func (e PbmObjectType) Values() []PbmObjectType {
   571  	return []PbmObjectType{
   572  		PbmObjectTypeVirtualMachine,
   573  		PbmObjectTypeVirtualMachineAndDisks,
   574  		PbmObjectTypeVirtualDiskId,
   575  		PbmObjectTypeVirtualDiskUUID,
   576  		PbmObjectTypeDatastore,
   577  		PbmObjectTypeVsanObjectId,
   578  		PbmObjectTypeFileShareId,
   579  		PbmObjectTypeUnknown,
   580  	}
   581  }
   582  
   583  func (e PbmObjectType) Strings() []string {
   584  	return types.EnumValuesAsStrings(e.Values())
   585  }
   586  
   587  func init() {
   588  	types.Add("pbm:PbmObjectType", reflect.TypeOf((*PbmObjectType)(nil)).Elem())
   589  }
   590  
   591  // The `PbmOperation_enum` enumerated type
   592  // defines the provisioning operation being performed on the entity like FCD, virtual machine.
   593  type PbmOperation string
   594  
   595  const (
   596  	// Indicates create operation of an entity.
   597  	PbmOperationCREATE = PbmOperation("CREATE")
   598  	// Indicates register operation of an entity.
   599  	PbmOperationREGISTER = PbmOperation("REGISTER")
   600  	// Indicates reconfigure operation of an entity.
   601  	PbmOperationRECONFIGURE = PbmOperation("RECONFIGURE")
   602  	// Indicates migrate operation of an entity.
   603  	PbmOperationMIGRATE = PbmOperation("MIGRATE")
   604  	// Indicates clone operation of an entity.
   605  	PbmOperationCLONE = PbmOperation("CLONE")
   606  )
   607  
   608  func (e PbmOperation) Values() []PbmOperation {
   609  	return []PbmOperation{
   610  		PbmOperationCREATE,
   611  		PbmOperationREGISTER,
   612  		PbmOperationRECONFIGURE,
   613  		PbmOperationMIGRATE,
   614  		PbmOperationCLONE,
   615  	}
   616  }
   617  
   618  func (e PbmOperation) Strings() []string {
   619  	return types.EnumValuesAsStrings(e.Values())
   620  }
   621  
   622  func init() {
   623  	types.Add("pbm:PbmOperation", reflect.TypeOf((*PbmOperation)(nil)).Elem())
   624  }
   625  
   626  // Volume allocation type constants.
   627  type PbmPolicyAssociationVolumeAllocationType string
   628  
   629  const (
   630  	// Space required is fully allocated and initialized.
   631  	//
   632  	// It is wiped clean of any previous content on the
   633  	// physical media. Gives faster runtime IO performance.
   634  	PbmPolicyAssociationVolumeAllocationTypeFullyInitialized = PbmPolicyAssociationVolumeAllocationType("FullyInitialized")
   635  	// Space required is fully allocated.
   636  	//
   637  	// It may contain
   638  	// stale data on the physical media.
   639  	PbmPolicyAssociationVolumeAllocationTypeReserveSpace = PbmPolicyAssociationVolumeAllocationType("ReserveSpace")
   640  	// Space required is allocated and zeroed on demand
   641  	// as the space is used.
   642  	PbmPolicyAssociationVolumeAllocationTypeConserveSpaceWhenPossible = PbmPolicyAssociationVolumeAllocationType("ConserveSpaceWhenPossible")
   643  )
   644  
   645  func (e PbmPolicyAssociationVolumeAllocationType) Values() []PbmPolicyAssociationVolumeAllocationType {
   646  	return []PbmPolicyAssociationVolumeAllocationType{
   647  		PbmPolicyAssociationVolumeAllocationTypeFullyInitialized,
   648  		PbmPolicyAssociationVolumeAllocationTypeReserveSpace,
   649  		PbmPolicyAssociationVolumeAllocationTypeConserveSpaceWhenPossible,
   650  	}
   651  }
   652  
   653  func (e PbmPolicyAssociationVolumeAllocationType) Strings() []string {
   654  	return types.EnumValuesAsStrings(e.Values())
   655  }
   656  
   657  func init() {
   658  	types.Add("pbm:PbmPolicyAssociationVolumeAllocationType", reflect.TypeOf((*PbmPolicyAssociationVolumeAllocationType)(nil)).Elem())
   659  }
   660  
   661  // The `PbmProfileCategoryEnum_enum`
   662  // enumerated type defines the profile categories for a capability-based
   663  // storage profile.
   664  //
   665  // See
   666  // `PbmCapabilityProfile`.
   667  type PbmProfileCategoryEnum string
   668  
   669  const (
   670  	// Indicates a storage requirement.
   671  	//
   672  	// Requirements are based on
   673  	// storage capabilities.
   674  	PbmProfileCategoryEnumREQUIREMENT = PbmProfileCategoryEnum("REQUIREMENT")
   675  	// Indicates a storage capability.
   676  	//
   677  	// Storage capabilities
   678  	// are defined by storage providers.
   679  	PbmProfileCategoryEnumRESOURCE = PbmProfileCategoryEnum("RESOURCE")
   680  	// Indicates a data service policy that can be embedded into
   681  	// another storage policy.
   682  	//
   683  	// Policies of this type can't be assigned to
   684  	// Virtual Machines or Virtual Disks.
   685  	PbmProfileCategoryEnumDATA_SERVICE_POLICY = PbmProfileCategoryEnum("DATA_SERVICE_POLICY")
   686  )
   687  
   688  func (e PbmProfileCategoryEnum) Values() []PbmProfileCategoryEnum {
   689  	return []PbmProfileCategoryEnum{
   690  		PbmProfileCategoryEnumREQUIREMENT,
   691  		PbmProfileCategoryEnumRESOURCE,
   692  		PbmProfileCategoryEnumDATA_SERVICE_POLICY,
   693  	}
   694  }
   695  
   696  func (e PbmProfileCategoryEnum) Strings() []string {
   697  	return types.EnumValuesAsStrings(e.Values())
   698  }
   699  
   700  func init() {
   701  	types.Add("pbm:PbmProfileCategoryEnum", reflect.TypeOf((*PbmProfileCategoryEnum)(nil)).Elem())
   702  }
   703  
   704  // The `PbmProfileResourceTypeEnum_enum` enumerated type defines the set of resource
   705  // types that are supported for profile management.
   706  //
   707  // See `PbmProfileResourceType`.
   708  type PbmProfileResourceTypeEnum string
   709  
   710  const (
   711  	// Indicates resources that support storage profiles.
   712  	PbmProfileResourceTypeEnumSTORAGE = PbmProfileResourceTypeEnum("STORAGE")
   713  )
   714  
   715  func (e PbmProfileResourceTypeEnum) Values() []PbmProfileResourceTypeEnum {
   716  	return []PbmProfileResourceTypeEnum{
   717  		PbmProfileResourceTypeEnumSTORAGE,
   718  	}
   719  }
   720  
   721  func (e PbmProfileResourceTypeEnum) Strings() []string {
   722  	return types.EnumValuesAsStrings(e.Values())
   723  }
   724  
   725  func init() {
   726  	types.Add("pbm:PbmProfileResourceTypeEnum", reflect.TypeOf((*PbmProfileResourceTypeEnum)(nil)).Elem())
   727  }
   728  
   729  // System pre-created profile types.
   730  type PbmSystemCreatedProfileType string
   731  
   732  const (
   733  	// Indicates the system pre-created editable VSAN default profile.
   734  	PbmSystemCreatedProfileTypeVsanDefaultProfile = PbmSystemCreatedProfileType("VsanDefaultProfile")
   735  	// Indicates the system pre-created non-editable default profile
   736  	// for VVOL datastores.
   737  	PbmSystemCreatedProfileTypeVVolDefaultProfile = PbmSystemCreatedProfileType("VVolDefaultProfile")
   738  	// Indicates the system pre-created non-editable default profile
   739  	// for PMem datastores
   740  	PbmSystemCreatedProfileTypePmemDefaultProfile = PbmSystemCreatedProfileType("PmemDefaultProfile")
   741  	// Indicates the system pre-created non-editable VMC default profile.
   742  	PbmSystemCreatedProfileTypeVmcManagementProfile = PbmSystemCreatedProfileType("VmcManagementProfile")
   743  	// Indicates the system pre-created non-editable VSANMAX default profile.
   744  	PbmSystemCreatedProfileTypeVsanMaxDefaultProfile = PbmSystemCreatedProfileType("VsanMaxDefaultProfile")
   745  )
   746  
   747  func (e PbmSystemCreatedProfileType) Values() []PbmSystemCreatedProfileType {
   748  	return []PbmSystemCreatedProfileType{
   749  		PbmSystemCreatedProfileTypeVsanDefaultProfile,
   750  		PbmSystemCreatedProfileTypeVVolDefaultProfile,
   751  		PbmSystemCreatedProfileTypePmemDefaultProfile,
   752  		PbmSystemCreatedProfileTypeVmcManagementProfile,
   753  		PbmSystemCreatedProfileTypeVsanMaxDefaultProfile,
   754  	}
   755  }
   756  
   757  func (e PbmSystemCreatedProfileType) Strings() []string {
   758  	return types.EnumValuesAsStrings(e.Values())
   759  }
   760  
   761  func init() {
   762  	types.Add("pbm:PbmSystemCreatedProfileType", reflect.TypeOf((*PbmSystemCreatedProfileType)(nil)).Elem())
   763  }
   764  
   765  // The `PbmVmOperation_enum` enumerated type
   766  // defines the provisioning operation being performed on the virtual machine.
   767  type PbmVmOperation string
   768  
   769  const (
   770  	// Indicates create operation of a virtual machine.
   771  	PbmVmOperationCREATE = PbmVmOperation("CREATE")
   772  	// Indicates reconfigure operation of a virtual machine.
   773  	PbmVmOperationRECONFIGURE = PbmVmOperation("RECONFIGURE")
   774  	// Indicates migrate operation of a virtual machine.
   775  	PbmVmOperationMIGRATE = PbmVmOperation("MIGRATE")
   776  	// Indicates clone operation of a virtual machine.
   777  	PbmVmOperationCLONE = PbmVmOperation("CLONE")
   778  )
   779  
   780  func (e PbmVmOperation) Values() []PbmVmOperation {
   781  	return []PbmVmOperation{
   782  		PbmVmOperationCREATE,
   783  		PbmVmOperationRECONFIGURE,
   784  		PbmVmOperationMIGRATE,
   785  		PbmVmOperationCLONE,
   786  	}
   787  }
   788  
   789  func (e PbmVmOperation) Strings() []string {
   790  	return types.EnumValuesAsStrings(e.Values())
   791  }
   792  
   793  func init() {
   794  	types.Add("pbm:PbmVmOperation", reflect.TypeOf((*PbmVmOperation)(nil)).Elem())
   795  }
   796  
   797  // The `PbmVvolType_enum` enumeration type
   798  // defines VVOL types.
   799  //
   800  // VvolType's are referenced to specify which objectType
   801  // to fetch for default capability.
   802  type PbmVvolType string
   803  
   804  const (
   805  	// meta-data volume
   806  	PbmVvolTypeConfig = PbmVvolType("Config")
   807  	// vmdk volume
   808  	PbmVvolTypeData = PbmVvolType("Data")
   809  	// swap volume
   810  	PbmVvolTypeSwap = PbmVvolType("Swap")
   811  )
   812  
   813  func (e PbmVvolType) Values() []PbmVvolType {
   814  	return []PbmVvolType{
   815  		PbmVvolTypeConfig,
   816  		PbmVvolTypeData,
   817  		PbmVvolTypeSwap,
   818  	}
   819  }
   820  
   821  func (e PbmVvolType) Strings() []string {
   822  	return types.EnumValuesAsStrings(e.Values())
   823  }
   824  
   825  func init() {
   826  	types.Add("pbm:PbmVvolType", reflect.TypeOf((*PbmVvolType)(nil)).Elem())
   827  }