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

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

     1  // Code generated by protoc-gen-validate. DO NOT EDIT.
     2  // source: envoy/admin/v3/config_dump.proto
     3  
     4  package envoy_admin_v3
     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 EndpointsConfigDump with the rules
   809  // defined in the proto definition for this message. If any rules are
   810  // violated, an error is returned.
   811  func (m *EndpointsConfigDump) Validate() error {
   812  	if m == nil {
   813  		return nil
   814  	}
   815  
   816  	for idx, item := range m.GetStaticEndpointConfigs() {
   817  		_, _ = idx, item
   818  
   819  		if v, ok := interface{}(item).(interface{ Validate() error }); ok {
   820  			if err := v.Validate(); err != nil {
   821  				return EndpointsConfigDumpValidationError{
   822  					field:  fmt.Sprintf("StaticEndpointConfigs[%v]", idx),
   823  					reason: "embedded message failed validation",
   824  					cause:  err,
   825  				}
   826  			}
   827  		}
   828  
   829  	}
   830  
   831  	for idx, item := range m.GetDynamicEndpointConfigs() {
   832  		_, _ = idx, item
   833  
   834  		if v, ok := interface{}(item).(interface{ Validate() error }); ok {
   835  			if err := v.Validate(); err != nil {
   836  				return EndpointsConfigDumpValidationError{
   837  					field:  fmt.Sprintf("DynamicEndpointConfigs[%v]", idx),
   838  					reason: "embedded message failed validation",
   839  					cause:  err,
   840  				}
   841  			}
   842  		}
   843  
   844  	}
   845  
   846  	return nil
   847  }
   848  
   849  // EndpointsConfigDumpValidationError is the validation error returned by
   850  // EndpointsConfigDump.Validate if the designated constraints aren't met.
   851  type EndpointsConfigDumpValidationError struct {
   852  	field  string
   853  	reason string
   854  	cause  error
   855  	key    bool
   856  }
   857  
   858  // Field function returns field value.
   859  func (e EndpointsConfigDumpValidationError) Field() string { return e.field }
   860  
   861  // Reason function returns reason value.
   862  func (e EndpointsConfigDumpValidationError) Reason() string { return e.reason }
   863  
   864  // Cause function returns cause value.
   865  func (e EndpointsConfigDumpValidationError) Cause() error { return e.cause }
   866  
   867  // Key function returns key value.
   868  func (e EndpointsConfigDumpValidationError) Key() bool { return e.key }
   869  
   870  // ErrorName returns error name.
   871  func (e EndpointsConfigDumpValidationError) ErrorName() string {
   872  	return "EndpointsConfigDumpValidationError"
   873  }
   874  
   875  // Error satisfies the builtin error interface
   876  func (e EndpointsConfigDumpValidationError) Error() string {
   877  	cause := ""
   878  	if e.cause != nil {
   879  		cause = fmt.Sprintf(" | caused by: %v", e.cause)
   880  	}
   881  
   882  	key := ""
   883  	if e.key {
   884  		key = "key for "
   885  	}
   886  
   887  	return fmt.Sprintf(
   888  		"invalid %sEndpointsConfigDump.%s: %s%s",
   889  		key,
   890  		e.field,
   891  		e.reason,
   892  		cause)
   893  }
   894  
   895  var _ error = EndpointsConfigDumpValidationError{}
   896  
   897  var _ interface {
   898  	Field() string
   899  	Reason() string
   900  	Key() bool
   901  	Cause() error
   902  	ErrorName() string
   903  } = EndpointsConfigDumpValidationError{}
   904  
   905  // Validate checks the field values on ListenersConfigDump_StaticListener with
   906  // the rules defined in the proto definition for this message. If any rules
   907  // are violated, an error is returned.
   908  func (m *ListenersConfigDump_StaticListener) Validate() error {
   909  	if m == nil {
   910  		return nil
   911  	}
   912  
   913  	if v, ok := interface{}(m.GetListener()).(interface{ Validate() error }); ok {
   914  		if err := v.Validate(); err != nil {
   915  			return ListenersConfigDump_StaticListenerValidationError{
   916  				field:  "Listener",
   917  				reason: "embedded message failed validation",
   918  				cause:  err,
   919  			}
   920  		}
   921  	}
   922  
   923  	if v, ok := interface{}(m.GetLastUpdated()).(interface{ Validate() error }); ok {
   924  		if err := v.Validate(); err != nil {
   925  			return ListenersConfigDump_StaticListenerValidationError{
   926  				field:  "LastUpdated",
   927  				reason: "embedded message failed validation",
   928  				cause:  err,
   929  			}
   930  		}
   931  	}
   932  
   933  	return nil
   934  }
   935  
   936  // ListenersConfigDump_StaticListenerValidationError is the validation error
   937  // returned by ListenersConfigDump_StaticListener.Validate if the designated
   938  // constraints aren't met.
   939  type ListenersConfigDump_StaticListenerValidationError struct {
   940  	field  string
   941  	reason string
   942  	cause  error
   943  	key    bool
   944  }
   945  
   946  // Field function returns field value.
   947  func (e ListenersConfigDump_StaticListenerValidationError) Field() string { return e.field }
   948  
   949  // Reason function returns reason value.
   950  func (e ListenersConfigDump_StaticListenerValidationError) Reason() string { return e.reason }
   951  
   952  // Cause function returns cause value.
   953  func (e ListenersConfigDump_StaticListenerValidationError) Cause() error { return e.cause }
   954  
   955  // Key function returns key value.
   956  func (e ListenersConfigDump_StaticListenerValidationError) Key() bool { return e.key }
   957  
   958  // ErrorName returns error name.
   959  func (e ListenersConfigDump_StaticListenerValidationError) ErrorName() string {
   960  	return "ListenersConfigDump_StaticListenerValidationError"
   961  }
   962  
   963  // Error satisfies the builtin error interface
   964  func (e ListenersConfigDump_StaticListenerValidationError) Error() string {
   965  	cause := ""
   966  	if e.cause != nil {
   967  		cause = fmt.Sprintf(" | caused by: %v", e.cause)
   968  	}
   969  
   970  	key := ""
   971  	if e.key {
   972  		key = "key for "
   973  	}
   974  
   975  	return fmt.Sprintf(
   976  		"invalid %sListenersConfigDump_StaticListener.%s: %s%s",
   977  		key,
   978  		e.field,
   979  		e.reason,
   980  		cause)
   981  }
   982  
   983  var _ error = ListenersConfigDump_StaticListenerValidationError{}
   984  
   985  var _ interface {
   986  	Field() string
   987  	Reason() string
   988  	Key() bool
   989  	Cause() error
   990  	ErrorName() string
   991  } = ListenersConfigDump_StaticListenerValidationError{}
   992  
   993  // Validate checks the field values on ListenersConfigDump_DynamicListenerState
   994  // with the rules defined in the proto definition for this message. If any
   995  // rules are violated, an error is returned.
   996  func (m *ListenersConfigDump_DynamicListenerState) Validate() error {
   997  	if m == nil {
   998  		return nil
   999  	}
  1000  
  1001  	// no validation rules for VersionInfo
  1002  
  1003  	if v, ok := interface{}(m.GetListener()).(interface{ Validate() error }); ok {
  1004  		if err := v.Validate(); err != nil {
  1005  			return ListenersConfigDump_DynamicListenerStateValidationError{
  1006  				field:  "Listener",
  1007  				reason: "embedded message failed validation",
  1008  				cause:  err,
  1009  			}
  1010  		}
  1011  	}
  1012  
  1013  	if v, ok := interface{}(m.GetLastUpdated()).(interface{ Validate() error }); ok {
  1014  		if err := v.Validate(); err != nil {
  1015  			return ListenersConfigDump_DynamicListenerStateValidationError{
  1016  				field:  "LastUpdated",
  1017  				reason: "embedded message failed validation",
  1018  				cause:  err,
  1019  			}
  1020  		}
  1021  	}
  1022  
  1023  	return nil
  1024  }
  1025  
  1026  // ListenersConfigDump_DynamicListenerStateValidationError is the validation
  1027  // error returned by ListenersConfigDump_DynamicListenerState.Validate if the
  1028  // designated constraints aren't met.
  1029  type ListenersConfigDump_DynamicListenerStateValidationError struct {
  1030  	field  string
  1031  	reason string
  1032  	cause  error
  1033  	key    bool
  1034  }
  1035  
  1036  // Field function returns field value.
  1037  func (e ListenersConfigDump_DynamicListenerStateValidationError) Field() string { return e.field }
  1038  
  1039  // Reason function returns reason value.
  1040  func (e ListenersConfigDump_DynamicListenerStateValidationError) Reason() string { return e.reason }
  1041  
  1042  // Cause function returns cause value.
  1043  func (e ListenersConfigDump_DynamicListenerStateValidationError) Cause() error { return e.cause }
  1044  
  1045  // Key function returns key value.
  1046  func (e ListenersConfigDump_DynamicListenerStateValidationError) Key() bool { return e.key }
  1047  
  1048  // ErrorName returns error name.
  1049  func (e ListenersConfigDump_DynamicListenerStateValidationError) ErrorName() string {
  1050  	return "ListenersConfigDump_DynamicListenerStateValidationError"
  1051  }
  1052  
  1053  // Error satisfies the builtin error interface
  1054  func (e ListenersConfigDump_DynamicListenerStateValidationError) Error() string {
  1055  	cause := ""
  1056  	if e.cause != nil {
  1057  		cause = fmt.Sprintf(" | caused by: %v", e.cause)
  1058  	}
  1059  
  1060  	key := ""
  1061  	if e.key {
  1062  		key = "key for "
  1063  	}
  1064  
  1065  	return fmt.Sprintf(
  1066  		"invalid %sListenersConfigDump_DynamicListenerState.%s: %s%s",
  1067  		key,
  1068  		e.field,
  1069  		e.reason,
  1070  		cause)
  1071  }
  1072  
  1073  var _ error = ListenersConfigDump_DynamicListenerStateValidationError{}
  1074  
  1075  var _ interface {
  1076  	Field() string
  1077  	Reason() string
  1078  	Key() bool
  1079  	Cause() error
  1080  	ErrorName() string
  1081  } = ListenersConfigDump_DynamicListenerStateValidationError{}
  1082  
  1083  // Validate checks the field values on ListenersConfigDump_DynamicListener with
  1084  // the rules defined in the proto definition for this message. If any rules
  1085  // are violated, an error is returned.
  1086  func (m *ListenersConfigDump_DynamicListener) Validate() error {
  1087  	if m == nil {
  1088  		return nil
  1089  	}
  1090  
  1091  	// no validation rules for Name
  1092  
  1093  	if v, ok := interface{}(m.GetActiveState()).(interface{ Validate() error }); ok {
  1094  		if err := v.Validate(); err != nil {
  1095  			return ListenersConfigDump_DynamicListenerValidationError{
  1096  				field:  "ActiveState",
  1097  				reason: "embedded message failed validation",
  1098  				cause:  err,
  1099  			}
  1100  		}
  1101  	}
  1102  
  1103  	if v, ok := interface{}(m.GetWarmingState()).(interface{ Validate() error }); ok {
  1104  		if err := v.Validate(); err != nil {
  1105  			return ListenersConfigDump_DynamicListenerValidationError{
  1106  				field:  "WarmingState",
  1107  				reason: "embedded message failed validation",
  1108  				cause:  err,
  1109  			}
  1110  		}
  1111  	}
  1112  
  1113  	if v, ok := interface{}(m.GetDrainingState()).(interface{ Validate() error }); ok {
  1114  		if err := v.Validate(); err != nil {
  1115  			return ListenersConfigDump_DynamicListenerValidationError{
  1116  				field:  "DrainingState",
  1117  				reason: "embedded message failed validation",
  1118  				cause:  err,
  1119  			}
  1120  		}
  1121  	}
  1122  
  1123  	if v, ok := interface{}(m.GetErrorState()).(interface{ Validate() error }); ok {
  1124  		if err := v.Validate(); err != nil {
  1125  			return ListenersConfigDump_DynamicListenerValidationError{
  1126  				field:  "ErrorState",
  1127  				reason: "embedded message failed validation",
  1128  				cause:  err,
  1129  			}
  1130  		}
  1131  	}
  1132  
  1133  	return nil
  1134  }
  1135  
  1136  // ListenersConfigDump_DynamicListenerValidationError is the validation error
  1137  // returned by ListenersConfigDump_DynamicListener.Validate if the designated
  1138  // constraints aren't met.
  1139  type ListenersConfigDump_DynamicListenerValidationError struct {
  1140  	field  string
  1141  	reason string
  1142  	cause  error
  1143  	key    bool
  1144  }
  1145  
  1146  // Field function returns field value.
  1147  func (e ListenersConfigDump_DynamicListenerValidationError) Field() string { return e.field }
  1148  
  1149  // Reason function returns reason value.
  1150  func (e ListenersConfigDump_DynamicListenerValidationError) Reason() string { return e.reason }
  1151  
  1152  // Cause function returns cause value.
  1153  func (e ListenersConfigDump_DynamicListenerValidationError) Cause() error { return e.cause }
  1154  
  1155  // Key function returns key value.
  1156  func (e ListenersConfigDump_DynamicListenerValidationError) Key() bool { return e.key }
  1157  
  1158  // ErrorName returns error name.
  1159  func (e ListenersConfigDump_DynamicListenerValidationError) ErrorName() string {
  1160  	return "ListenersConfigDump_DynamicListenerValidationError"
  1161  }
  1162  
  1163  // Error satisfies the builtin error interface
  1164  func (e ListenersConfigDump_DynamicListenerValidationError) Error() string {
  1165  	cause := ""
  1166  	if e.cause != nil {
  1167  		cause = fmt.Sprintf(" | caused by: %v", e.cause)
  1168  	}
  1169  
  1170  	key := ""
  1171  	if e.key {
  1172  		key = "key for "
  1173  	}
  1174  
  1175  	return fmt.Sprintf(
  1176  		"invalid %sListenersConfigDump_DynamicListener.%s: %s%s",
  1177  		key,
  1178  		e.field,
  1179  		e.reason,
  1180  		cause)
  1181  }
  1182  
  1183  var _ error = ListenersConfigDump_DynamicListenerValidationError{}
  1184  
  1185  var _ interface {
  1186  	Field() string
  1187  	Reason() string
  1188  	Key() bool
  1189  	Cause() error
  1190  	ErrorName() string
  1191  } = ListenersConfigDump_DynamicListenerValidationError{}
  1192  
  1193  // Validate checks the field values on ClustersConfigDump_StaticCluster with
  1194  // the rules defined in the proto definition for this message. If any rules
  1195  // are violated, an error is returned.
  1196  func (m *ClustersConfigDump_StaticCluster) Validate() error {
  1197  	if m == nil {
  1198  		return nil
  1199  	}
  1200  
  1201  	if v, ok := interface{}(m.GetCluster()).(interface{ Validate() error }); ok {
  1202  		if err := v.Validate(); err != nil {
  1203  			return ClustersConfigDump_StaticClusterValidationError{
  1204  				field:  "Cluster",
  1205  				reason: "embedded message failed validation",
  1206  				cause:  err,
  1207  			}
  1208  		}
  1209  	}
  1210  
  1211  	if v, ok := interface{}(m.GetLastUpdated()).(interface{ Validate() error }); ok {
  1212  		if err := v.Validate(); err != nil {
  1213  			return ClustersConfigDump_StaticClusterValidationError{
  1214  				field:  "LastUpdated",
  1215  				reason: "embedded message failed validation",
  1216  				cause:  err,
  1217  			}
  1218  		}
  1219  	}
  1220  
  1221  	return nil
  1222  }
  1223  
  1224  // ClustersConfigDump_StaticClusterValidationError is the validation error
  1225  // returned by ClustersConfigDump_StaticCluster.Validate if the designated
  1226  // constraints aren't met.
  1227  type ClustersConfigDump_StaticClusterValidationError struct {
  1228  	field  string
  1229  	reason string
  1230  	cause  error
  1231  	key    bool
  1232  }
  1233  
  1234  // Field function returns field value.
  1235  func (e ClustersConfigDump_StaticClusterValidationError) Field() string { return e.field }
  1236  
  1237  // Reason function returns reason value.
  1238  func (e ClustersConfigDump_StaticClusterValidationError) Reason() string { return e.reason }
  1239  
  1240  // Cause function returns cause value.
  1241  func (e ClustersConfigDump_StaticClusterValidationError) Cause() error { return e.cause }
  1242  
  1243  // Key function returns key value.
  1244  func (e ClustersConfigDump_StaticClusterValidationError) Key() bool { return e.key }
  1245  
  1246  // ErrorName returns error name.
  1247  func (e ClustersConfigDump_StaticClusterValidationError) ErrorName() string {
  1248  	return "ClustersConfigDump_StaticClusterValidationError"
  1249  }
  1250  
  1251  // Error satisfies the builtin error interface
  1252  func (e ClustersConfigDump_StaticClusterValidationError) Error() string {
  1253  	cause := ""
  1254  	if e.cause != nil {
  1255  		cause = fmt.Sprintf(" | caused by: %v", e.cause)
  1256  	}
  1257  
  1258  	key := ""
  1259  	if e.key {
  1260  		key = "key for "
  1261  	}
  1262  
  1263  	return fmt.Sprintf(
  1264  		"invalid %sClustersConfigDump_StaticCluster.%s: %s%s",
  1265  		key,
  1266  		e.field,
  1267  		e.reason,
  1268  		cause)
  1269  }
  1270  
  1271  var _ error = ClustersConfigDump_StaticClusterValidationError{}
  1272  
  1273  var _ interface {
  1274  	Field() string
  1275  	Reason() string
  1276  	Key() bool
  1277  	Cause() error
  1278  	ErrorName() string
  1279  } = ClustersConfigDump_StaticClusterValidationError{}
  1280  
  1281  // Validate checks the field values on ClustersConfigDump_DynamicCluster with
  1282  // the rules defined in the proto definition for this message. If any rules
  1283  // are violated, an error is returned.
  1284  func (m *ClustersConfigDump_DynamicCluster) Validate() error {
  1285  	if m == nil {
  1286  		return nil
  1287  	}
  1288  
  1289  	// no validation rules for VersionInfo
  1290  
  1291  	if v, ok := interface{}(m.GetCluster()).(interface{ Validate() error }); ok {
  1292  		if err := v.Validate(); err != nil {
  1293  			return ClustersConfigDump_DynamicClusterValidationError{
  1294  				field:  "Cluster",
  1295  				reason: "embedded message failed validation",
  1296  				cause:  err,
  1297  			}
  1298  		}
  1299  	}
  1300  
  1301  	if v, ok := interface{}(m.GetLastUpdated()).(interface{ Validate() error }); ok {
  1302  		if err := v.Validate(); err != nil {
  1303  			return ClustersConfigDump_DynamicClusterValidationError{
  1304  				field:  "LastUpdated",
  1305  				reason: "embedded message failed validation",
  1306  				cause:  err,
  1307  			}
  1308  		}
  1309  	}
  1310  
  1311  	return nil
  1312  }
  1313  
  1314  // ClustersConfigDump_DynamicClusterValidationError is the validation error
  1315  // returned by ClustersConfigDump_DynamicCluster.Validate if the designated
  1316  // constraints aren't met.
  1317  type ClustersConfigDump_DynamicClusterValidationError struct {
  1318  	field  string
  1319  	reason string
  1320  	cause  error
  1321  	key    bool
  1322  }
  1323  
  1324  // Field function returns field value.
  1325  func (e ClustersConfigDump_DynamicClusterValidationError) Field() string { return e.field }
  1326  
  1327  // Reason function returns reason value.
  1328  func (e ClustersConfigDump_DynamicClusterValidationError) Reason() string { return e.reason }
  1329  
  1330  // Cause function returns cause value.
  1331  func (e ClustersConfigDump_DynamicClusterValidationError) Cause() error { return e.cause }
  1332  
  1333  // Key function returns key value.
  1334  func (e ClustersConfigDump_DynamicClusterValidationError) Key() bool { return e.key }
  1335  
  1336  // ErrorName returns error name.
  1337  func (e ClustersConfigDump_DynamicClusterValidationError) ErrorName() string {
  1338  	return "ClustersConfigDump_DynamicClusterValidationError"
  1339  }
  1340  
  1341  // Error satisfies the builtin error interface
  1342  func (e ClustersConfigDump_DynamicClusterValidationError) Error() string {
  1343  	cause := ""
  1344  	if e.cause != nil {
  1345  		cause = fmt.Sprintf(" | caused by: %v", e.cause)
  1346  	}
  1347  
  1348  	key := ""
  1349  	if e.key {
  1350  		key = "key for "
  1351  	}
  1352  
  1353  	return fmt.Sprintf(
  1354  		"invalid %sClustersConfigDump_DynamicCluster.%s: %s%s",
  1355  		key,
  1356  		e.field,
  1357  		e.reason,
  1358  		cause)
  1359  }
  1360  
  1361  var _ error = ClustersConfigDump_DynamicClusterValidationError{}
  1362  
  1363  var _ interface {
  1364  	Field() string
  1365  	Reason() string
  1366  	Key() bool
  1367  	Cause() error
  1368  	ErrorName() string
  1369  } = ClustersConfigDump_DynamicClusterValidationError{}
  1370  
  1371  // Validate checks the field values on RoutesConfigDump_StaticRouteConfig with
  1372  // the rules defined in the proto definition for this message. If any rules
  1373  // are violated, an error is returned.
  1374  func (m *RoutesConfigDump_StaticRouteConfig) Validate() error {
  1375  	if m == nil {
  1376  		return nil
  1377  	}
  1378  
  1379  	if v, ok := interface{}(m.GetRouteConfig()).(interface{ Validate() error }); ok {
  1380  		if err := v.Validate(); err != nil {
  1381  			return RoutesConfigDump_StaticRouteConfigValidationError{
  1382  				field:  "RouteConfig",
  1383  				reason: "embedded message failed validation",
  1384  				cause:  err,
  1385  			}
  1386  		}
  1387  	}
  1388  
  1389  	if v, ok := interface{}(m.GetLastUpdated()).(interface{ Validate() error }); ok {
  1390  		if err := v.Validate(); err != nil {
  1391  			return RoutesConfigDump_StaticRouteConfigValidationError{
  1392  				field:  "LastUpdated",
  1393  				reason: "embedded message failed validation",
  1394  				cause:  err,
  1395  			}
  1396  		}
  1397  	}
  1398  
  1399  	return nil
  1400  }
  1401  
  1402  // RoutesConfigDump_StaticRouteConfigValidationError is the validation error
  1403  // returned by RoutesConfigDump_StaticRouteConfig.Validate if the designated
  1404  // constraints aren't met.
  1405  type RoutesConfigDump_StaticRouteConfigValidationError struct {
  1406  	field  string
  1407  	reason string
  1408  	cause  error
  1409  	key    bool
  1410  }
  1411  
  1412  // Field function returns field value.
  1413  func (e RoutesConfigDump_StaticRouteConfigValidationError) Field() string { return e.field }
  1414  
  1415  // Reason function returns reason value.
  1416  func (e RoutesConfigDump_StaticRouteConfigValidationError) Reason() string { return e.reason }
  1417  
  1418  // Cause function returns cause value.
  1419  func (e RoutesConfigDump_StaticRouteConfigValidationError) Cause() error { return e.cause }
  1420  
  1421  // Key function returns key value.
  1422  func (e RoutesConfigDump_StaticRouteConfigValidationError) Key() bool { return e.key }
  1423  
  1424  // ErrorName returns error name.
  1425  func (e RoutesConfigDump_StaticRouteConfigValidationError) ErrorName() string {
  1426  	return "RoutesConfigDump_StaticRouteConfigValidationError"
  1427  }
  1428  
  1429  // Error satisfies the builtin error interface
  1430  func (e RoutesConfigDump_StaticRouteConfigValidationError) Error() string {
  1431  	cause := ""
  1432  	if e.cause != nil {
  1433  		cause = fmt.Sprintf(" | caused by: %v", e.cause)
  1434  	}
  1435  
  1436  	key := ""
  1437  	if e.key {
  1438  		key = "key for "
  1439  	}
  1440  
  1441  	return fmt.Sprintf(
  1442  		"invalid %sRoutesConfigDump_StaticRouteConfig.%s: %s%s",
  1443  		key,
  1444  		e.field,
  1445  		e.reason,
  1446  		cause)
  1447  }
  1448  
  1449  var _ error = RoutesConfigDump_StaticRouteConfigValidationError{}
  1450  
  1451  var _ interface {
  1452  	Field() string
  1453  	Reason() string
  1454  	Key() bool
  1455  	Cause() error
  1456  	ErrorName() string
  1457  } = RoutesConfigDump_StaticRouteConfigValidationError{}
  1458  
  1459  // Validate checks the field values on RoutesConfigDump_DynamicRouteConfig with
  1460  // the rules defined in the proto definition for this message. If any rules
  1461  // are violated, an error is returned.
  1462  func (m *RoutesConfigDump_DynamicRouteConfig) Validate() error {
  1463  	if m == nil {
  1464  		return nil
  1465  	}
  1466  
  1467  	// no validation rules for VersionInfo
  1468  
  1469  	if v, ok := interface{}(m.GetRouteConfig()).(interface{ Validate() error }); ok {
  1470  		if err := v.Validate(); err != nil {
  1471  			return RoutesConfigDump_DynamicRouteConfigValidationError{
  1472  				field:  "RouteConfig",
  1473  				reason: "embedded message failed validation",
  1474  				cause:  err,
  1475  			}
  1476  		}
  1477  	}
  1478  
  1479  	if v, ok := interface{}(m.GetLastUpdated()).(interface{ Validate() error }); ok {
  1480  		if err := v.Validate(); err != nil {
  1481  			return RoutesConfigDump_DynamicRouteConfigValidationError{
  1482  				field:  "LastUpdated",
  1483  				reason: "embedded message failed validation",
  1484  				cause:  err,
  1485  			}
  1486  		}
  1487  	}
  1488  
  1489  	return nil
  1490  }
  1491  
  1492  // RoutesConfigDump_DynamicRouteConfigValidationError is the validation error
  1493  // returned by RoutesConfigDump_DynamicRouteConfig.Validate if the designated
  1494  // constraints aren't met.
  1495  type RoutesConfigDump_DynamicRouteConfigValidationError struct {
  1496  	field  string
  1497  	reason string
  1498  	cause  error
  1499  	key    bool
  1500  }
  1501  
  1502  // Field function returns field value.
  1503  func (e RoutesConfigDump_DynamicRouteConfigValidationError) Field() string { return e.field }
  1504  
  1505  // Reason function returns reason value.
  1506  func (e RoutesConfigDump_DynamicRouteConfigValidationError) Reason() string { return e.reason }
  1507  
  1508  // Cause function returns cause value.
  1509  func (e RoutesConfigDump_DynamicRouteConfigValidationError) Cause() error { return e.cause }
  1510  
  1511  // Key function returns key value.
  1512  func (e RoutesConfigDump_DynamicRouteConfigValidationError) Key() bool { return e.key }
  1513  
  1514  // ErrorName returns error name.
  1515  func (e RoutesConfigDump_DynamicRouteConfigValidationError) ErrorName() string {
  1516  	return "RoutesConfigDump_DynamicRouteConfigValidationError"
  1517  }
  1518  
  1519  // Error satisfies the builtin error interface
  1520  func (e RoutesConfigDump_DynamicRouteConfigValidationError) Error() string {
  1521  	cause := ""
  1522  	if e.cause != nil {
  1523  		cause = fmt.Sprintf(" | caused by: %v", e.cause)
  1524  	}
  1525  
  1526  	key := ""
  1527  	if e.key {
  1528  		key = "key for "
  1529  	}
  1530  
  1531  	return fmt.Sprintf(
  1532  		"invalid %sRoutesConfigDump_DynamicRouteConfig.%s: %s%s",
  1533  		key,
  1534  		e.field,
  1535  		e.reason,
  1536  		cause)
  1537  }
  1538  
  1539  var _ error = RoutesConfigDump_DynamicRouteConfigValidationError{}
  1540  
  1541  var _ interface {
  1542  	Field() string
  1543  	Reason() string
  1544  	Key() bool
  1545  	Cause() error
  1546  	ErrorName() string
  1547  } = RoutesConfigDump_DynamicRouteConfigValidationError{}
  1548  
  1549  // Validate checks the field values on
  1550  // ScopedRoutesConfigDump_InlineScopedRouteConfigs with the rules defined in
  1551  // the proto definition for this message. If any rules are violated, an error
  1552  // is returned.
  1553  func (m *ScopedRoutesConfigDump_InlineScopedRouteConfigs) Validate() error {
  1554  	if m == nil {
  1555  		return nil
  1556  	}
  1557  
  1558  	// no validation rules for Name
  1559  
  1560  	for idx, item := range m.GetScopedRouteConfigs() {
  1561  		_, _ = idx, item
  1562  
  1563  		if v, ok := interface{}(item).(interface{ Validate() error }); ok {
  1564  			if err := v.Validate(); err != nil {
  1565  				return ScopedRoutesConfigDump_InlineScopedRouteConfigsValidationError{
  1566  					field:  fmt.Sprintf("ScopedRouteConfigs[%v]", idx),
  1567  					reason: "embedded message failed validation",
  1568  					cause:  err,
  1569  				}
  1570  			}
  1571  		}
  1572  
  1573  	}
  1574  
  1575  	if v, ok := interface{}(m.GetLastUpdated()).(interface{ Validate() error }); ok {
  1576  		if err := v.Validate(); err != nil {
  1577  			return ScopedRoutesConfigDump_InlineScopedRouteConfigsValidationError{
  1578  				field:  "LastUpdated",
  1579  				reason: "embedded message failed validation",
  1580  				cause:  err,
  1581  			}
  1582  		}
  1583  	}
  1584  
  1585  	return nil
  1586  }
  1587  
  1588  // ScopedRoutesConfigDump_InlineScopedRouteConfigsValidationError is the
  1589  // validation error returned by
  1590  // ScopedRoutesConfigDump_InlineScopedRouteConfigs.Validate if the designated
  1591  // constraints aren't met.
  1592  type ScopedRoutesConfigDump_InlineScopedRouteConfigsValidationError struct {
  1593  	field  string
  1594  	reason string
  1595  	cause  error
  1596  	key    bool
  1597  }
  1598  
  1599  // Field function returns field value.
  1600  func (e ScopedRoutesConfigDump_InlineScopedRouteConfigsValidationError) Field() string {
  1601  	return e.field
  1602  }
  1603  
  1604  // Reason function returns reason value.
  1605  func (e ScopedRoutesConfigDump_InlineScopedRouteConfigsValidationError) Reason() string {
  1606  	return e.reason
  1607  }
  1608  
  1609  // Cause function returns cause value.
  1610  func (e ScopedRoutesConfigDump_InlineScopedRouteConfigsValidationError) Cause() error { return e.cause }
  1611  
  1612  // Key function returns key value.
  1613  func (e ScopedRoutesConfigDump_InlineScopedRouteConfigsValidationError) Key() bool { return e.key }
  1614  
  1615  // ErrorName returns error name.
  1616  func (e ScopedRoutesConfigDump_InlineScopedRouteConfigsValidationError) ErrorName() string {
  1617  	return "ScopedRoutesConfigDump_InlineScopedRouteConfigsValidationError"
  1618  }
  1619  
  1620  // Error satisfies the builtin error interface
  1621  func (e ScopedRoutesConfigDump_InlineScopedRouteConfigsValidationError) Error() string {
  1622  	cause := ""
  1623  	if e.cause != nil {
  1624  		cause = fmt.Sprintf(" | caused by: %v", e.cause)
  1625  	}
  1626  
  1627  	key := ""
  1628  	if e.key {
  1629  		key = "key for "
  1630  	}
  1631  
  1632  	return fmt.Sprintf(
  1633  		"invalid %sScopedRoutesConfigDump_InlineScopedRouteConfigs.%s: %s%s",
  1634  		key,
  1635  		e.field,
  1636  		e.reason,
  1637  		cause)
  1638  }
  1639  
  1640  var _ error = ScopedRoutesConfigDump_InlineScopedRouteConfigsValidationError{}
  1641  
  1642  var _ interface {
  1643  	Field() string
  1644  	Reason() string
  1645  	Key() bool
  1646  	Cause() error
  1647  	ErrorName() string
  1648  } = ScopedRoutesConfigDump_InlineScopedRouteConfigsValidationError{}
  1649  
  1650  // Validate checks the field values on
  1651  // ScopedRoutesConfigDump_DynamicScopedRouteConfigs with the rules defined in
  1652  // the proto definition for this message. If any rules are violated, an error
  1653  // is returned.
  1654  func (m *ScopedRoutesConfigDump_DynamicScopedRouteConfigs) Validate() error {
  1655  	if m == nil {
  1656  		return nil
  1657  	}
  1658  
  1659  	// no validation rules for Name
  1660  
  1661  	// no validation rules for VersionInfo
  1662  
  1663  	for idx, item := range m.GetScopedRouteConfigs() {
  1664  		_, _ = idx, item
  1665  
  1666  		if v, ok := interface{}(item).(interface{ Validate() error }); ok {
  1667  			if err := v.Validate(); err != nil {
  1668  				return ScopedRoutesConfigDump_DynamicScopedRouteConfigsValidationError{
  1669  					field:  fmt.Sprintf("ScopedRouteConfigs[%v]", idx),
  1670  					reason: "embedded message failed validation",
  1671  					cause:  err,
  1672  				}
  1673  			}
  1674  		}
  1675  
  1676  	}
  1677  
  1678  	if v, ok := interface{}(m.GetLastUpdated()).(interface{ Validate() error }); ok {
  1679  		if err := v.Validate(); err != nil {
  1680  			return ScopedRoutesConfigDump_DynamicScopedRouteConfigsValidationError{
  1681  				field:  "LastUpdated",
  1682  				reason: "embedded message failed validation",
  1683  				cause:  err,
  1684  			}
  1685  		}
  1686  	}
  1687  
  1688  	return nil
  1689  }
  1690  
  1691  // ScopedRoutesConfigDump_DynamicScopedRouteConfigsValidationError is the
  1692  // validation error returned by
  1693  // ScopedRoutesConfigDump_DynamicScopedRouteConfigs.Validate if the designated
  1694  // constraints aren't met.
  1695  type ScopedRoutesConfigDump_DynamicScopedRouteConfigsValidationError struct {
  1696  	field  string
  1697  	reason string
  1698  	cause  error
  1699  	key    bool
  1700  }
  1701  
  1702  // Field function returns field value.
  1703  func (e ScopedRoutesConfigDump_DynamicScopedRouteConfigsValidationError) Field() string {
  1704  	return e.field
  1705  }
  1706  
  1707  // Reason function returns reason value.
  1708  func (e ScopedRoutesConfigDump_DynamicScopedRouteConfigsValidationError) Reason() string {
  1709  	return e.reason
  1710  }
  1711  
  1712  // Cause function returns cause value.
  1713  func (e ScopedRoutesConfigDump_DynamicScopedRouteConfigsValidationError) Cause() error {
  1714  	return e.cause
  1715  }
  1716  
  1717  // Key function returns key value.
  1718  func (e ScopedRoutesConfigDump_DynamicScopedRouteConfigsValidationError) Key() bool { return e.key }
  1719  
  1720  // ErrorName returns error name.
  1721  func (e ScopedRoutesConfigDump_DynamicScopedRouteConfigsValidationError) ErrorName() string {
  1722  	return "ScopedRoutesConfigDump_DynamicScopedRouteConfigsValidationError"
  1723  }
  1724  
  1725  // Error satisfies the builtin error interface
  1726  func (e ScopedRoutesConfigDump_DynamicScopedRouteConfigsValidationError) Error() string {
  1727  	cause := ""
  1728  	if e.cause != nil {
  1729  		cause = fmt.Sprintf(" | caused by: %v", e.cause)
  1730  	}
  1731  
  1732  	key := ""
  1733  	if e.key {
  1734  		key = "key for "
  1735  	}
  1736  
  1737  	return fmt.Sprintf(
  1738  		"invalid %sScopedRoutesConfigDump_DynamicScopedRouteConfigs.%s: %s%s",
  1739  		key,
  1740  		e.field,
  1741  		e.reason,
  1742  		cause)
  1743  }
  1744  
  1745  var _ error = ScopedRoutesConfigDump_DynamicScopedRouteConfigsValidationError{}
  1746  
  1747  var _ interface {
  1748  	Field() string
  1749  	Reason() string
  1750  	Key() bool
  1751  	Cause() error
  1752  	ErrorName() string
  1753  } = ScopedRoutesConfigDump_DynamicScopedRouteConfigsValidationError{}
  1754  
  1755  // Validate checks the field values on SecretsConfigDump_DynamicSecret with the
  1756  // rules defined in the proto definition for this message. If any rules are
  1757  // violated, an error is returned.
  1758  func (m *SecretsConfigDump_DynamicSecret) Validate() error {
  1759  	if m == nil {
  1760  		return nil
  1761  	}
  1762  
  1763  	// no validation rules for Name
  1764  
  1765  	// no validation rules for VersionInfo
  1766  
  1767  	if v, ok := interface{}(m.GetLastUpdated()).(interface{ Validate() error }); ok {
  1768  		if err := v.Validate(); err != nil {
  1769  			return SecretsConfigDump_DynamicSecretValidationError{
  1770  				field:  "LastUpdated",
  1771  				reason: "embedded message failed validation",
  1772  				cause:  err,
  1773  			}
  1774  		}
  1775  	}
  1776  
  1777  	if v, ok := interface{}(m.GetSecret()).(interface{ Validate() error }); ok {
  1778  		if err := v.Validate(); err != nil {
  1779  			return SecretsConfigDump_DynamicSecretValidationError{
  1780  				field:  "Secret",
  1781  				reason: "embedded message failed validation",
  1782  				cause:  err,
  1783  			}
  1784  		}
  1785  	}
  1786  
  1787  	return nil
  1788  }
  1789  
  1790  // SecretsConfigDump_DynamicSecretValidationError is the validation error
  1791  // returned by SecretsConfigDump_DynamicSecret.Validate if the designated
  1792  // constraints aren't met.
  1793  type SecretsConfigDump_DynamicSecretValidationError struct {
  1794  	field  string
  1795  	reason string
  1796  	cause  error
  1797  	key    bool
  1798  }
  1799  
  1800  // Field function returns field value.
  1801  func (e SecretsConfigDump_DynamicSecretValidationError) Field() string { return e.field }
  1802  
  1803  // Reason function returns reason value.
  1804  func (e SecretsConfigDump_DynamicSecretValidationError) Reason() string { return e.reason }
  1805  
  1806  // Cause function returns cause value.
  1807  func (e SecretsConfigDump_DynamicSecretValidationError) Cause() error { return e.cause }
  1808  
  1809  // Key function returns key value.
  1810  func (e SecretsConfigDump_DynamicSecretValidationError) Key() bool { return e.key }
  1811  
  1812  // ErrorName returns error name.
  1813  func (e SecretsConfigDump_DynamicSecretValidationError) ErrorName() string {
  1814  	return "SecretsConfigDump_DynamicSecretValidationError"
  1815  }
  1816  
  1817  // Error satisfies the builtin error interface
  1818  func (e SecretsConfigDump_DynamicSecretValidationError) Error() string {
  1819  	cause := ""
  1820  	if e.cause != nil {
  1821  		cause = fmt.Sprintf(" | caused by: %v", e.cause)
  1822  	}
  1823  
  1824  	key := ""
  1825  	if e.key {
  1826  		key = "key for "
  1827  	}
  1828  
  1829  	return fmt.Sprintf(
  1830  		"invalid %sSecretsConfigDump_DynamicSecret.%s: %s%s",
  1831  		key,
  1832  		e.field,
  1833  		e.reason,
  1834  		cause)
  1835  }
  1836  
  1837  var _ error = SecretsConfigDump_DynamicSecretValidationError{}
  1838  
  1839  var _ interface {
  1840  	Field() string
  1841  	Reason() string
  1842  	Key() bool
  1843  	Cause() error
  1844  	ErrorName() string
  1845  } = SecretsConfigDump_DynamicSecretValidationError{}
  1846  
  1847  // Validate checks the field values on SecretsConfigDump_StaticSecret with the
  1848  // rules defined in the proto definition for this message. If any rules are
  1849  // violated, an error is returned.
  1850  func (m *SecretsConfigDump_StaticSecret) Validate() error {
  1851  	if m == nil {
  1852  		return nil
  1853  	}
  1854  
  1855  	// no validation rules for Name
  1856  
  1857  	if v, ok := interface{}(m.GetLastUpdated()).(interface{ Validate() error }); ok {
  1858  		if err := v.Validate(); err != nil {
  1859  			return SecretsConfigDump_StaticSecretValidationError{
  1860  				field:  "LastUpdated",
  1861  				reason: "embedded message failed validation",
  1862  				cause:  err,
  1863  			}
  1864  		}
  1865  	}
  1866  
  1867  	if v, ok := interface{}(m.GetSecret()).(interface{ Validate() error }); ok {
  1868  		if err := v.Validate(); err != nil {
  1869  			return SecretsConfigDump_StaticSecretValidationError{
  1870  				field:  "Secret",
  1871  				reason: "embedded message failed validation",
  1872  				cause:  err,
  1873  			}
  1874  		}
  1875  	}
  1876  
  1877  	return nil
  1878  }
  1879  
  1880  // SecretsConfigDump_StaticSecretValidationError is the validation error
  1881  // returned by SecretsConfigDump_StaticSecret.Validate if the designated
  1882  // constraints aren't met.
  1883  type SecretsConfigDump_StaticSecretValidationError struct {
  1884  	field  string
  1885  	reason string
  1886  	cause  error
  1887  	key    bool
  1888  }
  1889  
  1890  // Field function returns field value.
  1891  func (e SecretsConfigDump_StaticSecretValidationError) Field() string { return e.field }
  1892  
  1893  // Reason function returns reason value.
  1894  func (e SecretsConfigDump_StaticSecretValidationError) Reason() string { return e.reason }
  1895  
  1896  // Cause function returns cause value.
  1897  func (e SecretsConfigDump_StaticSecretValidationError) Cause() error { return e.cause }
  1898  
  1899  // Key function returns key value.
  1900  func (e SecretsConfigDump_StaticSecretValidationError) Key() bool { return e.key }
  1901  
  1902  // ErrorName returns error name.
  1903  func (e SecretsConfigDump_StaticSecretValidationError) ErrorName() string {
  1904  	return "SecretsConfigDump_StaticSecretValidationError"
  1905  }
  1906  
  1907  // Error satisfies the builtin error interface
  1908  func (e SecretsConfigDump_StaticSecretValidationError) Error() string {
  1909  	cause := ""
  1910  	if e.cause != nil {
  1911  		cause = fmt.Sprintf(" | caused by: %v", e.cause)
  1912  	}
  1913  
  1914  	key := ""
  1915  	if e.key {
  1916  		key = "key for "
  1917  	}
  1918  
  1919  	return fmt.Sprintf(
  1920  		"invalid %sSecretsConfigDump_StaticSecret.%s: %s%s",
  1921  		key,
  1922  		e.field,
  1923  		e.reason,
  1924  		cause)
  1925  }
  1926  
  1927  var _ error = SecretsConfigDump_StaticSecretValidationError{}
  1928  
  1929  var _ interface {
  1930  	Field() string
  1931  	Reason() string
  1932  	Key() bool
  1933  	Cause() error
  1934  	ErrorName() string
  1935  } = SecretsConfigDump_StaticSecretValidationError{}
  1936  
  1937  // Validate checks the field values on EndpointsConfigDump_StaticEndpointConfig
  1938  // with the rules defined in the proto definition for this message. If any
  1939  // rules are violated, an error is returned.
  1940  func (m *EndpointsConfigDump_StaticEndpointConfig) Validate() error {
  1941  	if m == nil {
  1942  		return nil
  1943  	}
  1944  
  1945  	if v, ok := interface{}(m.GetEndpointConfig()).(interface{ Validate() error }); ok {
  1946  		if err := v.Validate(); err != nil {
  1947  			return EndpointsConfigDump_StaticEndpointConfigValidationError{
  1948  				field:  "EndpointConfig",
  1949  				reason: "embedded message failed validation",
  1950  				cause:  err,
  1951  			}
  1952  		}
  1953  	}
  1954  
  1955  	if v, ok := interface{}(m.GetLastUpdated()).(interface{ Validate() error }); ok {
  1956  		if err := v.Validate(); err != nil {
  1957  			return EndpointsConfigDump_StaticEndpointConfigValidationError{
  1958  				field:  "LastUpdated",
  1959  				reason: "embedded message failed validation",
  1960  				cause:  err,
  1961  			}
  1962  		}
  1963  	}
  1964  
  1965  	return nil
  1966  }
  1967  
  1968  // EndpointsConfigDump_StaticEndpointConfigValidationError is the validation
  1969  // error returned by EndpointsConfigDump_StaticEndpointConfig.Validate if the
  1970  // designated constraints aren't met.
  1971  type EndpointsConfigDump_StaticEndpointConfigValidationError struct {
  1972  	field  string
  1973  	reason string
  1974  	cause  error
  1975  	key    bool
  1976  }
  1977  
  1978  // Field function returns field value.
  1979  func (e EndpointsConfigDump_StaticEndpointConfigValidationError) Field() string { return e.field }
  1980  
  1981  // Reason function returns reason value.
  1982  func (e EndpointsConfigDump_StaticEndpointConfigValidationError) Reason() string { return e.reason }
  1983  
  1984  // Cause function returns cause value.
  1985  func (e EndpointsConfigDump_StaticEndpointConfigValidationError) Cause() error { return e.cause }
  1986  
  1987  // Key function returns key value.
  1988  func (e EndpointsConfigDump_StaticEndpointConfigValidationError) Key() bool { return e.key }
  1989  
  1990  // ErrorName returns error name.
  1991  func (e EndpointsConfigDump_StaticEndpointConfigValidationError) ErrorName() string {
  1992  	return "EndpointsConfigDump_StaticEndpointConfigValidationError"
  1993  }
  1994  
  1995  // Error satisfies the builtin error interface
  1996  func (e EndpointsConfigDump_StaticEndpointConfigValidationError) Error() string {
  1997  	cause := ""
  1998  	if e.cause != nil {
  1999  		cause = fmt.Sprintf(" | caused by: %v", e.cause)
  2000  	}
  2001  
  2002  	key := ""
  2003  	if e.key {
  2004  		key = "key for "
  2005  	}
  2006  
  2007  	return fmt.Sprintf(
  2008  		"invalid %sEndpointsConfigDump_StaticEndpointConfig.%s: %s%s",
  2009  		key,
  2010  		e.field,
  2011  		e.reason,
  2012  		cause)
  2013  }
  2014  
  2015  var _ error = EndpointsConfigDump_StaticEndpointConfigValidationError{}
  2016  
  2017  var _ interface {
  2018  	Field() string
  2019  	Reason() string
  2020  	Key() bool
  2021  	Cause() error
  2022  	ErrorName() string
  2023  } = EndpointsConfigDump_StaticEndpointConfigValidationError{}
  2024  
  2025  // Validate checks the field values on
  2026  // EndpointsConfigDump_DynamicEndpointConfig with the rules defined in the
  2027  // proto definition for this message. If any rules are violated, an error is returned.
  2028  func (m *EndpointsConfigDump_DynamicEndpointConfig) Validate() error {
  2029  	if m == nil {
  2030  		return nil
  2031  	}
  2032  
  2033  	// no validation rules for VersionInfo
  2034  
  2035  	if v, ok := interface{}(m.GetEndpointConfig()).(interface{ Validate() error }); ok {
  2036  		if err := v.Validate(); err != nil {
  2037  			return EndpointsConfigDump_DynamicEndpointConfigValidationError{
  2038  				field:  "EndpointConfig",
  2039  				reason: "embedded message failed validation",
  2040  				cause:  err,
  2041  			}
  2042  		}
  2043  	}
  2044  
  2045  	if v, ok := interface{}(m.GetLastUpdated()).(interface{ Validate() error }); ok {
  2046  		if err := v.Validate(); err != nil {
  2047  			return EndpointsConfigDump_DynamicEndpointConfigValidationError{
  2048  				field:  "LastUpdated",
  2049  				reason: "embedded message failed validation",
  2050  				cause:  err,
  2051  			}
  2052  		}
  2053  	}
  2054  
  2055  	return nil
  2056  }
  2057  
  2058  // EndpointsConfigDump_DynamicEndpointConfigValidationError is the validation
  2059  // error returned by EndpointsConfigDump_DynamicEndpointConfig.Validate if the
  2060  // designated constraints aren't met.
  2061  type EndpointsConfigDump_DynamicEndpointConfigValidationError struct {
  2062  	field  string
  2063  	reason string
  2064  	cause  error
  2065  	key    bool
  2066  }
  2067  
  2068  // Field function returns field value.
  2069  func (e EndpointsConfigDump_DynamicEndpointConfigValidationError) Field() string { return e.field }
  2070  
  2071  // Reason function returns reason value.
  2072  func (e EndpointsConfigDump_DynamicEndpointConfigValidationError) Reason() string { return e.reason }
  2073  
  2074  // Cause function returns cause value.
  2075  func (e EndpointsConfigDump_DynamicEndpointConfigValidationError) Cause() error { return e.cause }
  2076  
  2077  // Key function returns key value.
  2078  func (e EndpointsConfigDump_DynamicEndpointConfigValidationError) Key() bool { return e.key }
  2079  
  2080  // ErrorName returns error name.
  2081  func (e EndpointsConfigDump_DynamicEndpointConfigValidationError) ErrorName() string {
  2082  	return "EndpointsConfigDump_DynamicEndpointConfigValidationError"
  2083  }
  2084  
  2085  // Error satisfies the builtin error interface
  2086  func (e EndpointsConfigDump_DynamicEndpointConfigValidationError) Error() string {
  2087  	cause := ""
  2088  	if e.cause != nil {
  2089  		cause = fmt.Sprintf(" | caused by: %v", e.cause)
  2090  	}
  2091  
  2092  	key := ""
  2093  	if e.key {
  2094  		key = "key for "
  2095  	}
  2096  
  2097  	return fmt.Sprintf(
  2098  		"invalid %sEndpointsConfigDump_DynamicEndpointConfig.%s: %s%s",
  2099  		key,
  2100  		e.field,
  2101  		e.reason,
  2102  		cause)
  2103  }
  2104  
  2105  var _ error = EndpointsConfigDump_DynamicEndpointConfigValidationError{}
  2106  
  2107  var _ interface {
  2108  	Field() string
  2109  	Reason() string
  2110  	Key() bool
  2111  	Cause() error
  2112  	ErrorName() string
  2113  } = EndpointsConfigDump_DynamicEndpointConfigValidationError{}
  2114  

View as plain text