Source file src/github.com/datawire/ambassador/v2/pkg/api/envoy/admin/v2alpha/config_dump.pb.validate.go

Documentation: github.com/datawire/ambassador/v2/pkg/api/envoy/admin/v2alpha

     1  // Code generated by protoc-gen-validate. DO NOT EDIT.
     2  // source: envoy/admin/v2alpha/config_dump.proto
     3  
     4  package envoy_admin_v2alpha
     5  
     6  import (
     7  	"bytes"
     8  	"errors"
     9  	"fmt"
    10  	"net"
    11  	"net/mail"
    12  	"net/url"
    13  	"regexp"
    14  	"strings"
    15  	"time"
    16  	"unicode/utf8"
    17  
    18  	"github.com/golang/protobuf/ptypes"
    19  )
    20  
    21  // ensure the imports are used
    22  var (
    23  	_ = bytes.MinRead
    24  	_ = errors.New("")
    25  	_ = fmt.Print
    26  	_ = utf8.UTFMax
    27  	_ = (*regexp.Regexp)(nil)
    28  	_ = (*strings.Reader)(nil)
    29  	_ = net.IPv4len
    30  	_ = time.Duration(0)
    31  	_ = (*url.URL)(nil)
    32  	_ = (*mail.Address)(nil)
    33  	_ = ptypes.DynamicAny{}
    34  )
    35  
    36  // Validate checks the field values on ConfigDump with the rules defined in the
    37  // proto definition for this message. If any rules are violated, an error is returned.
    38  func (m *ConfigDump) Validate() error {
    39  	if m == nil {
    40  		return nil
    41  	}
    42  
    43  	for idx, item := range m.GetConfigs() {
    44  		_, _ = idx, item
    45  
    46  		if v, ok := interface{}(item).(interface{ Validate() error }); ok {
    47  			if err := v.Validate(); err != nil {
    48  				return ConfigDumpValidationError{
    49  					field:  fmt.Sprintf("Configs[%v]", idx),
    50  					reason: "embedded message failed validation",
    51  					cause:  err,
    52  				}
    53  			}
    54  		}
    55  
    56  	}
    57  
    58  	return nil
    59  }
    60  
    61  // ConfigDumpValidationError is the validation error returned by
    62  // ConfigDump.Validate if the designated constraints aren't met.
    63  type ConfigDumpValidationError struct {
    64  	field  string
    65  	reason string
    66  	cause  error
    67  	key    bool
    68  }
    69  
    70  // Field function returns field value.
    71  func (e ConfigDumpValidationError) Field() string { return e.field }
    72  
    73  // Reason function returns reason value.
    74  func (e ConfigDumpValidationError) Reason() string { return e.reason }
    75  
    76  // Cause function returns cause value.
    77  func (e ConfigDumpValidationError) Cause() error { return e.cause }
    78  
    79  // Key function returns key value.
    80  func (e ConfigDumpValidationError) Key() bool { return e.key }
    81  
    82  // ErrorName returns error name.
    83  func (e ConfigDumpValidationError) ErrorName() string { return "ConfigDumpValidationError" }
    84  
    85  // Error satisfies the builtin error interface
    86  func (e ConfigDumpValidationError) Error() string {
    87  	cause := ""
    88  	if e.cause != nil {
    89  		cause = fmt.Sprintf(" | caused by: %v", e.cause)
    90  	}
    91  
    92  	key := ""
    93  	if e.key {
    94  		key = "key for "
    95  	}
    96  
    97  	return fmt.Sprintf(
    98  		"invalid %sConfigDump.%s: %s%s",
    99  		key,
   100  		e.field,
   101  		e.reason,
   102  		cause)
   103  }
   104  
   105  var _ error = ConfigDumpValidationError{}
   106  
   107  var _ interface {
   108  	Field() string
   109  	Reason() string
   110  	Key() bool
   111  	Cause() error
   112  	ErrorName() string
   113  } = ConfigDumpValidationError{}
   114  
   115  // Validate checks the field values on UpdateFailureState with the rules
   116  // defined in the proto definition for this message. If any rules are
   117  // violated, an error is returned.
   118  func (m *UpdateFailureState) Validate() error {
   119  	if m == nil {
   120  		return nil
   121  	}
   122  
   123  	if v, ok := interface{}(m.GetFailedConfiguration()).(interface{ Validate() error }); ok {
   124  		if err := v.Validate(); err != nil {
   125  			return UpdateFailureStateValidationError{
   126  				field:  "FailedConfiguration",
   127  				reason: "embedded message failed validation",
   128  				cause:  err,
   129  			}
   130  		}
   131  	}
   132  
   133  	if v, ok := interface{}(m.GetLastUpdateAttempt()).(interface{ Validate() error }); ok {
   134  		if err := v.Validate(); err != nil {
   135  			return UpdateFailureStateValidationError{
   136  				field:  "LastUpdateAttempt",
   137  				reason: "embedded message failed validation",
   138  				cause:  err,
   139  			}
   140  		}
   141  	}
   142  
   143  	// no validation rules for Details
   144  
   145  	return nil
   146  }
   147  
   148  // UpdateFailureStateValidationError is the validation error returned by
   149  // UpdateFailureState.Validate if the designated constraints aren't met.
   150  type UpdateFailureStateValidationError struct {
   151  	field  string
   152  	reason string
   153  	cause  error
   154  	key    bool
   155  }
   156  
   157  // Field function returns field value.
   158  func (e UpdateFailureStateValidationError) Field() string { return e.field }
   159  
   160  // Reason function returns reason value.
   161  func (e UpdateFailureStateValidationError) Reason() string { return e.reason }
   162  
   163  // Cause function returns cause value.
   164  func (e UpdateFailureStateValidationError) Cause() error { return e.cause }
   165  
   166  // Key function returns key value.
   167  func (e UpdateFailureStateValidationError) Key() bool { return e.key }
   168  
   169  // ErrorName returns error name.
   170  func (e UpdateFailureStateValidationError) ErrorName() string {
   171  	return "UpdateFailureStateValidationError"
   172  }
   173  
   174  // Error satisfies the builtin error interface
   175  func (e UpdateFailureStateValidationError) Error() string {
   176  	cause := ""
   177  	if e.cause != nil {
   178  		cause = fmt.Sprintf(" | caused by: %v", e.cause)
   179  	}
   180  
   181  	key := ""
   182  	if e.key {
   183  		key = "key for "
   184  	}
   185  
   186  	return fmt.Sprintf(
   187  		"invalid %sUpdateFailureState.%s: %s%s",
   188  		key,
   189  		e.field,
   190  		e.reason,
   191  		cause)
   192  }
   193  
   194  var _ error = UpdateFailureStateValidationError{}
   195  
   196  var _ interface {
   197  	Field() string
   198  	Reason() string
   199  	Key() bool
   200  	Cause() error
   201  	ErrorName() string
   202  } = UpdateFailureStateValidationError{}
   203  
   204  // Validate checks the field values on BootstrapConfigDump with the rules
   205  // defined in the proto definition for this message. If any rules are
   206  // violated, an error is returned.
   207  func (m *BootstrapConfigDump) Validate() error {
   208  	if m == nil {
   209  		return nil
   210  	}
   211  
   212  	if v, ok := interface{}(m.GetBootstrap()).(interface{ Validate() error }); ok {
   213  		if err := v.Validate(); err != nil {
   214  			return BootstrapConfigDumpValidationError{
   215  				field:  "Bootstrap",
   216  				reason: "embedded message failed validation",
   217  				cause:  err,
   218  			}
   219  		}
   220  	}
   221  
   222  	if v, ok := interface{}(m.GetLastUpdated()).(interface{ Validate() error }); ok {
   223  		if err := v.Validate(); err != nil {
   224  			return BootstrapConfigDumpValidationError{
   225  				field:  "LastUpdated",
   226  				reason: "embedded message failed validation",
   227  				cause:  err,
   228  			}
   229  		}
   230  	}
   231  
   232  	return nil
   233  }
   234  
   235  // BootstrapConfigDumpValidationError is the validation error returned by
   236  // BootstrapConfigDump.Validate if the designated constraints aren't met.
   237  type BootstrapConfigDumpValidationError struct {
   238  	field  string
   239  	reason string
   240  	cause  error
   241  	key    bool
   242  }
   243  
   244  // Field function returns field value.
   245  func (e BootstrapConfigDumpValidationError) Field() string { return e.field }
   246  
   247  // Reason function returns reason value.
   248  func (e BootstrapConfigDumpValidationError) Reason() string { return e.reason }
   249  
   250  // Cause function returns cause value.
   251  func (e BootstrapConfigDumpValidationError) Cause() error { return e.cause }
   252  
   253  // Key function returns key value.
   254  func (e BootstrapConfigDumpValidationError) Key() bool { return e.key }
   255  
   256  // ErrorName returns error name.
   257  func (e BootstrapConfigDumpValidationError) ErrorName() string {
   258  	return "BootstrapConfigDumpValidationError"
   259  }
   260  
   261  // Error satisfies the builtin error interface
   262  func (e BootstrapConfigDumpValidationError) Error() string {
   263  	cause := ""
   264  	if e.cause != nil {
   265  		cause = fmt.Sprintf(" | caused by: %v", e.cause)
   266  	}
   267  
   268  	key := ""
   269  	if e.key {
   270  		key = "key for "
   271  	}
   272  
   273  	return fmt.Sprintf(
   274  		"invalid %sBootstrapConfigDump.%s: %s%s",
   275  		key,
   276  		e.field,
   277  		e.reason,
   278  		cause)
   279  }
   280  
   281  var _ error = BootstrapConfigDumpValidationError{}
   282  
   283  var _ interface {
   284  	Field() string
   285  	Reason() string
   286  	Key() bool
   287  	Cause() error
   288  	ErrorName() string
   289  } = BootstrapConfigDumpValidationError{}
   290  
   291  // Validate checks the field values on ListenersConfigDump with the rules
   292  // defined in the proto definition for this message. If any rules are
   293  // violated, an error is returned.
   294  func (m *ListenersConfigDump) Validate() error {
   295  	if m == nil {
   296  		return nil
   297  	}
   298  
   299  	// no validation rules for VersionInfo
   300  
   301  	for idx, item := range m.GetStaticListeners() {
   302  		_, _ = idx, item
   303  
   304  		if v, ok := interface{}(item).(interface{ Validate() error }); ok {
   305  			if err := v.Validate(); err != nil {
   306  				return ListenersConfigDumpValidationError{
   307  					field:  fmt.Sprintf("StaticListeners[%v]", idx),
   308  					reason: "embedded message failed validation",
   309  					cause:  err,
   310  				}
   311  			}
   312  		}
   313  
   314  	}
   315  
   316  	for idx, item := range m.GetDynamicListeners() {
   317  		_, _ = idx, item
   318  
   319  		if v, ok := interface{}(item).(interface{ Validate() error }); ok {
   320  			if err := v.Validate(); err != nil {
   321  				return ListenersConfigDumpValidationError{
   322  					field:  fmt.Sprintf("DynamicListeners[%v]", idx),
   323  					reason: "embedded message failed validation",
   324  					cause:  err,
   325  				}
   326  			}
   327  		}
   328  
   329  	}
   330  
   331  	return nil
   332  }
   333  
   334  // ListenersConfigDumpValidationError is the validation error returned by
   335  // ListenersConfigDump.Validate if the designated constraints aren't met.
   336  type ListenersConfigDumpValidationError struct {
   337  	field  string
   338  	reason string
   339  	cause  error
   340  	key    bool
   341  }
   342  
   343  // Field function returns field value.
   344  func (e ListenersConfigDumpValidationError) Field() string { return e.field }
   345  
   346  // Reason function returns reason value.
   347  func (e ListenersConfigDumpValidationError) Reason() string { return e.reason }
   348  
   349  // Cause function returns cause value.
   350  func (e ListenersConfigDumpValidationError) Cause() error { return e.cause }
   351  
   352  // Key function returns key value.
   353  func (e ListenersConfigDumpValidationError) Key() bool { return e.key }
   354  
   355  // ErrorName returns error name.
   356  func (e ListenersConfigDumpValidationError) ErrorName() string {
   357  	return "ListenersConfigDumpValidationError"
   358  }
   359  
   360  // Error satisfies the builtin error interface
   361  func (e ListenersConfigDumpValidationError) Error() string {
   362  	cause := ""
   363  	if e.cause != nil {
   364  		cause = fmt.Sprintf(" | caused by: %v", e.cause)
   365  	}
   366  
   367  	key := ""
   368  	if e.key {
   369  		key = "key for "
   370  	}
   371  
   372  	return fmt.Sprintf(
   373  		"invalid %sListenersConfigDump.%s: %s%s",
   374  		key,
   375  		e.field,
   376  		e.reason,
   377  		cause)
   378  }
   379  
   380  var _ error = ListenersConfigDumpValidationError{}
   381  
   382  var _ interface {
   383  	Field() string
   384  	Reason() string
   385  	Key() bool
   386  	Cause() error
   387  	ErrorName() string
   388  } = ListenersConfigDumpValidationError{}
   389  
   390  // Validate checks the field values on ClustersConfigDump with the rules
   391  // defined in the proto definition for this message. If any rules are
   392  // violated, an error is returned.
   393  func (m *ClustersConfigDump) Validate() error {
   394  	if m == nil {
   395  		return nil
   396  	}
   397  
   398  	// no validation rules for VersionInfo
   399  
   400  	for idx, item := range m.GetStaticClusters() {
   401  		_, _ = idx, item
   402  
   403  		if v, ok := interface{}(item).(interface{ Validate() error }); ok {
   404  			if err := v.Validate(); err != nil {
   405  				return ClustersConfigDumpValidationError{
   406  					field:  fmt.Sprintf("StaticClusters[%v]", idx),
   407  					reason: "embedded message failed validation",
   408  					cause:  err,
   409  				}
   410  			}
   411  		}
   412  
   413  	}
   414  
   415  	for idx, item := range m.GetDynamicActiveClusters() {
   416  		_, _ = idx, item
   417  
   418  		if v, ok := interface{}(item).(interface{ Validate() error }); ok {
   419  			if err := v.Validate(); err != nil {
   420  				return ClustersConfigDumpValidationError{
   421  					field:  fmt.Sprintf("DynamicActiveClusters[%v]", idx),
   422  					reason: "embedded message failed validation",
   423  					cause:  err,
   424  				}
   425  			}
   426  		}
   427  
   428  	}
   429  
   430  	for idx, item := range m.GetDynamicWarmingClusters() {
   431  		_, _ = idx, item
   432  
   433  		if v, ok := interface{}(item).(interface{ Validate() error }); ok {
   434  			if err := v.Validate(); err != nil {
   435  				return ClustersConfigDumpValidationError{
   436  					field:  fmt.Sprintf("DynamicWarmingClusters[%v]", idx),
   437  					reason: "embedded message failed validation",
   438  					cause:  err,
   439  				}
   440  			}
   441  		}
   442  
   443  	}
   444  
   445  	return nil
   446  }
   447  
   448  // ClustersConfigDumpValidationError is the validation error returned by
   449  // ClustersConfigDump.Validate if the designated constraints aren't met.
   450  type ClustersConfigDumpValidationError struct {
   451  	field  string
   452  	reason string
   453  	cause  error
   454  	key    bool
   455  }
   456  
   457  // Field function returns field value.
   458  func (e ClustersConfigDumpValidationError) Field() string { return e.field }
   459  
   460  // Reason function returns reason value.
   461  func (e ClustersConfigDumpValidationError) Reason() string { return e.reason }
   462  
   463  // Cause function returns cause value.
   464  func (e ClustersConfigDumpValidationError) Cause() error { return e.cause }
   465  
   466  // Key function returns key value.
   467  func (e ClustersConfigDumpValidationError) Key() bool { return e.key }
   468  
   469  // ErrorName returns error name.
   470  func (e ClustersConfigDumpValidationError) ErrorName() string {
   471  	return "ClustersConfigDumpValidationError"
   472  }
   473  
   474  // Error satisfies the builtin error interface
   475  func (e ClustersConfigDumpValidationError) Error() string {
   476  	cause := ""
   477  	if e.cause != nil {
   478  		cause = fmt.Sprintf(" | caused by: %v", e.cause)
   479  	}
   480  
   481  	key := ""
   482  	if e.key {
   483  		key = "key for "
   484  	}
   485  
   486  	return fmt.Sprintf(
   487  		"invalid %sClustersConfigDump.%s: %s%s",
   488  		key,
   489  		e.field,
   490  		e.reason,
   491  		cause)
   492  }
   493  
   494  var _ error = ClustersConfigDumpValidationError{}
   495  
   496  var _ interface {
   497  	Field() string
   498  	Reason() string
   499  	Key() bool
   500  	Cause() error
   501  	ErrorName() string
   502  } = ClustersConfigDumpValidationError{}
   503  
   504  // Validate checks the field values on RoutesConfigDump with the rules defined
   505  // in the proto definition for this message. If any rules are violated, an
   506  // error is returned.
   507  func (m *RoutesConfigDump) Validate() error {
   508  	if m == nil {
   509  		return nil
   510  	}
   511  
   512  	for idx, item := range m.GetStaticRouteConfigs() {
   513  		_, _ = idx, item
   514  
   515  		if v, ok := interface{}(item).(interface{ Validate() error }); ok {
   516  			if err := v.Validate(); err != nil {
   517  				return RoutesConfigDumpValidationError{
   518  					field:  fmt.Sprintf("StaticRouteConfigs[%v]", idx),
   519  					reason: "embedded message failed validation",
   520  					cause:  err,
   521  				}
   522  			}
   523  		}
   524  
   525  	}
   526  
   527  	for idx, item := range m.GetDynamicRouteConfigs() {
   528  		_, _ = idx, item
   529  
   530  		if v, ok := interface{}(item).(interface{ Validate() error }); ok {
   531  			if err := v.Validate(); err != nil {
   532  				return RoutesConfigDumpValidationError{
   533  					field:  fmt.Sprintf("DynamicRouteConfigs[%v]", idx),
   534  					reason: "embedded message failed validation",
   535  					cause:  err,
   536  				}
   537  			}
   538  		}
   539  
   540  	}
   541  
   542  	return nil
   543  }
   544  
   545  // RoutesConfigDumpValidationError is the validation error returned by
   546  // RoutesConfigDump.Validate if the designated constraints aren't met.
   547  type RoutesConfigDumpValidationError struct {
   548  	field  string
   549  	reason string
   550  	cause  error
   551  	key    bool
   552  }
   553  
   554  // Field function returns field value.
   555  func (e RoutesConfigDumpValidationError) Field() string { return e.field }
   556  
   557  // Reason function returns reason value.
   558  func (e RoutesConfigDumpValidationError) Reason() string { return e.reason }
   559  
   560  // Cause function returns cause value.
   561  func (e RoutesConfigDumpValidationError) Cause() error { return e.cause }
   562  
   563  // Key function returns key value.
   564  func (e RoutesConfigDumpValidationError) Key() bool { return e.key }
   565  
   566  // ErrorName returns error name.
   567  func (e RoutesConfigDumpValidationError) ErrorName() string { return "RoutesConfigDumpValidationError" }
   568  
   569  // Error satisfies the builtin error interface
   570  func (e RoutesConfigDumpValidationError) Error() string {
   571  	cause := ""
   572  	if e.cause != nil {
   573  		cause = fmt.Sprintf(" | caused by: %v", e.cause)
   574  	}
   575  
   576  	key := ""
   577  	if e.key {
   578  		key = "key for "
   579  	}
   580  
   581  	return fmt.Sprintf(
   582  		"invalid %sRoutesConfigDump.%s: %s%s",
   583  		key,
   584  		e.field,
   585  		e.reason,
   586  		cause)
   587  }
   588  
   589  var _ error = RoutesConfigDumpValidationError{}
   590  
   591  var _ interface {
   592  	Field() string
   593  	Reason() string
   594  	Key() bool
   595  	Cause() error
   596  	ErrorName() string
   597  } = RoutesConfigDumpValidationError{}
   598  
   599  // Validate checks the field values on ScopedRoutesConfigDump with the rules
   600  // defined in the proto definition for this message. If any rules are
   601  // violated, an error is returned.
   602  func (m *ScopedRoutesConfigDump) Validate() error {
   603  	if m == nil {
   604  		return nil
   605  	}
   606  
   607  	for idx, item := range m.GetInlineScopedRouteConfigs() {
   608  		_, _ = idx, item
   609  
   610  		if v, ok := interface{}(item).(interface{ Validate() error }); ok {
   611  			if err := v.Validate(); err != nil {
   612  				return ScopedRoutesConfigDumpValidationError{
   613  					field:  fmt.Sprintf("InlineScopedRouteConfigs[%v]", idx),
   614  					reason: "embedded message failed validation",
   615  					cause:  err,
   616  				}
   617  			}
   618  		}
   619  
   620  	}
   621  
   622  	for idx, item := range m.GetDynamicScopedRouteConfigs() {
   623  		_, _ = idx, item
   624  
   625  		if v, ok := interface{}(item).(interface{ Validate() error }); ok {
   626  			if err := v.Validate(); err != nil {
   627  				return ScopedRoutesConfigDumpValidationError{
   628  					field:  fmt.Sprintf("DynamicScopedRouteConfigs[%v]", idx),
   629  					reason: "embedded message failed validation",
   630  					cause:  err,
   631  				}
   632  			}
   633  		}
   634  
   635  	}
   636  
   637  	return nil
   638  }
   639  
   640  // ScopedRoutesConfigDumpValidationError is the validation error returned by
   641  // ScopedRoutesConfigDump.Validate if the designated constraints aren't met.
   642  type ScopedRoutesConfigDumpValidationError struct {
   643  	field  string
   644  	reason string
   645  	cause  error
   646  	key    bool
   647  }
   648  
   649  // Field function returns field value.
   650  func (e ScopedRoutesConfigDumpValidationError) Field() string { return e.field }
   651  
   652  // Reason function returns reason value.
   653  func (e ScopedRoutesConfigDumpValidationError) Reason() string { return e.reason }
   654  
   655  // Cause function returns cause value.
   656  func (e ScopedRoutesConfigDumpValidationError) Cause() error { return e.cause }
   657  
   658  // Key function returns key value.
   659  func (e ScopedRoutesConfigDumpValidationError) Key() bool { return e.key }
   660  
   661  // ErrorName returns error name.
   662  func (e ScopedRoutesConfigDumpValidationError) ErrorName() string {
   663  	return "ScopedRoutesConfigDumpValidationError"
   664  }
   665  
   666  // Error satisfies the builtin error interface
   667  func (e ScopedRoutesConfigDumpValidationError) Error() string {
   668  	cause := ""
   669  	if e.cause != nil {
   670  		cause = fmt.Sprintf(" | caused by: %v", e.cause)
   671  	}
   672  
   673  	key := ""
   674  	if e.key {
   675  		key = "key for "
   676  	}
   677  
   678  	return fmt.Sprintf(
   679  		"invalid %sScopedRoutesConfigDump.%s: %s%s",
   680  		key,
   681  		e.field,
   682  		e.reason,
   683  		cause)
   684  }
   685  
   686  var _ error = ScopedRoutesConfigDumpValidationError{}
   687  
   688  var _ interface {
   689  	Field() string
   690  	Reason() string
   691  	Key() bool
   692  	Cause() error
   693  	ErrorName() string
   694  } = ScopedRoutesConfigDumpValidationError{}
   695  
   696  // Validate checks the field values on SecretsConfigDump with the rules defined
   697  // in the proto definition for this message. If any rules are violated, an
   698  // error is returned.
   699  func (m *SecretsConfigDump) Validate() error {
   700  	if m == nil {
   701  		return nil
   702  	}
   703  
   704  	for idx, item := range m.GetStaticSecrets() {
   705  		_, _ = idx, item
   706  
   707  		if v, ok := interface{}(item).(interface{ Validate() error }); ok {
   708  			if err := v.Validate(); err != nil {
   709  				return SecretsConfigDumpValidationError{
   710  					field:  fmt.Sprintf("StaticSecrets[%v]", idx),
   711  					reason: "embedded message failed validation",
   712  					cause:  err,
   713  				}
   714  			}
   715  		}
   716  
   717  	}
   718  
   719  	for idx, item := range m.GetDynamicActiveSecrets() {
   720  		_, _ = idx, item
   721  
   722  		if v, ok := interface{}(item).(interface{ Validate() error }); ok {
   723  			if err := v.Validate(); err != nil {
   724  				return SecretsConfigDumpValidationError{
   725  					field:  fmt.Sprintf("DynamicActiveSecrets[%v]", idx),
   726  					reason: "embedded message failed validation",
   727  					cause:  err,
   728  				}
   729  			}
   730  		}
   731  
   732  	}
   733  
   734  	for idx, item := range m.GetDynamicWarmingSecrets() {
   735  		_, _ = idx, item
   736  
   737  		if v, ok := interface{}(item).(interface{ Validate() error }); ok {
   738  			if err := v.Validate(); err != nil {
   739  				return SecretsConfigDumpValidationError{
   740  					field:  fmt.Sprintf("DynamicWarmingSecrets[%v]", idx),
   741  					reason: "embedded message failed validation",
   742  					cause:  err,
   743  				}
   744  			}
   745  		}
   746  
   747  	}
   748  
   749  	return nil
   750  }
   751  
   752  // SecretsConfigDumpValidationError is the validation error returned by
   753  // SecretsConfigDump.Validate if the designated constraints aren't met.
   754  type SecretsConfigDumpValidationError struct {
   755  	field  string
   756  	reason string
   757  	cause  error
   758  	key    bool
   759  }
   760  
   761  // Field function returns field value.
   762  func (e SecretsConfigDumpValidationError) Field() string { return e.field }
   763  
   764  // Reason function returns reason value.
   765  func (e SecretsConfigDumpValidationError) Reason() string { return e.reason }
   766  
   767  // Cause function returns cause value.
   768  func (e SecretsConfigDumpValidationError) Cause() error { return e.cause }
   769  
   770  // Key function returns key value.
   771  func (e SecretsConfigDumpValidationError) Key() bool { return e.key }
   772  
   773  // ErrorName returns error name.
   774  func (e SecretsConfigDumpValidationError) ErrorName() string {
   775  	return "SecretsConfigDumpValidationError"
   776  }
   777  
   778  // Error satisfies the builtin error interface
   779  func (e SecretsConfigDumpValidationError) Error() string {
   780  	cause := ""
   781  	if e.cause != nil {
   782  		cause = fmt.Sprintf(" | caused by: %v", e.cause)
   783  	}
   784  
   785  	key := ""
   786  	if e.key {
   787  		key = "key for "
   788  	}
   789  
   790  	return fmt.Sprintf(
   791  		"invalid %sSecretsConfigDump.%s: %s%s",
   792  		key,
   793  		e.field,
   794  		e.reason,
   795  		cause)
   796  }
   797  
   798  var _ error = SecretsConfigDumpValidationError{}
   799  
   800  var _ interface {
   801  	Field() string
   802  	Reason() string
   803  	Key() bool
   804  	Cause() error
   805  	ErrorName() string
   806  } = SecretsConfigDumpValidationError{}
   807  
   808  // Validate checks the field values on ListenersConfigDump_StaticListener with
   809  // the rules defined in the proto definition for this message. If any rules
   810  // are violated, an error is returned.
   811  func (m *ListenersConfigDump_StaticListener) Validate() error {
   812  	if m == nil {
   813  		return nil
   814  	}
   815  
   816  	if v, ok := interface{}(m.GetListener()).(interface{ Validate() error }); ok {
   817  		if err := v.Validate(); err != nil {
   818  			return ListenersConfigDump_StaticListenerValidationError{
   819  				field:  "Listener",
   820  				reason: "embedded message failed validation",
   821  				cause:  err,
   822  			}
   823  		}
   824  	}
   825  
   826  	if v, ok := interface{}(m.GetLastUpdated()).(interface{ Validate() error }); ok {
   827  		if err := v.Validate(); err != nil {
   828  			return ListenersConfigDump_StaticListenerValidationError{
   829  				field:  "LastUpdated",
   830  				reason: "embedded message failed validation",
   831  				cause:  err,
   832  			}
   833  		}
   834  	}
   835  
   836  	return nil
   837  }
   838  
   839  // ListenersConfigDump_StaticListenerValidationError is the validation error
   840  // returned by ListenersConfigDump_StaticListener.Validate if the designated
   841  // constraints aren't met.
   842  type ListenersConfigDump_StaticListenerValidationError struct {
   843  	field  string
   844  	reason string
   845  	cause  error
   846  	key    bool
   847  }
   848  
   849  // Field function returns field value.
   850  func (e ListenersConfigDump_StaticListenerValidationError) Field() string { return e.field }
   851  
   852  // Reason function returns reason value.
   853  func (e ListenersConfigDump_StaticListenerValidationError) Reason() string { return e.reason }
   854  
   855  // Cause function returns cause value.
   856  func (e ListenersConfigDump_StaticListenerValidationError) Cause() error { return e.cause }
   857  
   858  // Key function returns key value.
   859  func (e ListenersConfigDump_StaticListenerValidationError) Key() bool { return e.key }
   860  
   861  // ErrorName returns error name.
   862  func (e ListenersConfigDump_StaticListenerValidationError) ErrorName() string {
   863  	return "ListenersConfigDump_StaticListenerValidationError"
   864  }
   865  
   866  // Error satisfies the builtin error interface
   867  func (e ListenersConfigDump_StaticListenerValidationError) Error() string {
   868  	cause := ""
   869  	if e.cause != nil {
   870  		cause = fmt.Sprintf(" | caused by: %v", e.cause)
   871  	}
   872  
   873  	key := ""
   874  	if e.key {
   875  		key = "key for "
   876  	}
   877  
   878  	return fmt.Sprintf(
   879  		"invalid %sListenersConfigDump_StaticListener.%s: %s%s",
   880  		key,
   881  		e.field,
   882  		e.reason,
   883  		cause)
   884  }
   885  
   886  var _ error = ListenersConfigDump_StaticListenerValidationError{}
   887  
   888  var _ interface {
   889  	Field() string
   890  	Reason() string
   891  	Key() bool
   892  	Cause() error
   893  	ErrorName() string
   894  } = ListenersConfigDump_StaticListenerValidationError{}
   895  
   896  // Validate checks the field values on ListenersConfigDump_DynamicListenerState
   897  // with the rules defined in the proto definition for this message. If any
   898  // rules are violated, an error is returned.
   899  func (m *ListenersConfigDump_DynamicListenerState) Validate() error {
   900  	if m == nil {
   901  		return nil
   902  	}
   903  
   904  	// no validation rules for VersionInfo
   905  
   906  	if v, ok := interface{}(m.GetListener()).(interface{ Validate() error }); ok {
   907  		if err := v.Validate(); err != nil {
   908  			return ListenersConfigDump_DynamicListenerStateValidationError{
   909  				field:  "Listener",
   910  				reason: "embedded message failed validation",
   911  				cause:  err,
   912  			}
   913  		}
   914  	}
   915  
   916  	if v, ok := interface{}(m.GetLastUpdated()).(interface{ Validate() error }); ok {
   917  		if err := v.Validate(); err != nil {
   918  			return ListenersConfigDump_DynamicListenerStateValidationError{
   919  				field:  "LastUpdated",
   920  				reason: "embedded message failed validation",
   921  				cause:  err,
   922  			}
   923  		}
   924  	}
   925  
   926  	return nil
   927  }
   928  
   929  // ListenersConfigDump_DynamicListenerStateValidationError is the validation
   930  // error returned by ListenersConfigDump_DynamicListenerState.Validate if the
   931  // designated constraints aren't met.
   932  type ListenersConfigDump_DynamicListenerStateValidationError struct {
   933  	field  string
   934  	reason string
   935  	cause  error
   936  	key    bool
   937  }
   938  
   939  // Field function returns field value.
   940  func (e ListenersConfigDump_DynamicListenerStateValidationError) Field() string { return e.field }
   941  
   942  // Reason function returns reason value.
   943  func (e ListenersConfigDump_DynamicListenerStateValidationError) Reason() string { return e.reason }
   944  
   945  // Cause function returns cause value.
   946  func (e ListenersConfigDump_DynamicListenerStateValidationError) Cause() error { return e.cause }
   947  
   948  // Key function returns key value.
   949  func (e ListenersConfigDump_DynamicListenerStateValidationError) Key() bool { return e.key }
   950  
   951  // ErrorName returns error name.
   952  func (e ListenersConfigDump_DynamicListenerStateValidationError) ErrorName() string {
   953  	return "ListenersConfigDump_DynamicListenerStateValidationError"
   954  }
   955  
   956  // Error satisfies the builtin error interface
   957  func (e ListenersConfigDump_DynamicListenerStateValidationError) Error() string {
   958  	cause := ""
   959  	if e.cause != nil {
   960  		cause = fmt.Sprintf(" | caused by: %v", e.cause)
   961  	}
   962  
   963  	key := ""
   964  	if e.key {
   965  		key = "key for "
   966  	}
   967  
   968  	return fmt.Sprintf(
   969  		"invalid %sListenersConfigDump_DynamicListenerState.%s: %s%s",
   970  		key,
   971  		e.field,
   972  		e.reason,
   973  		cause)
   974  }
   975  
   976  var _ error = ListenersConfigDump_DynamicListenerStateValidationError{}
   977  
   978  var _ interface {
   979  	Field() string
   980  	Reason() string
   981  	Key() bool
   982  	Cause() error
   983  	ErrorName() string
   984  } = ListenersConfigDump_DynamicListenerStateValidationError{}
   985  
   986  // Validate checks the field values on ListenersConfigDump_DynamicListener with
   987  // the rules defined in the proto definition for this message. If any rules
   988  // are violated, an error is returned.
   989  func (m *ListenersConfigDump_DynamicListener) Validate() error {
   990  	if m == nil {
   991  		return nil
   992  	}
   993  
   994  	// no validation rules for Name
   995  
   996  	if v, ok := interface{}(m.GetActiveState()).(interface{ Validate() error }); ok {
   997  		if err := v.Validate(); err != nil {
   998  			return ListenersConfigDump_DynamicListenerValidationError{
   999  				field:  "ActiveState",
  1000  				reason: "embedded message failed validation",
  1001  				cause:  err,
  1002  			}
  1003  		}
  1004  	}
  1005  
  1006  	if v, ok := interface{}(m.GetWarmingState()).(interface{ Validate() error }); ok {
  1007  		if err := v.Validate(); err != nil {
  1008  			return ListenersConfigDump_DynamicListenerValidationError{
  1009  				field:  "WarmingState",
  1010  				reason: "embedded message failed validation",
  1011  				cause:  err,
  1012  			}
  1013  		}
  1014  	}
  1015  
  1016  	if v, ok := interface{}(m.GetDrainingState()).(interface{ Validate() error }); ok {
  1017  		if err := v.Validate(); err != nil {
  1018  			return ListenersConfigDump_DynamicListenerValidationError{
  1019  				field:  "DrainingState",
  1020  				reason: "embedded message failed validation",
  1021  				cause:  err,
  1022  			}
  1023  		}
  1024  	}
  1025  
  1026  	if v, ok := interface{}(m.GetErrorState()).(interface{ Validate() error }); ok {
  1027  		if err := v.Validate(); err != nil {
  1028  			return ListenersConfigDump_DynamicListenerValidationError{
  1029  				field:  "ErrorState",
  1030  				reason: "embedded message failed validation",
  1031  				cause:  err,
  1032  			}
  1033  		}
  1034  	}
  1035  
  1036  	return nil
  1037  }
  1038  
  1039  // ListenersConfigDump_DynamicListenerValidationError is the validation error
  1040  // returned by ListenersConfigDump_DynamicListener.Validate if the designated
  1041  // constraints aren't met.
  1042  type ListenersConfigDump_DynamicListenerValidationError struct {
  1043  	field  string
  1044  	reason string
  1045  	cause  error
  1046  	key    bool
  1047  }
  1048  
  1049  // Field function returns field value.
  1050  func (e ListenersConfigDump_DynamicListenerValidationError) Field() string { return e.field }
  1051  
  1052  // Reason function returns reason value.
  1053  func (e ListenersConfigDump_DynamicListenerValidationError) Reason() string { return e.reason }
  1054  
  1055  // Cause function returns cause value.
  1056  func (e ListenersConfigDump_DynamicListenerValidationError) Cause() error { return e.cause }
  1057  
  1058  // Key function returns key value.
  1059  func (e ListenersConfigDump_DynamicListenerValidationError) Key() bool { return e.key }
  1060  
  1061  // ErrorName returns error name.
  1062  func (e ListenersConfigDump_DynamicListenerValidationError) ErrorName() string {
  1063  	return "ListenersConfigDump_DynamicListenerValidationError"
  1064  }
  1065  
  1066  // Error satisfies the builtin error interface
  1067  func (e ListenersConfigDump_DynamicListenerValidationError) Error() string {
  1068  	cause := ""
  1069  	if e.cause != nil {
  1070  		cause = fmt.Sprintf(" | caused by: %v", e.cause)
  1071  	}
  1072  
  1073  	key := ""
  1074  	if e.key {
  1075  		key = "key for "
  1076  	}
  1077  
  1078  	return fmt.Sprintf(
  1079  		"invalid %sListenersConfigDump_DynamicListener.%s: %s%s",
  1080  		key,
  1081  		e.field,
  1082  		e.reason,
  1083  		cause)
  1084  }
  1085  
  1086  var _ error = ListenersConfigDump_DynamicListenerValidationError{}
  1087  
  1088  var _ interface {
  1089  	Field() string
  1090  	Reason() string
  1091  	Key() bool
  1092  	Cause() error
  1093  	ErrorName() string
  1094  } = ListenersConfigDump_DynamicListenerValidationError{}
  1095  
  1096  // Validate checks the field values on ClustersConfigDump_StaticCluster with
  1097  // the rules defined in the proto definition for this message. If any rules
  1098  // are violated, an error is returned.
  1099  func (m *ClustersConfigDump_StaticCluster) Validate() error {
  1100  	if m == nil {
  1101  		return nil
  1102  	}
  1103  
  1104  	if v, ok := interface{}(m.GetCluster()).(interface{ Validate() error }); ok {
  1105  		if err := v.Validate(); err != nil {
  1106  			return ClustersConfigDump_StaticClusterValidationError{
  1107  				field:  "Cluster",
  1108  				reason: "embedded message failed validation",
  1109  				cause:  err,
  1110  			}
  1111  		}
  1112  	}
  1113  
  1114  	if v, ok := interface{}(m.GetLastUpdated()).(interface{ Validate() error }); ok {
  1115  		if err := v.Validate(); err != nil {
  1116  			return ClustersConfigDump_StaticClusterValidationError{
  1117  				field:  "LastUpdated",
  1118  				reason: "embedded message failed validation",
  1119  				cause:  err,
  1120  			}
  1121  		}
  1122  	}
  1123  
  1124  	return nil
  1125  }
  1126  
  1127  // ClustersConfigDump_StaticClusterValidationError is the validation error
  1128  // returned by ClustersConfigDump_StaticCluster.Validate if the designated
  1129  // constraints aren't met.
  1130  type ClustersConfigDump_StaticClusterValidationError struct {
  1131  	field  string
  1132  	reason string
  1133  	cause  error
  1134  	key    bool
  1135  }
  1136  
  1137  // Field function returns field value.
  1138  func (e ClustersConfigDump_StaticClusterValidationError) Field() string { return e.field }
  1139  
  1140  // Reason function returns reason value.
  1141  func (e ClustersConfigDump_StaticClusterValidationError) Reason() string { return e.reason }
  1142  
  1143  // Cause function returns cause value.
  1144  func (e ClustersConfigDump_StaticClusterValidationError) Cause() error { return e.cause }
  1145  
  1146  // Key function returns key value.
  1147  func (e ClustersConfigDump_StaticClusterValidationError) Key() bool { return e.key }
  1148  
  1149  // ErrorName returns error name.
  1150  func (e ClustersConfigDump_StaticClusterValidationError) ErrorName() string {
  1151  	return "ClustersConfigDump_StaticClusterValidationError"
  1152  }
  1153  
  1154  // Error satisfies the builtin error interface
  1155  func (e ClustersConfigDump_StaticClusterValidationError) Error() string {
  1156  	cause := ""
  1157  	if e.cause != nil {
  1158  		cause = fmt.Sprintf(" | caused by: %v", e.cause)
  1159  	}
  1160  
  1161  	key := ""
  1162  	if e.key {
  1163  		key = "key for "
  1164  	}
  1165  
  1166  	return fmt.Sprintf(
  1167  		"invalid %sClustersConfigDump_StaticCluster.%s: %s%s",
  1168  		key,
  1169  		e.field,
  1170  		e.reason,
  1171  		cause)
  1172  }
  1173  
  1174  var _ error = ClustersConfigDump_StaticClusterValidationError{}
  1175  
  1176  var _ interface {
  1177  	Field() string
  1178  	Reason() string
  1179  	Key() bool
  1180  	Cause() error
  1181  	ErrorName() string
  1182  } = ClustersConfigDump_StaticClusterValidationError{}
  1183  
  1184  // Validate checks the field values on ClustersConfigDump_DynamicCluster with
  1185  // the rules defined in the proto definition for this message. If any rules
  1186  // are violated, an error is returned.
  1187  func (m *ClustersConfigDump_DynamicCluster) Validate() error {
  1188  	if m == nil {
  1189  		return nil
  1190  	}
  1191  
  1192  	// no validation rules for VersionInfo
  1193  
  1194  	if v, ok := interface{}(m.GetCluster()).(interface{ Validate() error }); ok {
  1195  		if err := v.Validate(); err != nil {
  1196  			return ClustersConfigDump_DynamicClusterValidationError{
  1197  				field:  "Cluster",
  1198  				reason: "embedded message failed validation",
  1199  				cause:  err,
  1200  			}
  1201  		}
  1202  	}
  1203  
  1204  	if v, ok := interface{}(m.GetLastUpdated()).(interface{ Validate() error }); ok {
  1205  		if err := v.Validate(); err != nil {
  1206  			return ClustersConfigDump_DynamicClusterValidationError{
  1207  				field:  "LastUpdated",
  1208  				reason: "embedded message failed validation",
  1209  				cause:  err,
  1210  			}
  1211  		}
  1212  	}
  1213  
  1214  	return nil
  1215  }
  1216  
  1217  // ClustersConfigDump_DynamicClusterValidationError is the validation error
  1218  // returned by ClustersConfigDump_DynamicCluster.Validate if the designated
  1219  // constraints aren't met.
  1220  type ClustersConfigDump_DynamicClusterValidationError struct {
  1221  	field  string
  1222  	reason string
  1223  	cause  error
  1224  	key    bool
  1225  }
  1226  
  1227  // Field function returns field value.
  1228  func (e ClustersConfigDump_DynamicClusterValidationError) Field() string { return e.field }
  1229  
  1230  // Reason function returns reason value.
  1231  func (e ClustersConfigDump_DynamicClusterValidationError) Reason() string { return e.reason }
  1232  
  1233  // Cause function returns cause value.
  1234  func (e ClustersConfigDump_DynamicClusterValidationError) Cause() error { return e.cause }
  1235  
  1236  // Key function returns key value.
  1237  func (e ClustersConfigDump_DynamicClusterValidationError) Key() bool { return e.key }
  1238  
  1239  // ErrorName returns error name.
  1240  func (e ClustersConfigDump_DynamicClusterValidationError) ErrorName() string {
  1241  	return "ClustersConfigDump_DynamicClusterValidationError"
  1242  }
  1243  
  1244  // Error satisfies the builtin error interface
  1245  func (e ClustersConfigDump_DynamicClusterValidationError) Error() string {
  1246  	cause := ""
  1247  	if e.cause != nil {
  1248  		cause = fmt.Sprintf(" | caused by: %v", e.cause)
  1249  	}
  1250  
  1251  	key := ""
  1252  	if e.key {
  1253  		key = "key for "
  1254  	}
  1255  
  1256  	return fmt.Sprintf(
  1257  		"invalid %sClustersConfigDump_DynamicCluster.%s: %s%s",
  1258  		key,
  1259  		e.field,
  1260  		e.reason,
  1261  		cause)
  1262  }
  1263  
  1264  var _ error = ClustersConfigDump_DynamicClusterValidationError{}
  1265  
  1266  var _ interface {
  1267  	Field() string
  1268  	Reason() string
  1269  	Key() bool
  1270  	Cause() error
  1271  	ErrorName() string
  1272  } = ClustersConfigDump_DynamicClusterValidationError{}
  1273  
  1274  // Validate checks the field values on RoutesConfigDump_StaticRouteConfig with
  1275  // the rules defined in the proto definition for this message. If any rules
  1276  // are violated, an error is returned.
  1277  func (m *RoutesConfigDump_StaticRouteConfig) Validate() error {
  1278  	if m == nil {
  1279  		return nil
  1280  	}
  1281  
  1282  	if v, ok := interface{}(m.GetRouteConfig()).(interface{ Validate() error }); ok {
  1283  		if err := v.Validate(); err != nil {
  1284  			return RoutesConfigDump_StaticRouteConfigValidationError{
  1285  				field:  "RouteConfig",
  1286  				reason: "embedded message failed validation",
  1287  				cause:  err,
  1288  			}
  1289  		}
  1290  	}
  1291  
  1292  	if v, ok := interface{}(m.GetLastUpdated()).(interface{ Validate() error }); ok {
  1293  		if err := v.Validate(); err != nil {
  1294  			return RoutesConfigDump_StaticRouteConfigValidationError{
  1295  				field:  "LastUpdated",
  1296  				reason: "embedded message failed validation",
  1297  				cause:  err,
  1298  			}
  1299  		}
  1300  	}
  1301  
  1302  	return nil
  1303  }
  1304  
  1305  // RoutesConfigDump_StaticRouteConfigValidationError is the validation error
  1306  // returned by RoutesConfigDump_StaticRouteConfig.Validate if the designated
  1307  // constraints aren't met.
  1308  type RoutesConfigDump_StaticRouteConfigValidationError struct {
  1309  	field  string
  1310  	reason string
  1311  	cause  error
  1312  	key    bool
  1313  }
  1314  
  1315  // Field function returns field value.
  1316  func (e RoutesConfigDump_StaticRouteConfigValidationError) Field() string { return e.field }
  1317  
  1318  // Reason function returns reason value.
  1319  func (e RoutesConfigDump_StaticRouteConfigValidationError) Reason() string { return e.reason }
  1320  
  1321  // Cause function returns cause value.
  1322  func (e RoutesConfigDump_StaticRouteConfigValidationError) Cause() error { return e.cause }
  1323  
  1324  // Key function returns key value.
  1325  func (e RoutesConfigDump_StaticRouteConfigValidationError) Key() bool { return e.key }
  1326  
  1327  // ErrorName returns error name.
  1328  func (e RoutesConfigDump_StaticRouteConfigValidationError) ErrorName() string {
  1329  	return "RoutesConfigDump_StaticRouteConfigValidationError"
  1330  }
  1331  
  1332  // Error satisfies the builtin error interface
  1333  func (e RoutesConfigDump_StaticRouteConfigValidationError) Error() string {
  1334  	cause := ""
  1335  	if e.cause != nil {
  1336  		cause = fmt.Sprintf(" | caused by: %v", e.cause)
  1337  	}
  1338  
  1339  	key := ""
  1340  	if e.key {
  1341  		key = "key for "
  1342  	}
  1343  
  1344  	return fmt.Sprintf(
  1345  		"invalid %sRoutesConfigDump_StaticRouteConfig.%s: %s%s",
  1346  		key,
  1347  		e.field,
  1348  		e.reason,
  1349  		cause)
  1350  }
  1351  
  1352  var _ error = RoutesConfigDump_StaticRouteConfigValidationError{}
  1353  
  1354  var _ interface {
  1355  	Field() string
  1356  	Reason() string
  1357  	Key() bool
  1358  	Cause() error
  1359  	ErrorName() string
  1360  } = RoutesConfigDump_StaticRouteConfigValidationError{}
  1361  
  1362  // Validate checks the field values on RoutesConfigDump_DynamicRouteConfig with
  1363  // the rules defined in the proto definition for this message. If any rules
  1364  // are violated, an error is returned.
  1365  func (m *RoutesConfigDump_DynamicRouteConfig) Validate() error {
  1366  	if m == nil {
  1367  		return nil
  1368  	}
  1369  
  1370  	// no validation rules for VersionInfo
  1371  
  1372  	if v, ok := interface{}(m.GetRouteConfig()).(interface{ Validate() error }); ok {
  1373  		if err := v.Validate(); err != nil {
  1374  			return RoutesConfigDump_DynamicRouteConfigValidationError{
  1375  				field:  "RouteConfig",
  1376  				reason: "embedded message failed validation",
  1377  				cause:  err,
  1378  			}
  1379  		}
  1380  	}
  1381  
  1382  	if v, ok := interface{}(m.GetLastUpdated()).(interface{ Validate() error }); ok {
  1383  		if err := v.Validate(); err != nil {
  1384  			return RoutesConfigDump_DynamicRouteConfigValidationError{
  1385  				field:  "LastUpdated",
  1386  				reason: "embedded message failed validation",
  1387  				cause:  err,
  1388  			}
  1389  		}
  1390  	}
  1391  
  1392  	return nil
  1393  }
  1394  
  1395  // RoutesConfigDump_DynamicRouteConfigValidationError is the validation error
  1396  // returned by RoutesConfigDump_DynamicRouteConfig.Validate if the designated
  1397  // constraints aren't met.
  1398  type RoutesConfigDump_DynamicRouteConfigValidationError struct {
  1399  	field  string
  1400  	reason string
  1401  	cause  error
  1402  	key    bool
  1403  }
  1404  
  1405  // Field function returns field value.
  1406  func (e RoutesConfigDump_DynamicRouteConfigValidationError) Field() string { return e.field }
  1407  
  1408  // Reason function returns reason value.
  1409  func (e RoutesConfigDump_DynamicRouteConfigValidationError) Reason() string { return e.reason }
  1410  
  1411  // Cause function returns cause value.
  1412  func (e RoutesConfigDump_DynamicRouteConfigValidationError) Cause() error { return e.cause }
  1413  
  1414  // Key function returns key value.
  1415  func (e RoutesConfigDump_DynamicRouteConfigValidationError) Key() bool { return e.key }
  1416  
  1417  // ErrorName returns error name.
  1418  func (e RoutesConfigDump_DynamicRouteConfigValidationError) ErrorName() string {
  1419  	return "RoutesConfigDump_DynamicRouteConfigValidationError"
  1420  }
  1421  
  1422  // Error satisfies the builtin error interface
  1423  func (e RoutesConfigDump_DynamicRouteConfigValidationError) Error() string {
  1424  	cause := ""
  1425  	if e.cause != nil {
  1426  		cause = fmt.Sprintf(" | caused by: %v", e.cause)
  1427  	}
  1428  
  1429  	key := ""
  1430  	if e.key {
  1431  		key = "key for "
  1432  	}
  1433  
  1434  	return fmt.Sprintf(
  1435  		"invalid %sRoutesConfigDump_DynamicRouteConfig.%s: %s%s",
  1436  		key,
  1437  		e.field,
  1438  		e.reason,
  1439  		cause)
  1440  }
  1441  
  1442  var _ error = RoutesConfigDump_DynamicRouteConfigValidationError{}
  1443  
  1444  var _ interface {
  1445  	Field() string
  1446  	Reason() string
  1447  	Key() bool
  1448  	Cause() error
  1449  	ErrorName() string
  1450  } = RoutesConfigDump_DynamicRouteConfigValidationError{}
  1451  
  1452  // Validate checks the field values on
  1453  // ScopedRoutesConfigDump_InlineScopedRouteConfigs with the rules defined in
  1454  // the proto definition for this message. If any rules are violated, an error
  1455  // is returned.
  1456  func (m *ScopedRoutesConfigDump_InlineScopedRouteConfigs) Validate() error {
  1457  	if m == nil {
  1458  		return nil
  1459  	}
  1460  
  1461  	// no validation rules for Name
  1462  
  1463  	for idx, item := range m.GetScopedRouteConfigs() {
  1464  		_, _ = idx, item
  1465  
  1466  		if v, ok := interface{}(item).(interface{ Validate() error }); ok {
  1467  			if err := v.Validate(); err != nil {
  1468  				return ScopedRoutesConfigDump_InlineScopedRouteConfigsValidationError{
  1469  					field:  fmt.Sprintf("ScopedRouteConfigs[%v]", idx),
  1470  					reason: "embedded message failed validation",
  1471  					cause:  err,
  1472  				}
  1473  			}
  1474  		}
  1475  
  1476  	}
  1477  
  1478  	if v, ok := interface{}(m.GetLastUpdated()).(interface{ Validate() error }); ok {
  1479  		if err := v.Validate(); err != nil {
  1480  			return ScopedRoutesConfigDump_InlineScopedRouteConfigsValidationError{
  1481  				field:  "LastUpdated",
  1482  				reason: "embedded message failed validation",
  1483  				cause:  err,
  1484  			}
  1485  		}
  1486  	}
  1487  
  1488  	return nil
  1489  }
  1490  
  1491  // ScopedRoutesConfigDump_InlineScopedRouteConfigsValidationError is the
  1492  // validation error returned by
  1493  // ScopedRoutesConfigDump_InlineScopedRouteConfigs.Validate if the designated
  1494  // constraints aren't met.
  1495  type ScopedRoutesConfigDump_InlineScopedRouteConfigsValidationError struct {
  1496  	field  string
  1497  	reason string
  1498  	cause  error
  1499  	key    bool
  1500  }
  1501  
  1502  // Field function returns field value.
  1503  func (e ScopedRoutesConfigDump_InlineScopedRouteConfigsValidationError) Field() string {
  1504  	return e.field
  1505  }
  1506  
  1507  // Reason function returns reason value.
  1508  func (e ScopedRoutesConfigDump_InlineScopedRouteConfigsValidationError) Reason() string {
  1509  	return e.reason
  1510  }
  1511  
  1512  // Cause function returns cause value.
  1513  func (e ScopedRoutesConfigDump_InlineScopedRouteConfigsValidationError) Cause() error { return e.cause }
  1514  
  1515  // Key function returns key value.
  1516  func (e ScopedRoutesConfigDump_InlineScopedRouteConfigsValidationError) Key() bool { return e.key }
  1517  
  1518  // ErrorName returns error name.
  1519  func (e ScopedRoutesConfigDump_InlineScopedRouteConfigsValidationError) ErrorName() string {
  1520  	return "ScopedRoutesConfigDump_InlineScopedRouteConfigsValidationError"
  1521  }
  1522  
  1523  // Error satisfies the builtin error interface
  1524  func (e ScopedRoutesConfigDump_InlineScopedRouteConfigsValidationError) Error() string {
  1525  	cause := ""
  1526  	if e.cause != nil {
  1527  		cause = fmt.Sprintf(" | caused by: %v", e.cause)
  1528  	}
  1529  
  1530  	key := ""
  1531  	if e.key {
  1532  		key = "key for "
  1533  	}
  1534  
  1535  	return fmt.Sprintf(
  1536  		"invalid %sScopedRoutesConfigDump_InlineScopedRouteConfigs.%s: %s%s",
  1537  		key,
  1538  		e.field,
  1539  		e.reason,
  1540  		cause)
  1541  }
  1542  
  1543  var _ error = ScopedRoutesConfigDump_InlineScopedRouteConfigsValidationError{}
  1544  
  1545  var _ interface {
  1546  	Field() string
  1547  	Reason() string
  1548  	Key() bool
  1549  	Cause() error
  1550  	ErrorName() string
  1551  } = ScopedRoutesConfigDump_InlineScopedRouteConfigsValidationError{}
  1552  
  1553  // Validate checks the field values on
  1554  // ScopedRoutesConfigDump_DynamicScopedRouteConfigs with the rules defined in
  1555  // the proto definition for this message. If any rules are violated, an error
  1556  // is returned.
  1557  func (m *ScopedRoutesConfigDump_DynamicScopedRouteConfigs) Validate() error {
  1558  	if m == nil {
  1559  		return nil
  1560  	}
  1561  
  1562  	// no validation rules for Name
  1563  
  1564  	// no validation rules for VersionInfo
  1565  
  1566  	for idx, item := range m.GetScopedRouteConfigs() {
  1567  		_, _ = idx, item
  1568  
  1569  		if v, ok := interface{}(item).(interface{ Validate() error }); ok {
  1570  			if err := v.Validate(); err != nil {
  1571  				return ScopedRoutesConfigDump_DynamicScopedRouteConfigsValidationError{
  1572  					field:  fmt.Sprintf("ScopedRouteConfigs[%v]", idx),
  1573  					reason: "embedded message failed validation",
  1574  					cause:  err,
  1575  				}
  1576  			}
  1577  		}
  1578  
  1579  	}
  1580  
  1581  	if v, ok := interface{}(m.GetLastUpdated()).(interface{ Validate() error }); ok {
  1582  		if err := v.Validate(); err != nil {
  1583  			return ScopedRoutesConfigDump_DynamicScopedRouteConfigsValidationError{
  1584  				field:  "LastUpdated",
  1585  				reason: "embedded message failed validation",
  1586  				cause:  err,
  1587  			}
  1588  		}
  1589  	}
  1590  
  1591  	return nil
  1592  }
  1593  
  1594  // ScopedRoutesConfigDump_DynamicScopedRouteConfigsValidationError is the
  1595  // validation error returned by
  1596  // ScopedRoutesConfigDump_DynamicScopedRouteConfigs.Validate if the designated
  1597  // constraints aren't met.
  1598  type ScopedRoutesConfigDump_DynamicScopedRouteConfigsValidationError struct {
  1599  	field  string
  1600  	reason string
  1601  	cause  error
  1602  	key    bool
  1603  }
  1604  
  1605  // Field function returns field value.
  1606  func (e ScopedRoutesConfigDump_DynamicScopedRouteConfigsValidationError) Field() string {
  1607  	return e.field
  1608  }
  1609  
  1610  // Reason function returns reason value.
  1611  func (e ScopedRoutesConfigDump_DynamicScopedRouteConfigsValidationError) Reason() string {
  1612  	return e.reason
  1613  }
  1614  
  1615  // Cause function returns cause value.
  1616  func (e ScopedRoutesConfigDump_DynamicScopedRouteConfigsValidationError) Cause() error {
  1617  	return e.cause
  1618  }
  1619  
  1620  // Key function returns key value.
  1621  func (e ScopedRoutesConfigDump_DynamicScopedRouteConfigsValidationError) Key() bool { return e.key }
  1622  
  1623  // ErrorName returns error name.
  1624  func (e ScopedRoutesConfigDump_DynamicScopedRouteConfigsValidationError) ErrorName() string {
  1625  	return "ScopedRoutesConfigDump_DynamicScopedRouteConfigsValidationError"
  1626  }
  1627  
  1628  // Error satisfies the builtin error interface
  1629  func (e ScopedRoutesConfigDump_DynamicScopedRouteConfigsValidationError) Error() string {
  1630  	cause := ""
  1631  	if e.cause != nil {
  1632  		cause = fmt.Sprintf(" | caused by: %v", e.cause)
  1633  	}
  1634  
  1635  	key := ""
  1636  	if e.key {
  1637  		key = "key for "
  1638  	}
  1639  
  1640  	return fmt.Sprintf(
  1641  		"invalid %sScopedRoutesConfigDump_DynamicScopedRouteConfigs.%s: %s%s",
  1642  		key,
  1643  		e.field,
  1644  		e.reason,
  1645  		cause)
  1646  }
  1647  
  1648  var _ error = ScopedRoutesConfigDump_DynamicScopedRouteConfigsValidationError{}
  1649  
  1650  var _ interface {
  1651  	Field() string
  1652  	Reason() string
  1653  	Key() bool
  1654  	Cause() error
  1655  	ErrorName() string
  1656  } = ScopedRoutesConfigDump_DynamicScopedRouteConfigsValidationError{}
  1657  
  1658  // Validate checks the field values on SecretsConfigDump_DynamicSecret with the
  1659  // rules defined in the proto definition for this message. If any rules are
  1660  // violated, an error is returned.
  1661  func (m *SecretsConfigDump_DynamicSecret) Validate() error {
  1662  	if m == nil {
  1663  		return nil
  1664  	}
  1665  
  1666  	// no validation rules for Name
  1667  
  1668  	// no validation rules for VersionInfo
  1669  
  1670  	if v, ok := interface{}(m.GetLastUpdated()).(interface{ Validate() error }); ok {
  1671  		if err := v.Validate(); err != nil {
  1672  			return SecretsConfigDump_DynamicSecretValidationError{
  1673  				field:  "LastUpdated",
  1674  				reason: "embedded message failed validation",
  1675  				cause:  err,
  1676  			}
  1677  		}
  1678  	}
  1679  
  1680  	if v, ok := interface{}(m.GetSecret()).(interface{ Validate() error }); ok {
  1681  		if err := v.Validate(); err != nil {
  1682  			return SecretsConfigDump_DynamicSecretValidationError{
  1683  				field:  "Secret",
  1684  				reason: "embedded message failed validation",
  1685  				cause:  err,
  1686  			}
  1687  		}
  1688  	}
  1689  
  1690  	return nil
  1691  }
  1692  
  1693  // SecretsConfigDump_DynamicSecretValidationError is the validation error
  1694  // returned by SecretsConfigDump_DynamicSecret.Validate if the designated
  1695  // constraints aren't met.
  1696  type SecretsConfigDump_DynamicSecretValidationError struct {
  1697  	field  string
  1698  	reason string
  1699  	cause  error
  1700  	key    bool
  1701  }
  1702  
  1703  // Field function returns field value.
  1704  func (e SecretsConfigDump_DynamicSecretValidationError) Field() string { return e.field }
  1705  
  1706  // Reason function returns reason value.
  1707  func (e SecretsConfigDump_DynamicSecretValidationError) Reason() string { return e.reason }
  1708  
  1709  // Cause function returns cause value.
  1710  func (e SecretsConfigDump_DynamicSecretValidationError) Cause() error { return e.cause }
  1711  
  1712  // Key function returns key value.
  1713  func (e SecretsConfigDump_DynamicSecretValidationError) Key() bool { return e.key }
  1714  
  1715  // ErrorName returns error name.
  1716  func (e SecretsConfigDump_DynamicSecretValidationError) ErrorName() string {
  1717  	return "SecretsConfigDump_DynamicSecretValidationError"
  1718  }
  1719  
  1720  // Error satisfies the builtin error interface
  1721  func (e SecretsConfigDump_DynamicSecretValidationError) Error() string {
  1722  	cause := ""
  1723  	if e.cause != nil {
  1724  		cause = fmt.Sprintf(" | caused by: %v", e.cause)
  1725  	}
  1726  
  1727  	key := ""
  1728  	if e.key {
  1729  		key = "key for "
  1730  	}
  1731  
  1732  	return fmt.Sprintf(
  1733  		"invalid %sSecretsConfigDump_DynamicSecret.%s: %s%s",
  1734  		key,
  1735  		e.field,
  1736  		e.reason,
  1737  		cause)
  1738  }
  1739  
  1740  var _ error = SecretsConfigDump_DynamicSecretValidationError{}
  1741  
  1742  var _ interface {
  1743  	Field() string
  1744  	Reason() string
  1745  	Key() bool
  1746  	Cause() error
  1747  	ErrorName() string
  1748  } = SecretsConfigDump_DynamicSecretValidationError{}
  1749  
  1750  // Validate checks the field values on SecretsConfigDump_StaticSecret with the
  1751  // rules defined in the proto definition for this message. If any rules are
  1752  // violated, an error is returned.
  1753  func (m *SecretsConfigDump_StaticSecret) Validate() error {
  1754  	if m == nil {
  1755  		return nil
  1756  	}
  1757  
  1758  	// no validation rules for Name
  1759  
  1760  	if v, ok := interface{}(m.GetLastUpdated()).(interface{ Validate() error }); ok {
  1761  		if err := v.Validate(); err != nil {
  1762  			return SecretsConfigDump_StaticSecretValidationError{
  1763  				field:  "LastUpdated",
  1764  				reason: "embedded message failed validation",
  1765  				cause:  err,
  1766  			}
  1767  		}
  1768  	}
  1769  
  1770  	if v, ok := interface{}(m.GetSecret()).(interface{ Validate() error }); ok {
  1771  		if err := v.Validate(); err != nil {
  1772  			return SecretsConfigDump_StaticSecretValidationError{
  1773  				field:  "Secret",
  1774  				reason: "embedded message failed validation",
  1775  				cause:  err,
  1776  			}
  1777  		}
  1778  	}
  1779  
  1780  	return nil
  1781  }
  1782  
  1783  // SecretsConfigDump_StaticSecretValidationError is the validation error
  1784  // returned by SecretsConfigDump_StaticSecret.Validate if the designated
  1785  // constraints aren't met.
  1786  type SecretsConfigDump_StaticSecretValidationError struct {
  1787  	field  string
  1788  	reason string
  1789  	cause  error
  1790  	key    bool
  1791  }
  1792  
  1793  // Field function returns field value.
  1794  func (e SecretsConfigDump_StaticSecretValidationError) Field() string { return e.field }
  1795  
  1796  // Reason function returns reason value.
  1797  func (e SecretsConfigDump_StaticSecretValidationError) Reason() string { return e.reason }
  1798  
  1799  // Cause function returns cause value.
  1800  func (e SecretsConfigDump_StaticSecretValidationError) Cause() error { return e.cause }
  1801  
  1802  // Key function returns key value.
  1803  func (e SecretsConfigDump_StaticSecretValidationError) Key() bool { return e.key }
  1804  
  1805  // ErrorName returns error name.
  1806  func (e SecretsConfigDump_StaticSecretValidationError) ErrorName() string {
  1807  	return "SecretsConfigDump_StaticSecretValidationError"
  1808  }
  1809  
  1810  // Error satisfies the builtin error interface
  1811  func (e SecretsConfigDump_StaticSecretValidationError) Error() string {
  1812  	cause := ""
  1813  	if e.cause != nil {
  1814  		cause = fmt.Sprintf(" | caused by: %v", e.cause)
  1815  	}
  1816  
  1817  	key := ""
  1818  	if e.key {
  1819  		key = "key for "
  1820  	}
  1821  
  1822  	return fmt.Sprintf(
  1823  		"invalid %sSecretsConfigDump_StaticSecret.%s: %s%s",
  1824  		key,
  1825  		e.field,
  1826  		e.reason,
  1827  		cause)
  1828  }
  1829  
  1830  var _ error = SecretsConfigDump_StaticSecretValidationError{}
  1831  
  1832  var _ interface {
  1833  	Field() string
  1834  	Reason() string
  1835  	Key() bool
  1836  	Cause() error
  1837  	ErrorName() string
  1838  } = SecretsConfigDump_StaticSecretValidationError{}
  1839  

View as plain text