▽

Source file src/k8s.io/api/admissionregistration/v1/generated.pb.go

Documentation: k8s.io/api/admissionregistration/v1

     1  /*
     2  Copyright The Kubernetes Authors.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  // Code generated by protoc-gen-gogo. DO NOT EDIT.
    18  // source: k8s.io/api/admissionregistration/v1/generated.proto
    19  
    20  package v1
    21  
    22  import (
    23  	fmt "fmt"
    24  
    25  	io "io"
    26  
    27  	proto "github.com/gogo/protobuf/proto"
    28  	k8s_io_apimachinery_pkg_apis_meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    29  	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    30  
    31  	math "math"
    32  	math_bits "math/bits"
    33  	reflect "reflect"
    34  	strings "strings"
    35  )
    36  
    37  // Reference imports to suppress errors if they are not otherwise used.
    38  var _ = proto.Marshal
    39  var _ = fmt.Errorf
    40  var _ = math.Inf
    41  
    42  // This is a compile-time assertion to ensure that this generated file
    43  // is compatible with the proto package it is being compiled against.
    44  // A compilation error at this line likely means your copy of the
    45  // proto package needs to be updated.
    46  const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
    47  
    48  func (m *AuditAnnotation) Reset()      { *m = AuditAnnotation{} }
    49  func (*AuditAnnotation) ProtoMessage() {}
    50  func (*AuditAnnotation) Descriptor() ([]byte, []int) {
    51  	return fileDescriptor_3205c7dc5bf0c9bf, []int{0}
    52  }
    53  func (m *AuditAnnotation) XXX_Unmarshal(b []byte) error {
    54  	return m.Unmarshal(b)
    55  }
    56  func (m *AuditAnnotation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    57  	b = b[:cap(b)]
    58  	n, err := m.MarshalToSizedBuffer(b)
    59  	if err != nil {
    60  		return nil, err
    61  	}
    62  	return b[:n], nil
    63  }
    64  func (m *AuditAnnotation) XXX_Merge(src proto.Message) {
    65  	xxx_messageInfo_AuditAnnotation.Merge(m, src)
    66  }
    67  func (m *AuditAnnotation) XXX_Size() int {
    68  	return m.Size()
    69  }
    70  func (m *AuditAnnotation) XXX_DiscardUnknown() {
    71  	xxx_messageInfo_AuditAnnotation.DiscardUnknown(m)
    72  }
    73  
    74  var xxx_messageInfo_AuditAnnotation proto.InternalMessageInfo
    75  
    76  func (m *ExpressionWarning) Reset()      { *m = ExpressionWarning{} }
    77  func (*ExpressionWarning) ProtoMessage() {}
    78  func (*ExpressionWarning) Descriptor() ([]byte, []int) {
    79  	return fileDescriptor_3205c7dc5bf0c9bf, []int{1}
    80  }
    81  func (m *ExpressionWarning) XXX_Unmarshal(b []byte) error {
    82  	return m.Unmarshal(b)
    83  }
    84  func (m *ExpressionWarning) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    85  	b = b[:cap(b)]
    86  	n, err := m.MarshalToSizedBuffer(b)
    87  	if err != nil {
    88  		return nil, err
    89  	}
    90  	return b[:n], nil
    91  }
    92  func (m *ExpressionWarning) XXX_Merge(src proto.Message) {
    93  	xxx_messageInfo_ExpressionWarning.Merge(m, src)
    94  }
    95  func (m *ExpressionWarning) XXX_Size() int {
    96  	return m.Size()
    97  }
    98  func (m *ExpressionWarning) XXX_DiscardUnknown() {
    99  	xxx_messageInfo_ExpressionWarning.DiscardUnknown(m)
   100  }
   101  
   102  var xxx_messageInfo_ExpressionWarning proto.InternalMessageInfo
   103  
   104  func (m *MatchCondition) Reset()      { *m = MatchCondition{} }
   105  func (*MatchCondition) ProtoMessage() {}
   106  func (*MatchCondition) Descriptor() ([]byte, []int) {
   107  	return fileDescriptor_3205c7dc5bf0c9bf, []int{2}
   108  }
   109  func (m *MatchCondition) XXX_Unmarshal(b []byte) error {
   110  	return m.Unmarshal(b)
   111  }
   112  func (m *MatchCondition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   113  	b = b[:cap(b)]
   114  	n, err := m.MarshalToSizedBuffer(b)
   115  	if err != nil {
   116  		return nil, err
   117  	}
   118  	return b[:n], nil
   119  }
   120  func (m *MatchCondition) XXX_Merge(src proto.Message) {
   121  	xxx_messageInfo_MatchCondition.Merge(m, src)
   122  }
   123  func (m *MatchCondition) XXX_Size() int {
   124  	return m.Size()
   125  }
   126  func (m *MatchCondition) XXX_DiscardUnknown() {
   127  	xxx_messageInfo_MatchCondition.DiscardUnknown(m)
   128  }
   129  
   130  var xxx_messageInfo_MatchCondition proto.InternalMessageInfo
   131  
   132  func (m *MatchResources) Reset()      { *m = MatchResources{} }
   133  func (*MatchResources) ProtoMessage() {}
   134  func (*MatchResources) Descriptor() ([]byte, []int) {
   135  	return fileDescriptor_3205c7dc5bf0c9bf, []int{3}
   136  }
   137  func (m *MatchResources) XXX_Unmarshal(b []byte) error {
   138  	return m.Unmarshal(b)
   139  }
   140  func (m *MatchResources) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   141  	b = b[:cap(b)]
   142  	n, err := m.MarshalToSizedBuffer(b)
   143  	if err != nil {
   144  		return nil, err
   145  	}
   146  	return b[:n], nil
   147  }
   148  func (m *MatchResources) XXX_Merge(src proto.Message) {
   149  	xxx_messageInfo_MatchResources.Merge(m, src)
   150  }
   151  func (m *MatchResources) XXX_Size() int {
   152  	return m.Size()
   153  }
   154  func (m *MatchResources) XXX_DiscardUnknown() {
   155  	xxx_messageInfo_MatchResources.DiscardUnknown(m)
   156  }
   157  
   158  var xxx_messageInfo_MatchResources proto.InternalMessageInfo
   159  
   160  func (m *MutatingWebhook) Reset()      { *m = MutatingWebhook{} }
   161  func (*MutatingWebhook) ProtoMessage() {}
   162  func (*MutatingWebhook) Descriptor() ([]byte, []int) {
   163  	return fileDescriptor_3205c7dc5bf0c9bf, []int{4}
   164  }
   165  func (m *MutatingWebhook) XXX_Unmarshal(b []byte) error {
   166  	return m.Unmarshal(b)
   167  }
   168  func (m *MutatingWebhook) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   169  	b = b[:cap(b)]
   170  	n, err := m.MarshalToSizedBuffer(b)
   171  	if err != nil {
   172  		return nil, err
   173  	}
   174  	return b[:n], nil
   175  }
   176  func (m *MutatingWebhook) XXX_Merge(src proto.Message) {
   177  	xxx_messageInfo_MutatingWebhook.Merge(m, src)
   178  }
   179  func (m *MutatingWebhook) XXX_Size() int {
   180  	return m.Size()
   181  }
   182  func (m *MutatingWebhook) XXX_DiscardUnknown() {
   183  	xxx_messageInfo_MutatingWebhook.DiscardUnknown(m)
   184  }
   185  
   186  var xxx_messageInfo_MutatingWebhook proto.InternalMessageInfo
   187  
   188  func (m *MutatingWebhookConfiguration) Reset()      { *m = MutatingWebhookConfiguration{} }
   189  func (*MutatingWebhookConfiguration) ProtoMessage() {}
   190  func (*MutatingWebhookConfiguration) Descriptor() ([]byte, []int) {
   191  	return fileDescriptor_3205c7dc5bf0c9bf, []int{5}
   192  }
   193  func (m *MutatingWebhookConfiguration) XXX_Unmarshal(b []byte) error {
   194  	return m.Unmarshal(b)
   195  }
   196  func (m *MutatingWebhookConfiguration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   197  	b = b[:cap(b)]
   198  	n, err := m.MarshalToSizedBuffer(b)
   199  	if err != nil {
   200  		return nil, err
   201  	}
   202  	return b[:n], nil
   203  }
   204  func (m *MutatingWebhookConfiguration) XXX_Merge(src proto.Message) {
   205  	xxx_messageInfo_MutatingWebhookConfiguration.Merge(m, src)
   206  }
   207  func (m *MutatingWebhookConfiguration) XXX_Size() int {
   208  	return m.Size()
   209  }
   210  func (m *MutatingWebhookConfiguration) XXX_DiscardUnknown() {
   211  	xxx_messageInfo_MutatingWebhookConfiguration.DiscardUnknown(m)
   212  }
   213  
   214  var xxx_messageInfo_MutatingWebhookConfiguration proto.InternalMessageInfo
   215  
   216  func (m *MutatingWebhookConfigurationList) Reset()      { *m = MutatingWebhookConfigurationList{} }
   217  func (*MutatingWebhookConfigurationList) ProtoMessage() {}
   218  func (*MutatingWebhookConfigurationList) Descriptor() ([]byte, []int) {
   219  	return fileDescriptor_3205c7dc5bf0c9bf, []int{6}
   220  }
   221  func (m *MutatingWebhookConfigurationList) XXX_Unmarshal(b []byte) error {
   222  	return m.Unmarshal(b)
   223  }
   224  func (m *MutatingWebhookConfigurationList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   225  	b = b[:cap(b)]
   226  	n, err := m.MarshalToSizedBuffer(b)
   227  	if err != nil {
   228  		return nil, err
   229  	}
   230  	return b[:n], nil
   231  }
   232  func (m *MutatingWebhookConfigurationList) XXX_Merge(src proto.Message) {
   233  	xxx_messageInfo_MutatingWebhookConfigurationList.Merge(m, src)
   234  }
   235  func (m *MutatingWebhookConfigurationList) XXX_Size() int {
   236  	return m.Size()
   237  }
   238  func (m *MutatingWebhookConfigurationList) XXX_DiscardUnknown() {
   239  	xxx_messageInfo_MutatingWebhookConfigurationList.DiscardUnknown(m)
   240  }
   241  
   242  var xxx_messageInfo_MutatingWebhookConfigurationList proto.InternalMessageInfo
   243  
   244  func (m *NamedRuleWithOperations) Reset()      { *m = NamedRuleWithOperations{} }
   245  func (*NamedRuleWithOperations) ProtoMessage() {}
   246  func (*NamedRuleWithOperations) Descriptor() ([]byte, []int) {
   247  	return fileDescriptor_3205c7dc5bf0c9bf, []int{7}
   248  }
   249  func (m *NamedRuleWithOperations) XXX_Unmarshal(b []byte) error {
   250  	return m.Unmarshal(b)
   251  }
   252  func (m *NamedRuleWithOperations) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   253  	b = b[:cap(b)]
   254  	n, err := m.MarshalToSizedBuffer(b)
   255  	if err != nil {
   256  		return nil, err
   257  	}
   258  	return b[:n], nil
   259  }
   260  func (m *NamedRuleWithOperations) XXX_Merge(src proto.Message) {
   261  	xxx_messageInfo_NamedRuleWithOperations.Merge(m, src)
   262  }
   263  func (m *NamedRuleWithOperations) XXX_Size() int {
   264  	return m.Size()
   265  }
   266  func (m *NamedRuleWithOperations) XXX_DiscardUnknown() {
   267  	xxx_messageInfo_NamedRuleWithOperations.DiscardUnknown(m)
   268  }
   269  
   270  var xxx_messageInfo_NamedRuleWithOperations proto.InternalMessageInfo
   271  
   272  func (m *ParamKind) Reset()      { *m = ParamKind{} }
   273  func (*ParamKind) ProtoMessage() {}
   274  func (*ParamKind) Descriptor() ([]byte, []int) {
   275  	return fileDescriptor_3205c7dc5bf0c9bf, []int{8}
   276  }
   277  func (m *ParamKind) XXX_Unmarshal(b []byte) error {
   278  	return m.Unmarshal(b)
   279  }
   280  func (m *ParamKind) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   281  	b = b[:cap(b)]
   282  	n, err := m.MarshalToSizedBuffer(b)
   283  	if err != nil {
   284  		return nil, err
   285  	}
   286  	return b[:n], nil
   287  }
   288  func (m *ParamKind) XXX_Merge(src proto.Message) {
   289  	xxx_messageInfo_ParamKind.Merge(m, src)
   290  }
   291  func (m *ParamKind) XXX_Size() int {
   292  	return m.Size()
   293  }
   294  func (m *ParamKind) XXX_DiscardUnknown() {
   295  	xxx_messageInfo_ParamKind.DiscardUnknown(m)
   296  }
   297  
   298  var xxx_messageInfo_ParamKind proto.InternalMessageInfo
   299  
   300  func (m *ParamRef) Reset()      { *m = ParamRef{} }
   301  func (*ParamRef) ProtoMessage() {}
   302  func (*ParamRef) Descriptor() ([]byte, []int) {
   303  	return fileDescriptor_3205c7dc5bf0c9bf, []int{9}
   304  }
   305  func (m *ParamRef) XXX_Unmarshal(b []byte) error {
   306  	return m.Unmarshal(b)
   307  }
   308  func (m *ParamRef) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   309  	b = b[:cap(b)]
   310  	n, err := m.MarshalToSizedBuffer(b)
   311  	if err != nil {
   312  		return nil, err
   313  	}
   314  	return b[:n], nil
   315  }
   316  func (m *ParamRef) XXX_Merge(src proto.Message) {
   317  	xxx_messageInfo_ParamRef.Merge(m, src)
   318  }
   319  func (m *ParamRef) XXX_Size() int {
   320  	return m.Size()
   321  }
   322  func (m *ParamRef) XXX_DiscardUnknown() {
   323  	xxx_messageInfo_ParamRef.DiscardUnknown(m)
   324  }
   325  
   326  var xxx_messageInfo_ParamRef proto.InternalMessageInfo
   327  
   328  func (m *Rule) Reset()      { *m = Rule{} }
   329  func (*Rule) ProtoMessage() {}
   330  func (*Rule) Descriptor() ([]byte, []int) {
   331  	return fileDescriptor_3205c7dc5bf0c9bf, []int{10}
   332  }
   333  func (m *Rule) XXX_Unmarshal(b []byte) error {
   334  	return m.Unmarshal(b)
   335  }
   336  func (m *Rule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   337  	b = b[:cap(b)]
   338  	n, err := m.MarshalToSizedBuffer(b)
   339  	if err != nil {
   340  		return nil, err
   341  	}
   342  	return b[:n], nil
   343  }
   344  func (m *Rule) XXX_Merge(src proto.Message) {
   345  	xxx_messageInfo_Rule.Merge(m, src)
   346  }
   347  func (m *Rule) XXX_Size() int {
   348  	return m.Size()
   349  }
   350  func (m *Rule) XXX_DiscardUnknown() {
   351  	xxx_messageInfo_Rule.DiscardUnknown(m)
   352  }
   353  
   354  var xxx_messageInfo_Rule proto.InternalMessageInfo
   355  
   356  func (m *RuleWithOperations) Reset()      { *m = RuleWithOperations{} }
   357  func (*RuleWithOperations) ProtoMessage() {}
   358  func (*RuleWithOperations) Descriptor() ([]byte, []int) {
   359  	return fileDescriptor_3205c7dc5bf0c9bf, []int{11}
   360  }
   361  func (m *RuleWithOperations) XXX_Unmarshal(b []byte) error {
   362  	return m.Unmarshal(b)
   363  }
   364  func (m *RuleWithOperations) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   365  	b = b[:cap(b)]
   366  	n, err := m.MarshalToSizedBuffer(b)
   367  	if err != nil {
   368  		return nil, err
   369  	}
   370  	return b[:n], nil
   371  }
   372  func (m *RuleWithOperations) XXX_Merge(src proto.Message) {
   373  	xxx_messageInfo_RuleWithOperations.Merge(m, src)
   374  }
   375  func (m *RuleWithOperations) XXX_Size() int {
   376  	return m.Size()
   377  }
   378  func (m *RuleWithOperations) XXX_DiscardUnknown() {
   379  	xxx_messageInfo_RuleWithOperations.DiscardUnknown(m)
   380  }
   381  
   382  var xxx_messageInfo_RuleWithOperations proto.InternalMessageInfo
   383  
   384  func (m *ServiceReference) Reset()      { *m = ServiceReference{} }
   385  func (*ServiceReference) ProtoMessage() {}
   386  func (*ServiceReference) Descriptor() ([]byte, []int) {
   387  	return fileDescriptor_3205c7dc5bf0c9bf, []int{12}
   388  }
   389  func (m *ServiceReference) XXX_Unmarshal(b []byte) error {
   390  	return m.Unmarshal(b)
   391  }
   392  func (m *ServiceReference) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   393  	b = b[:cap(b)]
   394  	n, err := m.MarshalToSizedBuffer(b)
   395  	if err != nil {
   396  		return nil, err
   397  	}
   398  	return b[:n], nil
   399  }
   400  func (m *ServiceReference) XXX_Merge(src proto.Message) {
   401  	xxx_messageInfo_ServiceReference.Merge(m, src)
   402  }
   403  func (m *ServiceReference) XXX_Size() int {
   404  	return m.Size()
   405  }
   406  func (m *ServiceReference) XXX_DiscardUnknown() {
   407  	xxx_messageInfo_ServiceReference.DiscardUnknown(m)
   408  }
   409  
   410  var xxx_messageInfo_ServiceReference proto.InternalMessageInfo
   411  
   412  func (m *TypeChecking) Reset()      { *m = TypeChecking{} }
   413  func (*TypeChecking) ProtoMessage() {}
   414  func (*TypeChecking) Descriptor() ([]byte, []int) {
   415  	return fileDescriptor_3205c7dc5bf0c9bf, []int{13}
   416  }
   417  func (m *TypeChecking) XXX_Unmarshal(b []byte) error {
   418  	return m.Unmarshal(b)
   419  }
   420  func (m *TypeChecking) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   421  	b = b[:cap(b)]
   422  	n, err := m.MarshalToSizedBuffer(b)
   423  	if err != nil {
   424  		return nil, err
   425  	}
   426  	return b[:n], nil
   427  }
   428  func (m *TypeChecking) XXX_Merge(src proto.Message) {
   429  	xxx_messageInfo_TypeChecking.Merge(m, src)
   430  }
   431  func (m *TypeChecking) XXX_Size() int {
   432  	return m.Size()
   433  }
   434  func (m *TypeChecking) XXX_DiscardUnknown() {
   435  	xxx_messageInfo_TypeChecking.DiscardUnknown(m)
   436  }
   437  
   438  var xxx_messageInfo_TypeChecking proto.InternalMessageInfo
   439  
   440  func (m *ValidatingAdmissionPolicy) Reset()      { *m = ValidatingAdmissionPolicy{} }
   441  func (*ValidatingAdmissionPolicy) ProtoMessage() {}
   442  func (*ValidatingAdmissionPolicy) Descriptor() ([]byte, []int) {
   443  	return fileDescriptor_3205c7dc5bf0c9bf, []int{14}
   444  }
   445  func (m *ValidatingAdmissionPolicy) XXX_Unmarshal(b []byte) error {
   446  	return m.Unmarshal(b)
   447  }
   448  func (m *ValidatingAdmissionPolicy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   449  	b = b[:cap(b)]
   450  	n, err := m.MarshalToSizedBuffer(b)
   451  	if err != nil {
   452  		return nil, err
   453  	}
   454  	return b[:n], nil
   455  }
   456  func (m *ValidatingAdmissionPolicy) XXX_Merge(src proto.Message) {
   457  	xxx_messageInfo_ValidatingAdmissionPolicy.Merge(m, src)
   458  }
   459  func (m *ValidatingAdmissionPolicy) XXX_Size() int {
   460  	return m.Size()
   461  }
   462  func (m *ValidatingAdmissionPolicy) XXX_DiscardUnknown() {
   463  	xxx_messageInfo_ValidatingAdmissionPolicy.DiscardUnknown(m)
   464  }
   465  
   466  var xxx_messageInfo_ValidatingAdmissionPolicy proto.InternalMessageInfo
   467  
   468  func (m *ValidatingAdmissionPolicyBinding) Reset()      { *m = ValidatingAdmissionPolicyBinding{} }
   469  func (*ValidatingAdmissionPolicyBinding) ProtoMessage() {}
   470  func (*ValidatingAdmissionPolicyBinding) Descriptor() ([]byte, []int) {
   471  	return fileDescriptor_3205c7dc5bf0c9bf, []int{15}
   472  }
   473  func (m *ValidatingAdmissionPolicyBinding) XXX_Unmarshal(b []byte) error {
   474  	return m.Unmarshal(b)
   475  }
   476  func (m *ValidatingAdmissionPolicyBinding) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   477  	b = b[:cap(b)]
   478  	n, err := m.MarshalToSizedBuffer(b)
   479  	if err != nil {
   480  		return nil, err
   481  	}
   482  	return b[:n], nil
   483  }
   484  func (m *ValidatingAdmissionPolicyBinding) XXX_Merge(src proto.Message) {
   485  	xxx_messageInfo_ValidatingAdmissionPolicyBinding.Merge(m, src)
   486  }
   487  func (m *ValidatingAdmissionPolicyBinding) XXX_Size() int {
   488  	return m.Size()
   489  }
   490  func (m *ValidatingAdmissionPolicyBinding) XXX_DiscardUnknown() {
   491  	xxx_messageInfo_ValidatingAdmissionPolicyBinding.DiscardUnknown(m)
   492  }
   493  
   494  var xxx_messageInfo_ValidatingAdmissionPolicyBinding proto.InternalMessageInfo
   495  
   496  func (m *ValidatingAdmissionPolicyBindingList) Reset()      { *m = ValidatingAdmissionPolicyBindingList{} }
   497  func (*ValidatingAdmissionPolicyBindingList) ProtoMessage() {}
   498  func (*ValidatingAdmissionPolicyBindingList) Descriptor() ([]byte, []int) {
   499  	return fileDescriptor_3205c7dc5bf0c9bf, []int{16}
   500  }
   501  func (m *ValidatingAdmissionPolicyBindingList) XXX_Unmarshal(b []byte) error {
   502  	return m.Unmarshal(b)
   503  }
   504  func (m *ValidatingAdmissionPolicyBindingList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   505  	b = b[:cap(b)]
   506  	n, err := m.MarshalToSizedBuffer(b)
   507  	if err != nil {
   508  		return nil, err
   509  	}
   510  	return b[:n], nil
   511  }
   512  func (m *ValidatingAdmissionPolicyBindingList) XXX_Merge(src proto.Message) {
   513  	xxx_messageInfo_ValidatingAdmissionPolicyBindingList.Merge(m, src)
   514  }
   515  func (m *ValidatingAdmissionPolicyBindingList) XXX_Size() int {
   516  	return m.Size()
   517  }
   518  func (m *ValidatingAdmissionPolicyBindingList) XXX_DiscardUnknown() {
   519  	xxx_messageInfo_ValidatingAdmissionPolicyBindingList.DiscardUnknown(m)
   520  }
   521  
   522  var xxx_messageInfo_ValidatingAdmissionPolicyBindingList proto.InternalMessageInfo
   523  
   524  func (m *ValidatingAdmissionPolicyBindingSpec) Reset()      { *m = ValidatingAdmissionPolicyBindingSpec{} }
   525  func (*ValidatingAdmissionPolicyBindingSpec) ProtoMessage() {}
   526  func (*ValidatingAdmissionPolicyBindingSpec) Descriptor() ([]byte, []int) {
   527  	return fileDescriptor_3205c7dc5bf0c9bf, []int{17}
   528  }
   529  func (m *ValidatingAdmissionPolicyBindingSpec) XXX_Unmarshal(b []byte) error {
   530  	return m.Unmarshal(b)
   531  }
   532  func (m *ValidatingAdmissionPolicyBindingSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   533  	b = b[:cap(b)]
   534  	n, err := m.MarshalToSizedBuffer(b)
   535  	if err != nil {
   536  		return nil, err
   537  	}
   538  	return b[:n], nil
   539  }
   540  func (m *ValidatingAdmissionPolicyBindingSpec) XXX_Merge(src proto.Message) {
   541  	xxx_messageInfo_ValidatingAdmissionPolicyBindingSpec.Merge(m, src)
   542  }
   543  func (m *ValidatingAdmissionPolicyBindingSpec) XXX_Size() int {
   544  	return m.Size()
   545  }
   546  func (m *ValidatingAdmissionPolicyBindingSpec) XXX_DiscardUnknown() {
   547  	xxx_messageInfo_ValidatingAdmissionPolicyBindingSpec.DiscardUnknown(m)
   548  }
   549  
   550  var xxx_messageInfo_ValidatingAdmissionPolicyBindingSpec proto.InternalMessageInfo
   551  
   552  func (m *ValidatingAdmissionPolicyList) Reset()      { *m = ValidatingAdmissionPolicyList{} }
   553  func (*ValidatingAdmissionPolicyList) ProtoMessage() {}
   554  func (*ValidatingAdmissionPolicyList) Descriptor() ([]byte, []int) {
   555  	return fileDescriptor_3205c7dc5bf0c9bf, []int{18}
   556  }
   557  func (m *ValidatingAdmissionPolicyList) XXX_Unmarshal(b []byte) error {
   558  	return m.Unmarshal(b)
   559  }
   560  func (m *ValidatingAdmissionPolicyList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   561  	b = b[:cap(b)]
   562  	n, err := m.MarshalToSizedBuffer(b)
   563  	if err != nil {
   564  		return nil, err
   565  	}
   566  	return b[:n], nil
   567  }
   568  func (m *ValidatingAdmissionPolicyList) XXX_Merge(src proto.Message) {
   569  	xxx_messageInfo_ValidatingAdmissionPolicyList.Merge(m, src)
   570  }
   571  func (m *ValidatingAdmissionPolicyList) XXX_Size() int {
   572  	return m.Size()
   573  }
   574  func (m *ValidatingAdmissionPolicyList) XXX_DiscardUnknown() {
   575  	xxx_messageInfo_ValidatingAdmissionPolicyList.DiscardUnknown(m)
   576  }
   577  
   578  var xxx_messageInfo_ValidatingAdmissionPolicyList proto.InternalMessageInfo
   579  
   580  func (m *ValidatingAdmissionPolicySpec) Reset()      { *m = ValidatingAdmissionPolicySpec{} }
   581  func (*ValidatingAdmissionPolicySpec) ProtoMessage() {}
   582  func (*ValidatingAdmissionPolicySpec) Descriptor() ([]byte, []int) {
   583  	return fileDescriptor_3205c7dc5bf0c9bf, []int{19}
   584  }
   585  func (m *ValidatingAdmissionPolicySpec) XXX_Unmarshal(b []byte) error {
   586  	return m.Unmarshal(b)
   587  }
   588  func (m *ValidatingAdmissionPolicySpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   589  	b = b[:cap(b)]
   590  	n, err := m.MarshalToSizedBuffer(b)
   591  	if err != nil {
   592  		return nil, err
   593  	}
   594  	return b[:n], nil
   595  }
   596  func (m *ValidatingAdmissionPolicySpec) XXX_Merge(src proto.Message) {
   597  	xxx_messageInfo_ValidatingAdmissionPolicySpec.Merge(m, src)
   598  }
   599  func (m *ValidatingAdmissionPolicySpec) XXX_Size() int {
   600  	return m.Size()
   601  }
   602  func (m *ValidatingAdmissionPolicySpec) XXX_DiscardUnknown() {
   603  	xxx_messageInfo_ValidatingAdmissionPolicySpec.DiscardUnknown(m)
   604  }
   605  
   606  var xxx_messageInfo_ValidatingAdmissionPolicySpec proto.InternalMessageInfo
   607  
   608  func (m *ValidatingAdmissionPolicyStatus) Reset()      { *m = ValidatingAdmissionPolicyStatus{} }
   609  func (*ValidatingAdmissionPolicyStatus) ProtoMessage() {}
   610  func (*ValidatingAdmissionPolicyStatus) Descriptor() ([]byte, []int) {
   611  	return fileDescriptor_3205c7dc5bf0c9bf, []int{20}
   612  }
   613  func (m *ValidatingAdmissionPolicyStatus) XXX_Unmarshal(b []byte) error {
   614  	return m.Unmarshal(b)
   615  }
   616  func (m *ValidatingAdmissionPolicyStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   617  	b = b[:cap(b)]
   618  	n, err := m.MarshalToSizedBuffer(b)
   619  	if err != nil {
   620  		return nil, err
   621  	}
   622  	return b[:n], nil
   623  }
   624  func (m *ValidatingAdmissionPolicyStatus) XXX_Merge(src proto.Message) {
   625  	xxx_messageInfo_ValidatingAdmissionPolicyStatus.Merge(m, src)
   626  }
   627  func (m *ValidatingAdmissionPolicyStatus) XXX_Size() int {
   628  	return m.Size()
   629  }
   630  func (m *ValidatingAdmissionPolicyStatus) XXX_DiscardUnknown() {
   631  	xxx_messageInfo_ValidatingAdmissionPolicyStatus.DiscardUnknown(m)
   632  }
   633  
   634  var xxx_messageInfo_ValidatingAdmissionPolicyStatus proto.InternalMessageInfo
   635  
   636  func (m *ValidatingWebhook) Reset()      { *m = ValidatingWebhook{} }
   637  func (*ValidatingWebhook) ProtoMessage() {}
   638  func (*ValidatingWebhook) Descriptor() ([]byte, []int) {
   639  	return fileDescriptor_3205c7dc5bf0c9bf, []int{21}
   640  }
   641  func (m *ValidatingWebhook) XXX_Unmarshal(b []byte) error {
   642  	return m.Unmarshal(b)
   643  }
   644  func (m *ValidatingWebhook) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   645  	b = b[:cap(b)]
   646  	n, err := m.MarshalToSizedBuffer(b)
   647  	if err != nil {
   648  		return nil, err
   649  	}
   650  	return b[:n], nil
   651  }
   652  func (m *ValidatingWebhook) XXX_Merge(src proto.Message) {
   653  	xxx_messageInfo_ValidatingWebhook.Merge(m, src)
   654  }
   655  func (m *ValidatingWebhook) XXX_Size() int {
   656  	return m.Size()
   657  }
   658  func (m *ValidatingWebhook) XXX_DiscardUnknown() {
   659  	xxx_messageInfo_ValidatingWebhook.DiscardUnknown(m)
   660  }
   661  
   662  var xxx_messageInfo_ValidatingWebhook proto.InternalMessageInfo
   663  
   664  func (m *ValidatingWebhookConfiguration) Reset()      { *m = ValidatingWebhookConfiguration{} }
   665  func (*ValidatingWebhookConfiguration) ProtoMessage() {}
   666  func (*ValidatingWebhookConfiguration) Descriptor() ([]byte, []int) {
   667  	return fileDescriptor_3205c7dc5bf0c9bf, []int{22}
   668  }
   669  func (m *ValidatingWebhookConfiguration) XXX_Unmarshal(b []byte) error {
   670  	return m.Unmarshal(b)
   671  }
   672  func (m *ValidatingWebhookConfiguration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   673  	b = b[:cap(b)]
   674  	n, err := m.MarshalToSizedBuffer(b)
   675  	if err != nil {
   676  		return nil, err
   677  	}
   678  	return b[:n], nil
   679  }
   680  func (m *ValidatingWebhookConfiguration) XXX_Merge(src proto.Message) {
   681  	xxx_messageInfo_ValidatingWebhookConfiguration.Merge(m, src)
   682  }
   683  func (m *ValidatingWebhookConfiguration) XXX_Size() int {
   684  	return m.Size()
   685  }
   686  func (m *ValidatingWebhookConfiguration) XXX_DiscardUnknown() {
   687  	xxx_messageInfo_ValidatingWebhookConfiguration.DiscardUnknown(m)
   688  }
   689  
   690  var xxx_messageInfo_ValidatingWebhookConfiguration proto.InternalMessageInfo
   691  
   692  func (m *ValidatingWebhookConfigurationList) Reset()      { *m = ValidatingWebhookConfigurationList{} }
   693  func (*ValidatingWebhookConfigurationList) ProtoMessage() {}
   694  func (*ValidatingWebhookConfigurationList) Descriptor() ([]byte, []int) {
   695  	return fileDescriptor_3205c7dc5bf0c9bf, []int{23}
   696  }
   697  func (m *ValidatingWebhookConfigurationList) XXX_Unmarshal(b []byte) error {
   698  	return m.Unmarshal(b)
   699  }
   700  func (m *ValidatingWebhookConfigurationList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   701  	b = b[:cap(b)]
   702  	n, err := m.MarshalToSizedBuffer(b)
   703  	if err != nil {
   704  		return nil, err
   705  	}
   706  	return b[:n], nil
   707  }
   708  func (m *ValidatingWebhookConfigurationList) XXX_Merge(src proto.Message) {
   709  	xxx_messageInfo_ValidatingWebhookConfigurationList.Merge(m, src)
   710  }
   711  func (m *ValidatingWebhookConfigurationList) XXX_Size() int {
   712  	return m.Size()
   713  }
   714  func (m *ValidatingWebhookConfigurationList) XXX_DiscardUnknown() {
   715  	xxx_messageInfo_ValidatingWebhookConfigurationList.DiscardUnknown(m)
   716  }
   717  
   718  var xxx_messageInfo_ValidatingWebhookConfigurationList proto.InternalMessageInfo
   719  
   720  func (m *Validation) Reset()      { *m = Validation{} }
   721  func (*Validation) ProtoMessage() {}
   722  func (*Validation) Descriptor() ([]byte, []int) {
   723  	return fileDescriptor_3205c7dc5bf0c9bf, []int{24}
   724  }
   725  func (m *Validation) XXX_Unmarshal(b []byte) error {
   726  	return m.Unmarshal(b)
   727  }
   728  func (m *Validation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   729  	b = b[:cap(b)]
   730  	n, err := m.MarshalToSizedBuffer(b)
   731  	if err != nil {
   732  		return nil, err
   733  	}
   734  	return b[:n], nil
   735  }
   736  func (m *Validation) XXX_Merge(src proto.Message) {
   737  	xxx_messageInfo_Validation.Merge(m, src)
   738  }
   739  func (m *Validation) XXX_Size() int {
   740  	return m.Size()
   741  }
   742  func (m *Validation) XXX_DiscardUnknown() {
   743  	xxx_messageInfo_Validation.DiscardUnknown(m)
   744  }
   745  
   746  var xxx_messageInfo_Validation proto.InternalMessageInfo
   747  
   748  func (m *Variable) Reset()      { *m = Variable{} }
   749  func (*Variable) ProtoMessage() {}
   750  func (*Variable) Descriptor() ([]byte, []int) {
   751  	return fileDescriptor_3205c7dc5bf0c9bf, []int{25}
   752  }
   753  func (m *Variable) XXX_Unmarshal(b []byte) error {
   754  	return m.Unmarshal(b)
   755  }
   756  func (m *Variable) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   757  	b = b[:cap(b)]
   758  	n, err := m.MarshalToSizedBuffer(b)
   759  	if err != nil {
   760  		return nil, err
   761  	}
   762  	return b[:n], nil
   763  }
   764  func (m *Variable) XXX_Merge(src proto.Message) {
   765  	xxx_messageInfo_Variable.Merge(m, src)
   766  }
   767  func (m *Variable) XXX_Size() int {
   768  	return m.Size()
   769  }
   770  func (m *Variable) XXX_DiscardUnknown() {
   771  	xxx_messageInfo_Variable.DiscardUnknown(m)
   772  }
   773  
   774  var xxx_messageInfo_Variable proto.InternalMessageInfo
   775  
   776  func (m *WebhookClientConfig) Reset()      { *m = WebhookClientConfig{} }
   777  func (*WebhookClientConfig) ProtoMessage() {}
   778  func (*WebhookClientConfig) Descriptor() ([]byte, []int) {
   779  	return fileDescriptor_3205c7dc5bf0c9bf, []int{26}
   780  }
   781  func (m *WebhookClientConfig) XXX_Unmarshal(b []byte) error {
   782  	return m.Unmarshal(b)
   783  }
   784  func (m *WebhookClientConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   785  	b = b[:cap(b)]
   786  	n, err := m.MarshalToSizedBuffer(b)
   787  	if err != nil {
   788  		return nil, err
   789  	}
   790  	return b[:n], nil
   791  }
   792  func (m *WebhookClientConfig) XXX_Merge(src proto.Message) {
   793  	xxx_messageInfo_WebhookClientConfig.Merge(m, src)
   794  }
   795  func (m *WebhookClientConfig) XXX_Size() int {
   796  	return m.Size()
   797  }
   798  func (m *WebhookClientConfig) XXX_DiscardUnknown() {
   799  	xxx_messageInfo_WebhookClientConfig.DiscardUnknown(m)
   800  }
   801  
   802  var xxx_messageInfo_WebhookClientConfig proto.InternalMessageInfo
   803  
   804  func init() {
   805  	proto.RegisterType((*AuditAnnotation)(nil), "k8s.io.api.admissionregistration.v1.AuditAnnotation")
   806  	proto.RegisterType((*ExpressionWarning)(nil), "k8s.io.api.admissionregistration.v1.ExpressionWarning")
   807  	proto.RegisterType((*MatchCondition)(nil), "k8s.io.api.admissionregistration.v1.MatchCondition")
   808  	proto.RegisterType((*MatchResources)(nil), "k8s.io.api.admissionregistration.v1.MatchResources")
   809  	proto.RegisterType((*MutatingWebhook)(nil), "k8s.io.api.admissionregistration.v1.MutatingWebhook")
   810  	proto.RegisterType((*MutatingWebhookConfiguration)(nil), "k8s.io.api.admissionregistration.v1.MutatingWebhookConfiguration")
   811  	proto.RegisterType((*MutatingWebhookConfigurationList)(nil), "k8s.io.api.admissionregistration.v1.MutatingWebhookConfigurationList")
   812  	proto.RegisterType((*NamedRuleWithOperations)(nil), "k8s.io.api.admissionregistration.v1.NamedRuleWithOperations")
   813  	proto.RegisterType((*ParamKind)(nil), "k8s.io.api.admissionregistration.v1.ParamKind")
   814  	proto.RegisterType((*ParamRef)(nil), "k8s.io.api.admissionregistration.v1.ParamRef")
   815  	proto.RegisterType((*Rule)(nil), "k8s.io.api.admissionregistration.v1.Rule")
   816  	proto.RegisterType((*RuleWithOperations)(nil), "k8s.io.api.admissionregistration.v1.RuleWithOperations")
   817  	proto.RegisterType((*ServiceReference)(nil), "k8s.io.api.admissionregistration.v1.ServiceReference")
   818  	proto.RegisterType((*TypeChecking)(nil), "k8s.io.api.admissionregistration.v1.TypeChecking")
   819  	proto.RegisterType((*ValidatingAdmissionPolicy)(nil), "k8s.io.api.admissionregistration.v1.ValidatingAdmissionPolicy")
   820  	proto.RegisterType((*ValidatingAdmissionPolicyBinding)(nil), "k8s.io.api.admissionregistration.v1.ValidatingAdmissionPolicyBinding")
   821  	proto.RegisterType((*ValidatingAdmissionPolicyBindingList)(nil), "k8s.io.api.admissionregistration.v1.ValidatingAdmissionPolicyBindingList")
   822  	proto.RegisterType((*ValidatingAdmissionPolicyBindingSpec)(nil), "k8s.io.api.admissionregistration.v1.ValidatingAdmissionPolicyBindingSpec")
   823  	proto.RegisterType((*ValidatingAdmissionPolicyList)(nil), "k8s.io.api.admissionregistration.v1.ValidatingAdmissionPolicyList")
   824  	proto.RegisterType((*ValidatingAdmissionPolicySpec)(nil), "k8s.io.api.admissionregistration.v1.ValidatingAdmissionPolicySpec")
   825  	proto.RegisterType((*ValidatingAdmissionPolicyStatus)(nil), "k8s.io.api.admissionregistration.v1.ValidatingAdmissionPolicyStatus")
   826  	proto.RegisterType((*ValidatingWebhook)(nil), "k8s.io.api.admissionregistration.v1.ValidatingWebhook")
   827  	proto.RegisterType((*ValidatingWebhookConfiguration)(nil), "k8s.io.api.admissionregistration.v1.ValidatingWebhookConfiguration")
   828  	proto.RegisterType((*ValidatingWebhookConfigurationList)(nil), "k8s.io.api.admissionregistration.v1.ValidatingWebhookConfigurationList")
   829  	proto.RegisterType((*Validation)(nil), "k8s.io.api.admissionregistration.v1.Validation")
   830  	proto.RegisterType((*Variable)(nil), "k8s.io.api.admissionregistration.v1.Variable")
   831  	proto.RegisterType((*WebhookClientConfig)(nil), "k8s.io.api.admissionregistration.v1.WebhookClientConfig")
   832  }
   833  
   834  func init() {
   835  	proto.RegisterFile("k8s.io/api/admissionregistration/v1/generated.proto", fileDescriptor_3205c7dc5bf0c9bf)
   836  }
   837  
   838  var fileDescriptor_3205c7dc5bf0c9bf = []byte{
   839  	// 2075 bytes of a gzipped FileDescriptorProto
   840  	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5a, 0xcd, 0x6f, 0x1b, 0xc7,
   841  	0x15, 0xf7, 0x8a, 0x94, 0x44, 0x3e, 0xea, 0x8b, 0x13, 0x27, 0xa2, 0x1d, 0x87, 0x2b, 0x6c, 0x82,
   842  	0xc2, 0x46, 0x63, 0x32, 0xb2, 0x53, 0x27, 0x08, 0x8a, 0x06, 0xa2, 0xfc, 0x01, 0xc5, 0x96, 0x2d,
   843  	0x8c, 0x12, 0xa9, 0x68, 0xdd, 0x22, 0xab, 0xdd, 0x21, 0xb9, 0x11, 0xb9, 0xbb, 0xd8, 0xd9, 0x65,
   844  	0xac, 0x9e, 0x8a, 0xf6, 0x5e, 0x14, 0xe8, 0x5f, 0xd0, 0xfe, 0x09, 0xbd, 0xb4, 0x40, 0x4f, 0xbd,
   845  	0xf9, 0x52, 0x20, 0x3d, 0xd5, 0x87, 0x62, 0x51, 0xb3, 0x97, 0x1e, 0x7a, 0x68, 0xaf, 0x02, 0x8a,
   846  	0x16, 0x33, 0x3b, 0xfb, 0xc9, 0xa5, 0xb5, 0x96, 0x6d, 0xf5, 0xe2, 0x9b, 0xf6, 0x7d, 0xfc, 0xde,
   847  	0xbc, 0x37, 0x6f, 0xe6, 0xbd, 0x79, 0x14, 0x5c, 0x3f, 0xfc, 0x98, 0xb6, 0x0c, 0xab, 0xad, 0xda,
   848  	0x46, 0x5b, 0xd5, 0x87, 0x06, 0xa5, 0x86, 0x65, 0x3a, 0xa4, 0x67, 0x50, 0xd7, 0x51, 0x5d, 0xc3,
   849  	0x32, 0xdb, 0xa3, 0xf5, 0x76, 0x8f, 0x98, 0xc4, 0x51, 0x5d, 0xa2, 0xb7, 0x6c, 0xc7, 0x72, 0x2d,
   850  	0xf4, 0x6e, 0xa0, 0xd4, 0x52, 0x6d, 0xa3, 0x95, 0xab, 0xd4, 0x1a, 0xad, 0x5f, 0xbc, 0xda, 0x33,
   851  	0xdc, 0xbe, 0x77, 0xd0, 0xd2, 0xac, 0x61, 0xbb, 0x67, 0xf5, 0xac, 0x36, 0xd7, 0x3d, 0xf0, 0xba,
   852  	0xfc, 0x8b, 0x7f, 0xf0, 0xbf, 0x02, 0xcc, 0x8b, 0x1f, 0xc6, 0x0b, 0x19, 0xaa, 0x5a, 0xdf, 0x30,
   853  	0x89, 0x73, 0xd4, 0xb6, 0x0f, 0x7b, 0x8c, 0x40, 0xdb, 0x43, 0xe2, 0xaa, 0x39, 0x2b, 0xb9, 0xd8,
   854  	0x9e, 0xa6, 0xe5, 0x78, 0xa6, 0x6b, 0x0c, 0xc9, 0x84, 0xc2, 0x8d, 0x93, 0x14, 0xa8, 0xd6, 0x27,
   855  	0x43, 0x35, 0xab, 0xa7, 0x50, 0x58, 0xde, 0xf0, 0x74, 0xc3, 0xdd, 0x30, 0x4d, 0xcb, 0xe5, 0x3e,
   856  	0xa2, 0x77, 0xa0, 0x74, 0x48, 0x8e, 0x1a, 0xd2, 0x9a, 0x74, 0xb9, 0xda, 0xa9, 0x3d, 0xf6, 0xe5,
   857  	0x73, 0x63, 0x5f, 0x2e, 0xdd, 0x25, 0x47, 0x98, 0xd1, 0xd1, 0x06, 0x2c, 0x8f, 0xd4, 0x81, 0x47,
   858  	0x6e, 0x3d, 0xb2, 0x1d, 0xc2, 0x23, 0xd4, 0x98, 0xe1, 0xa2, 0xab, 0x42, 0x74, 0x79, 0x2f, 0xcd,
   859  	0xc6, 0x59, 0x79, 0x65, 0x00, 0xf5, 0xf8, 0x6b, 0x5f, 0x75, 0x4c, 0xc3, 0xec, 0xa1, 0xf7, 0xa1,
   860  	0xd2, 0x35, 0xc8, 0x40, 0xc7, 0xa4, 0x2b, 0x00, 0x57, 0x04, 0x60, 0xe5, 0xb6, 0xa0, 0xe3, 0x48,
   861  	0x02, 0x5d, 0x81, 0xf9, 0xaf, 0x03, 0xc5, 0x46, 0x89, 0x0b, 0x2f, 0x0b, 0xe1, 0x79, 0x81, 0x87,
   862  	0x43, 0xbe, 0xd2, 0x85, 0xa5, 0x6d, 0xd5, 0xd5, 0xfa, 0x9b, 0x96, 0xa9, 0x1b, 0xdc, 0xc3, 0x35,
   863  	0x28, 0x9b, 0xea, 0x90, 0x08, 0x17, 0x17, 0x84, 0x66, 0xf9, 0xbe, 0x3a, 0x24, 0x98, 0x73, 0xd0,
   864  	0x35, 0x00, 0x92, 0xf5, 0x0f, 0x09, 0x39, 0x48, 0xb8, 0x96, 0x90, 0x52, 0xfe, 0x54, 0x16, 0x86,
   865  	0x30, 0xa1, 0x96, 0xe7, 0x68, 0x84, 0xa2, 0x47, 0x50, 0x67, 0x70, 0xd4, 0x56, 0x35, 0xb2, 0x4b,
   866  	0x06, 0x44, 0x73, 0x2d, 0x87, 0x5b, 0xad, 0x5d, 0xbb, 0xde, 0x8a, 0x93, 0x2d, 0xda, 0xb1, 0x96,
   867  	0x7d, 0xd8, 0x63, 0x04, 0xda, 0x62, 0x89, 0xd1, 0x1a, 0xad, 0xb7, 0xee, 0xa9, 0x07, 0x64, 0x10,
   868  	0xaa, 0x76, 0xde, 0x1c, 0xfb, 0x72, 0xfd, 0x7e, 0x16, 0x11, 0x4f, 0x1a, 0x41, 0x16, 0x2c, 0x59,
   869  	0x07, 0x5f, 0x11, 0xcd, 0x8d, 0xcc, 0xce, 0x9c, 0xde, 0x2c, 0x1a, 0xfb, 0xf2, 0xd2, 0x83, 0x14,
   870  	0x1c, 0xce, 0xc0, 0xa3, 0x23, 0x58, 0x74, 0x84, 0xdf, 0xd8, 0x1b, 0x10, 0xda, 0x28, 0xad, 0x95,
   871  	0x2e, 0xd7, 0xae, 0x7d, 0xb7, 0x55, 0xe0, 0x4c, 0xb5, 0x98, 0x4b, 0x3a, 0x53, 0xdb, 0x37, 0xdc,
   872  	0xfe, 0x03, 0x9b, 0x04, 0x1c, 0xda, 0x79, 0x53, 0x84, 0x7c, 0x11, 0x27, 0xa1, 0x71, 0xda, 0x12,
   873  	0xfa, 0x85, 0x04, 0xe7, 0xc9, 0x23, 0x6d, 0xe0, 0xe9, 0x24, 0x25, 0xd7, 0x28, 0xbf, 0x84, 0x25,
   874  	0x5c, 0x12, 0x4b, 0x38, 0x7f, 0x2b, 0xc7, 0x02, 0xce, 0xb5, 0x8b, 0x6e, 0x42, 0x6d, 0xc8, 0x12,
   875  	0x61, 0xc7, 0x1a, 0x18, 0xda, 0x51, 0x63, 0x9e, 0xa7, 0x8f, 0x32, 0xf6, 0xe5, 0xda, 0x76, 0x4c,
   876  	0x3e, 0xf6, 0xe5, 0xe5, 0xc4, 0xe7, 0xe7, 0x47, 0x36, 0xc1, 0x49, 0x35, 0xe5, 0x77, 0x15, 0x58,
   877  	0xde, 0xf6, 0xd8, 0xa1, 0x34, 0x7b, 0xfb, 0xe4, 0xa0, 0x6f, 0x59, 0x87, 0x05, 0x32, 0xd7, 0x81,
   878  	0x05, 0x6d, 0x60, 0x10, 0xd3, 0xdd, 0xb4, 0xcc, 0xae, 0xd1, 0x13, 0xdb, 0xfe, 0x71, 0xa1, 0x18,
   879  	0x08, 0x2b, 0x9b, 0x09, 0xfd, 0xce, 0x79, 0x61, 0x63, 0x21, 0x49, 0xc5, 0x29, 0x1b, 0xe8, 0x21,
   880  	0xcc, 0x3a, 0x89, 0x3d, 0xff, 0xa8, 0x90, 0xb1, 0x9c, 0x58, 0x2f, 0x0a, 0x5b, 0xb3, 0x41, 0x70,
   881  	0x03, 0x50, 0x74, 0x0f, 0x16, 0xbb, 0xaa, 0x31, 0xf0, 0x1c, 0x22, 0xe2, 0x59, 0xe6, 0xce, 0x7f,
   882  	0x8b, 0xe5, 0xc5, 0xed, 0x24, 0xe3, 0xd8, 0x97, 0xeb, 0x29, 0x02, 0x8f, 0x69, 0x5a, 0x39, 0xbb,
   883  	0x37, 0xd5, 0x53, 0xed, 0x4d, 0xfe, 0xc1, 0x9e, 0xfd, 0xff, 0x1c, 0xec, 0xda, 0xab, 0x3d, 0xd8,
   884  	0x37, 0xa1, 0x46, 0x0d, 0x9d, 0xdc, 0xea, 0x76, 0x89, 0xe6, 0xd2, 0xc6, 0x5c, 0x1c, 0xb0, 0xdd,
   885  	0x98, 0xcc, 0x02, 0x16, 0x7f, 0x6e, 0x0e, 0x54, 0x4a, 0x71, 0x52, 0x0d, 0x7d, 0x02, 0x4b, 0xac,
   886  	0x0c, 0x59, 0x9e, 0xbb, 0x4b, 0x34, 0xcb, 0xd4, 0x29, 0x3f, 0x15, 0xb3, 0xc1, 0x0a, 0x3e, 0x4f,
   887  	0x71, 0x70, 0x46, 0x12, 0x7d, 0x01, 0xab, 0x51, 0x16, 0x61, 0x32, 0x32, 0xc8, 0xd7, 0x7b, 0xc4,
   888  	0x61, 0x1f, 0xb4, 0x51, 0x59, 0x2b, 0x5d, 0xae, 0x76, 0xde, 0x1e, 0xfb, 0xf2, 0xea, 0x46, 0xbe,
   889  	0x08, 0x9e, 0xa6, 0x8b, 0xbe, 0x04, 0xe4, 0x10, 0xc3, 0x1c, 0x59, 0x1a, 0x4f, 0x3f, 0x91, 0x10,
   890  	0xc0, 0xfd, 0xfb, 0x60, 0xec, 0xcb, 0x08, 0x4f, 0x70, 0x8f, 0x7d, 0xf9, 0xad, 0x49, 0x2a, 0x4f,
   891  	0x8f, 0x1c, 0x2c, 0x34, 0x82, 0xe5, 0x61, 0xaa, 0xf2, 0xd0, 0xc6, 0x02, 0x3f, 0x21, 0xd7, 0x0b,
   892  	0x9d, 0x90, 0x74, 0xd5, 0x8a, 0xeb, 0x6b, 0x9a, 0x4e, 0x71, 0xd6, 0x88, 0xf2, 0x44, 0x82, 0x4b,
   893  	0x99, 0x9b, 0x23, 0x38, 0xa9, 0x5e, 0x00, 0x8e, 0xbe, 0x84, 0x0a, 0x4b, 0x08, 0x5d, 0x75, 0x55,
   894  	0x51, 0x8e, 0x3e, 0x28, 0x96, 0x3e, 0x41, 0xae, 0x6c, 0x13, 0x57, 0x8d, 0xcb, 0x61, 0x4c, 0xc3,
   895  	0x11, 0x2a, 0xda, 0x83, 0x8a, 0xb0, 0x4c, 0x1b, 0x33, 0xdc, 0xe7, 0x0f, 0x8b, 0xf9, 0x9c, 0x5e,
   896  	0x76, 0xa7, 0xcc, 0xac, 0xe0, 0x08, 0x4b, 0xf9, 0x87, 0x04, 0x6b, 0xcf, 0x72, 0xed, 0x9e, 0x41,
   897  	0x5d, 0xf4, 0x70, 0xc2, 0xbd, 0x56, 0xc1, 0xd3, 0x61, 0xd0, 0xc0, 0xb9, 0xa8, 0xf5, 0x08, 0x29,
   898  	0x09, 0xd7, 0xba, 0x30, 0x6b, 0xb8, 0x64, 0x18, 0xfa, 0xb5, 0x71, 0x1a, 0xbf, 0x52, 0x6b, 0x8e,
   899  	0xef, 0xbd, 0x2d, 0x86, 0x8b, 0x03, 0x78, 0xb6, 0x8b, 0xab, 0x53, 0xaa, 0x12, 0xfa, 0x28, 0xae,
   900  	0xb6, 0xfc, 0xd6, 0x68, 0x48, 0xfc, 0x20, 0xd4, 0x93, 0xb5, 0x92, 0x33, 0x70, 0x5a, 0x0e, 0xfd,
   901  	0x5c, 0x02, 0xe4, 0x4c, 0xe0, 0x89, 0x2a, 0x71, 0xea, 0x8b, 0xfb, 0xa2, 0x70, 0x00, 0x4d, 0xf2,
   902  	0x70, 0x8e, 0x39, 0x45, 0x85, 0xea, 0x8e, 0xea, 0xa8, 0xc3, 0xbb, 0x86, 0xa9, 0xb3, 0x5e, 0x4b,
   903  	0xb5, 0x0d, 0x71, 0x2c, 0x45, 0x65, 0x8b, 0x92, 0x6b, 0x63, 0x67, 0x4b, 0x70, 0x70, 0x42, 0x8a,
   904  	0xd5, 0xc1, 0x43, 0xc3, 0xd4, 0x45, 0x67, 0x16, 0xd5, 0x41, 0x86, 0x87, 0x39, 0x47, 0xf9, 0xed,
   905  	0x0c, 0x54, 0xb8, 0x0d, 0xd6, 0x2d, 0x9e, 0x5c, 0x36, 0xdb, 0x50, 0x8d, 0xee, 0x5a, 0x81, 0x5a,
   906  	0x17, 0x62, 0xd5, 0xe8, 0x5e, 0xc6, 0xb1, 0x0c, 0xfa, 0x11, 0x54, 0x68, 0x78, 0x03, 0x97, 0x4e,
   907  	0x7f, 0x03, 0x2f, 0xb0, 0x24, 0x8b, 0xee, 0xde, 0x08, 0x12, 0xb9, 0xb0, 0x6a, 0xb3, 0xd5, 0x13,
   908  	0x97, 0x38, 0xf7, 0x2d, 0xf7, 0xb6, 0xe5, 0x99, 0xfa, 0x86, 0xc6, 0xa2, 0x27, 0xca, 0xdf, 0x27,
   909  	0xec, 0xce, 0xdb, 0xc9, 0x17, 0x39, 0xf6, 0xe5, 0xb7, 0xa7, 0xb0, 0xf8, 0x5d, 0x35, 0x0d, 0x5a,
   910  	0xf9, 0xa3, 0x04, 0x65, 0xb6, 0x85, 0xe8, 0xdb, 0x50, 0x55, 0x6d, 0xe3, 0x8e, 0x63, 0x79, 0x76,
   911  	0x98, 0x5b, 0x8b, 0x2c, 0x14, 0x1b, 0x3b, 0x5b, 0x01, 0x11, 0xc7, 0x7c, 0xb4, 0x0e, 0xb5, 0x78,
   912  	0x6b, 0x82, 0x63, 0x51, 0xed, 0x2c, 0xb3, 0x0a, 0x11, 0xef, 0x1e, 0xc5, 0x49, 0x19, 0x86, 0x1f,
   913  	0xe6, 0x65, 0xd0, 0x35, 0x08, 0xfc, 0xa8, 0x75, 0xc6, 0x31, 0x1f, 0xbd, 0x0f, 0xb3, 0x54, 0xb3,
   914  	0x6c, 0x22, 0x3c, 0x7f, 0x8b, 0x9d, 0x94, 0x5d, 0x46, 0x38, 0xf6, 0xe5, 0x2a, 0xff, 0x83, 0x7b,
   915  	0x15, 0x08, 0x29, 0xbf, 0x91, 0x20, 0x27, 0x0d, 0xd1, 0xa7, 0x00, 0x56, 0x9c, 0xef, 0x81, 0x4b,
   916  	0x32, 0xbf, 0xbe, 0x22, 0xea, 0xb1, 0x2f, 0x2f, 0x46, 0x5f, 0x1c, 0x32, 0xa1, 0x82, 0xee, 0x42,
   917  	0x99, 0x65, 0xb2, 0x38, 0x2a, 0x57, 0x0a, 0x1f, 0x95, 0x38, 0xdd, 0xd8, 0x17, 0xe6, 0x20, 0xca,
   918  	0xaf, 0x25, 0x58, 0xd9, 0x25, 0xce, 0xc8, 0xd0, 0x08, 0x26, 0x5d, 0xe2, 0x10, 0x53, 0xcb, 0xe4,
   919  	0xa0, 0x54, 0x20, 0x07, 0xc3, 0xb4, 0x9e, 0x99, 0x9a, 0xd6, 0x97, 0xa0, 0x6c, 0xab, 0x6e, 0x5f,
   920  	0xbc, 0x91, 0x2a, 0x8c, 0xbb, 0xa3, 0xba, 0x7d, 0xcc, 0xa9, 0x9c, 0x6b, 0x39, 0x2e, 0x8f, 0xeb,
   921  	0xac, 0xe0, 0x5a, 0x8e, 0x8b, 0x39, 0x55, 0xf9, 0x95, 0x04, 0x0b, 0x2c, 0x0a, 0x9b, 0x7d, 0xa2,
   922  	0x1d, 0xb2, 0x17, 0xda, 0xcf, 0x24, 0x40, 0x24, 0xfb, 0x6e, 0x0b, 0x62, 0x59, 0xbb, 0x76, 0xa3,
   923  	0x50, 0x40, 0x26, 0x9e, 0x7d, 0xf1, 0xd5, 0x31, 0xc1, 0xa2, 0x38, 0xc7, 0x9a, 0xf2, 0xe7, 0x19,
   924  	0xb8, 0xb0, 0xa7, 0x0e, 0x0c, 0x9d, 0x5f, 0xa7, 0x51, 0xd1, 0x17, 0x15, 0xf7, 0xd5, 0x17, 0x36,
   925  	0x1d, 0xca, 0xd4, 0x26, 0x9a, 0x48, 0x83, 0x4e, 0x21, 0xaf, 0xa7, 0xae, 0x77, 0xd7, 0x26, 0x5a,
   926  	0xbc, 0x6f, 0xec, 0x0b, 0x73, 0x74, 0x34, 0x80, 0x39, 0xea, 0xaa, 0xae, 0x47, 0xc5, 0xdd, 0x72,
   927  	0xf3, 0x05, 0xed, 0x70, 0xac, 0xce, 0x92, 0xb0, 0x34, 0x17, 0x7c, 0x63, 0x61, 0x43, 0xf9, 0xb7,
   928  	0x04, 0x6b, 0x53, 0x75, 0x3b, 0x86, 0xa9, 0xb3, 0xdd, 0x7f, 0xf5, 0xa1, 0x3d, 0x4c, 0x85, 0x76,
   929  	0xeb, 0xc5, 0x5c, 0x16, 0xcb, 0x9e, 0x16, 0x61, 0xe5, 0x5f, 0x12, 0xbc, 0x77, 0x92, 0xf2, 0x19,
   930  	0x34, 0x13, 0x5f, 0xa5, 0x9b, 0x89, 0x5b, 0x2f, 0xc5, 0xe9, 0x29, 0x0d, 0xc5, 0x7f, 0x66, 0x4e,
   931  	0x76, 0x99, 0x45, 0x88, 0x55, 0x64, 0x9b, 0x13, 0xef, 0xc7, 0x45, 0x33, 0xda, 0xba, 0x9d, 0x88,
   932  	0x83, 0x13, 0x52, 0x68, 0x1f, 0x2a, 0xb6, 0x28, 0xb7, 0x62, 0x03, 0xaf, 0x16, 0xf2, 0x25, 0xac,
   933  	0xd1, 0x41, 0x25, 0x0c, 0xbf, 0x70, 0x04, 0xc6, 0x1e, 0x3c, 0xc3, 0xd4, 0x54, 0x25, 0xa7, 0xdc,
   934  	0x9e, 0xd0, 0x43, 0x47, 0xaa, 0xc1, 0x73, 0x23, 0x4d, 0xc3, 0x19, 0x78, 0xb4, 0x0f, 0xf5, 0x91,
   935  	0x88, 0x92, 0x65, 0x06, 0x85, 0x31, 0x18, 0x25, 0x54, 0x3b, 0x57, 0xd8, 0x33, 0x6d, 0x2f, 0xcb,
   936  	0x3c, 0xf6, 0xe5, 0x95, 0x2c, 0x11, 0x4f, 0x62, 0x28, 0x63, 0x09, 0xde, 0x99, 0x1a, 0xff, 0x33,
   937  	0xc8, 0x35, 0x2d, 0x9d, 0x6b, 0xdf, 0x7b, 0xc1, 0x5c, 0x9b, 0x92, 0x64, 0xb3, 0xcf, 0x70, 0x92,
   938  	0x67, 0xd7, 0x0f, 0xa1, 0x6a, 0x87, 0xcd, 0x5f, 0x8e, 0x97, 0x27, 0xa4, 0x0a, 0xd3, 0x0a, 0x7a,
   939  	0x85, 0xe8, 0x13, 0xc7, 0x78, 0xc8, 0x83, 0x95, 0xf0, 0x35, 0xc4, 0x54, 0x0d, 0xd3, 0xa5, 0x39,
   940  	0x93, 0xaf, 0xc2, 0xf9, 0x72, 0x7e, 0xec, 0xcb, 0x2b, 0xdb, 0x19, 0x40, 0x3c, 0x61, 0x02, 0x75,
   941  	0xa1, 0x16, 0xef, 0x77, 0x38, 0x07, 0x69, 0x3f, 0x57, 0x80, 0x2d, 0xb3, 0xf3, 0x86, 0x88, 0x68,
   942  	0x2d, 0xa6, 0x51, 0x9c, 0x04, 0x7e, 0xc9, 0xb3, 0x90, 0x9f, 0xc0, 0x8a, 0x9a, 0x1e, 0xfe, 0xd2,
   943  	0xc6, 0xec, 0x73, 0x3c, 0xd6, 0x32, 0x93, 0xe3, 0x4e, 0x43, 0xac, 0x7f, 0x25, 0xc3, 0xa0, 0x78,
   944  	0xc2, 0x4e, 0xde, 0xdb, 0x78, 0xee, 0x0c, 0xde, 0xc6, 0xe8, 0xc7, 0x50, 0x1d, 0xa9, 0x8e, 0xa1,
   945  	0x1e, 0x0c, 0x08, 0x6d, 0xcc, 0x73, 0x8b, 0x57, 0x0b, 0xee, 0x53, 0xa0, 0x15, 0xf7, 0x64, 0x21,
   946  	0x85, 0xe2, 0x18, 0x52, 0xf9, 0xc3, 0x0c, 0xc8, 0x27, 0xd4, 0x61, 0xf4, 0x19, 0x20, 0xeb, 0x80,
   947  	0x12, 0x67, 0x44, 0xf4, 0x3b, 0xc1, 0x3c, 0x3e, 0x7c, 0xf9, 0x94, 0xe2, 0x7e, 0xe8, 0xc1, 0x84,
   948  	0x04, 0xce, 0xd1, 0x42, 0x3d, 0x58, 0x70, 0x13, 0x4d, 0x9a, 0x48, 0xf6, 0xf5, 0x42, 0x2e, 0x25,
   949  	0xbb, 0xbb, 0xce, 0xca, 0xd8, 0x97, 0x53, 0xfd, 0x1e, 0x4e, 0x01, 0x23, 0x0d, 0x40, 0x8b, 0xf7,
   950  	0x6a, 0x32, 0xc3, 0x9f, 0x71, 0x3b, 0xc5, 0xfb, 0x14, 0x55, 0x91, 0xc4, 0x16, 0x25, 0x60, 0x95,
   951  	0xbf, 0xcc, 0x43, 0x3d, 0x8e, 0xde, 0xeb, 0xa9, 0xe7, 0xeb, 0xa9, 0xe7, 0xb4, 0xa9, 0x27, 0xbc,
   952  	0x9e, 0x7a, 0x9e, 0x6a, 0xea, 0x99, 0x73, 0xef, 0xd6, 0xce, 0x62, 0x26, 0xf9, 0x57, 0x09, 0x9a,
   953  	0x13, 0x27, 0xfb, 0xac, 0xa7, 0x92, 0xdf, 0x9f, 0x98, 0x4a, 0xde, 0x78, 0xce, 0x26, 0x68, 0xda,
   954  	0x5c, 0xf2, 0x9f, 0x12, 0x28, 0xcf, 0x76, 0xef, 0x0c, 0x1a, 0xbc, 0x7e, 0xba, 0xc1, 0xdb, 0x3c,
   955  	0x9d, 0x6f, 0x45, 0x66, 0x93, 0xff, 0x95, 0x00, 0xe2, 0x26, 0x05, 0xbd, 0x07, 0x89, 0x1f, 0x45,
   956  	0xc5, 0x35, 0x1d, 0x44, 0x28, 0x41, 0x47, 0x57, 0x60, 0x7e, 0x48, 0x28, 0x55, 0x7b, 0xe1, 0xc4,
   957  	0x22, 0xfa, 0xcd, 0x76, 0x3b, 0x20, 0xe3, 0x90, 0x8f, 0xf6, 0x61, 0xce, 0x21, 0x2a, 0xb5, 0x4c,
   958  	0x31, 0xb9, 0xf8, 0x94, 0xbd, 0x5a, 0x31, 0xa7, 0x1c, 0xfb, 0xf2, 0x7a, 0x91, 0xdf, 0xd4, 0x5b,
   959  	0xe2, 0x91, 0xcb, 0x95, 0xb0, 0x80, 0x43, 0x77, 0xa0, 0x2e, 0x6c, 0x24, 0x16, 0x1c, 0x5c, 0xad,
   960  	0x17, 0xc4, 0x6a, 0xea, 0xdb, 0x59, 0x01, 0x3c, 0xa9, 0xa3, 0x7c, 0x06, 0x95, 0xb0, 0xfe, 0xa3,
   961  	0x06, 0x94, 0x13, 0x2f, 0xa5, 0xc0, 0x71, 0x4e, 0xc9, 0x04, 0x66, 0x26, 0x3f, 0x30, 0xca, 0xef,
   962  	0x25, 0x78, 0x23, 0xa7, 0x0a, 0xa1, 0x0b, 0x50, 0xf2, 0x9c, 0x81, 0x08, 0xc1, 0xfc, 0xd8, 0x97,
   963  	0x4b, 0x5f, 0xe0, 0x7b, 0x98, 0xd1, 0xd0, 0x43, 0x98, 0xa7, 0xc1, 0xfc, 0x48, 0xe4, 0xd1, 0x77,
   964  	0x0a, 0x6d, 0x76, 0x76, 0xe6, 0xd4, 0xa9, 0xb1, 0xf0, 0x87, 0xd4, 0x10, 0x12, 0x5d, 0x86, 0x8a,
   965  	0xa6, 0x76, 0x3c, 0x53, 0x17, 0xf3, 0xae, 0x85, 0xe0, 0x75, 0xb6, 0xb9, 0x11, 0xd0, 0x70, 0xc4,
   966  	0xed, 0x6c, 0x3d, 0x7e, 0xda, 0x3c, 0xf7, 0xcd, 0xd3, 0xe6, 0xb9, 0x27, 0x4f, 0x9b, 0xe7, 0x7e,
   967  	0x3a, 0x6e, 0x4a, 0x8f, 0xc7, 0x4d, 0xe9, 0x9b, 0x71, 0x53, 0x7a, 0x32, 0x6e, 0x4a, 0x7f, 0x1b,
   968  	0x37, 0xa5, 0x5f, 0xfe, 0xbd, 0x79, 0xee, 0x07, 0xef, 0x16, 0xf8, 0x6f, 0x8c, 0xff, 0x05, 0x00,
   969  	0x00, 0xff, 0xff, 0x1e, 0x59, 0xab, 0xd9, 0xb3, 0x21, 0x00, 0x00,
   970  }
   971  
   972  func (m *AuditAnnotation) Marshal() (dAtA []byte, err error) {
   973  	size := m.Size()
   974  	dAtA = make([]byte, size)
   975  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   976  	if err != nil {
   977  		return nil, err
   978  	}
   979  	return dAtA[:n], nil
   980  }
   981  
   982  func (m *AuditAnnotation) MarshalTo(dAtA []byte) (int, error) {
   983  	size := m.Size()
   984  	return m.MarshalToSizedBuffer(dAtA[:size])
   985  }
   986  
   987  func (m *AuditAnnotation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   988  	i := len(dAtA)
   989  	_ = i
   990  	var l int
   991  	_ = l
   992  	i -= len(m.ValueExpression)
   993  	copy(dAtA[i:], m.ValueExpression)
   994  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ValueExpression)))
   995  	i--
   996  	dAtA[i] = 0x12
   997  	i -= len(m.Key)
   998  	copy(dAtA[i:], m.Key)
   999  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Key)))
  1000  	i--
  1001  	dAtA[i] = 0xa
  1002  	return len(dAtA) - i, nil
  1003  }
  1004  
  1005  func (m *ExpressionWarning) Marshal() (dAtA []byte, err error) {
  1006  	size := m.Size()
  1007  	dAtA = make([]byte, size)
  1008  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1009  	if err != nil {
  1010  		return nil, err
  1011  	}
  1012  	return dAtA[:n], nil
  1013  }
  1014  
  1015  func (m *ExpressionWarning) MarshalTo(dAtA []byte) (int, error) {
  1016  	size := m.Size()
  1017  	return m.MarshalToSizedBuffer(dAtA[:size])
  1018  }
  1019  
  1020  func (m *ExpressionWarning) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1021  	i := len(dAtA)
  1022  	_ = i
  1023  	var l int
  1024  	_ = l
  1025  	i -= len(m.Warning)
  1026  	copy(dAtA[i:], m.Warning)
  1027  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Warning)))
  1028  	i--
  1029  	dAtA[i] = 0x1a
  1030  	i -= len(m.FieldRef)
  1031  	copy(dAtA[i:], m.FieldRef)
  1032  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.FieldRef)))
  1033  	i--
  1034  	dAtA[i] = 0x12
  1035  	return len(dAtA) - i, nil
  1036  }
  1037  
  1038  func (m *MatchCondition) Marshal() (dAtA []byte, err error) {
  1039  	size := m.Size()
  1040  	dAtA = make([]byte, size)
  1041  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1042  	if err != nil {
  1043  		return nil, err
  1044  	}
  1045  	return dAtA[:n], nil
  1046  }
  1047  
  1048  func (m *MatchCondition) MarshalTo(dAtA []byte) (int, error) {
  1049  	size := m.Size()
  1050  	return m.MarshalToSizedBuffer(dAtA[:size])
  1051  }
  1052  
  1053  func (m *MatchCondition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1054  	i := len(dAtA)
  1055  	_ = i
  1056  	var l int
  1057  	_ = l
  1058  	i -= len(m.Expression)
  1059  	copy(dAtA[i:], m.Expression)
  1060  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Expression)))
  1061  	i--
  1062  	dAtA[i] = 0x12
  1063  	i -= len(m.Name)
  1064  	copy(dAtA[i:], m.Name)
  1065  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
  1066  	i--
  1067  	dAtA[i] = 0xa
  1068  	return len(dAtA) - i, nil
  1069  }
  1070  
  1071  func (m *MatchResources) Marshal() (dAtA []byte, err error) {
  1072  	size := m.Size()
  1073  	dAtA = make([]byte, size)
  1074  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1075  	if err != nil {
  1076  		return nil, err
  1077  	}
  1078  	return dAtA[:n], nil
  1079  }
  1080  
  1081  func (m *MatchResources) MarshalTo(dAtA []byte) (int, error) {
  1082  	size := m.Size()
  1083  	return m.MarshalToSizedBuffer(dAtA[:size])
  1084  }
  1085  
  1086  func (m *MatchResources) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1087  	i := len(dAtA)
  1088  	_ = i
  1089  	var l int
  1090  	_ = l
  1091  	if m.MatchPolicy != nil {
  1092  		i -= len(*m.MatchPolicy)
  1093  		copy(dAtA[i:], *m.MatchPolicy)
  1094  		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.MatchPolicy)))
  1095  		i--
  1096  		dAtA[i] = 0x3a
  1097  	}
  1098  	if len(m.ExcludeResourceRules) > 0 {
  1099  		for iNdEx := len(m.ExcludeResourceRules) - 1; iNdEx >= 0; iNdEx-- {
  1100  			{
  1101  				size, err := m.ExcludeResourceRules[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  1102  				if err != nil {
  1103  					return 0, err
  1104  				}
  1105  				i -= size
  1106  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  1107  			}
  1108  			i--
  1109  			dAtA[i] = 0x22
  1110  		}
  1111  	}
  1112  	if len(m.ResourceRules) > 0 {
  1113  		for iNdEx := len(m.ResourceRules) - 1; iNdEx >= 0; iNdEx-- {
  1114  			{
  1115  				size, err := m.ResourceRules[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  1116  				if err != nil {
  1117  					return 0, err
  1118  				}
  1119  				i -= size
  1120  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  1121  			}
  1122  			i--
  1123  			dAtA[i] = 0x1a
  1124  		}
  1125  	}
  1126  	if m.ObjectSelector != nil {
  1127  		{
  1128  			size, err := m.ObjectSelector.MarshalToSizedBuffer(dAtA[:i])
  1129  			if err != nil {
  1130  				return 0, err
  1131  			}
  1132  			i -= size
  1133  			i = encodeVarintGenerated(dAtA, i, uint64(size))
  1134  		}
  1135  		i--
  1136  		dAtA[i] = 0x12
  1137  	}
  1138  	if m.NamespaceSelector != nil {
  1139  		{
  1140  			size, err := m.NamespaceSelector.MarshalToSizedBuffer(dAtA[:i])
  1141  			if err != nil {
  1142  				return 0, err
  1143  			}
  1144  			i -= size
  1145  			i = encodeVarintGenerated(dAtA, i, uint64(size))
  1146  		}
  1147  		i--
  1148  		dAtA[i] = 0xa
  1149  	}
  1150  	return len(dAtA) - i, nil
  1151  }
  1152  
  1153  func (m *MutatingWebhook) Marshal() (dAtA []byte, err error) {
  1154  	size := m.Size()
  1155  	dAtA = make([]byte, size)
  1156  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1157  	if err != nil {
  1158  		return nil, err
  1159  	}
  1160  	return dAtA[:n], nil
  1161  }
  1162  
  1163  func (m *MutatingWebhook) MarshalTo(dAtA []byte) (int, error) {
  1164  	size := m.Size()
  1165  	return m.MarshalToSizedBuffer(dAtA[:size])
  1166  }
  1167  
  1168  func (m *MutatingWebhook) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1169  	i := len(dAtA)
  1170  	_ = i
  1171  	var l int
  1172  	_ = l
  1173  	if len(m.MatchConditions) > 0 {
  1174  		for iNdEx := len(m.MatchConditions) - 1; iNdEx >= 0; iNdEx-- {
  1175  			{
  1176  				size, err := m.MatchConditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  1177  				if err != nil {
  1178  					return 0, err
  1179  				}
  1180  				i -= size
  1181  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  1182  			}
  1183  			i--
  1184  			dAtA[i] = 0x62
  1185  		}
  1186  	}
  1187  	if m.ObjectSelector != nil {
  1188  		{
  1189  			size, err := m.ObjectSelector.MarshalToSizedBuffer(dAtA[:i])
  1190  			if err != nil {
  1191  				return 0, err
  1192  			}
  1193  			i -= size
  1194  			i = encodeVarintGenerated(dAtA, i, uint64(size))
  1195  		}
  1196  		i--
  1197  		dAtA[i] = 0x5a
  1198  	}
  1199  	if m.ReinvocationPolicy != nil {
  1200  		i -= len(*m.ReinvocationPolicy)
  1201  		copy(dAtA[i:], *m.ReinvocationPolicy)
  1202  		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.ReinvocationPolicy)))
  1203  		i--
  1204  		dAtA[i] = 0x52
  1205  	}
  1206  	if m.MatchPolicy != nil {
  1207  		i -= len(*m.MatchPolicy)
  1208  		copy(dAtA[i:], *m.MatchPolicy)
  1209  		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.MatchPolicy)))
  1210  		i--
  1211  		dAtA[i] = 0x4a
  1212  	}
  1213  	if len(m.AdmissionReviewVersions) > 0 {
  1214  		for iNdEx := len(m.AdmissionReviewVersions) - 1; iNdEx >= 0; iNdEx-- {
  1215  			i -= len(m.AdmissionReviewVersions[iNdEx])
  1216  			copy(dAtA[i:], m.AdmissionReviewVersions[iNdEx])
  1217  			i = encodeVarintGenerated(dAtA, i, uint64(len(m.AdmissionReviewVersions[iNdEx])))
  1218  			i--
  1219  			dAtA[i] = 0x42
  1220  		}
  1221  	}
  1222  	if m.TimeoutSeconds != nil {
  1223  		i = encodeVarintGenerated(dAtA, i, uint64(*m.TimeoutSeconds))
  1224  		i--
  1225  		dAtA[i] = 0x38
  1226  	}
  1227  	if m.SideEffects != nil {
  1228  		i -= len(*m.SideEffects)
  1229  		copy(dAtA[i:], *m.SideEffects)
  1230  		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.SideEffects)))
  1231  		i--
  1232  		dAtA[i] = 0x32
  1233  	}
  1234  	if m.NamespaceSelector != nil {
  1235  		{
  1236  			size, err := m.NamespaceSelector.MarshalToSizedBuffer(dAtA[:i])
  1237  			if err != nil {
  1238  				return 0, err
  1239  			}
  1240  			i -= size
  1241  			i = encodeVarintGenerated(dAtA, i, uint64(size))
  1242  		}
  1243  		i--
  1244  		dAtA[i] = 0x2a
  1245  	}
  1246  	if m.FailurePolicy != nil {
  1247  		i -= len(*m.FailurePolicy)
  1248  		copy(dAtA[i:], *m.FailurePolicy)
  1249  		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.FailurePolicy)))
  1250  		i--
  1251  		dAtA[i] = 0x22
  1252  	}
  1253  	if len(m.Rules) > 0 {
  1254  		for iNdEx := len(m.Rules) - 1; iNdEx >= 0; iNdEx-- {
  1255  			{
  1256  				size, err := m.Rules[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  1257  				if err != nil {
  1258  					return 0, err
  1259  				}
  1260  				i -= size
  1261  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  1262  			}
  1263  			i--
  1264  			dAtA[i] = 0x1a
  1265  		}
  1266  	}
  1267  	{
  1268  		size, err := m.ClientConfig.MarshalToSizedBuffer(dAtA[:i])
  1269  		if err != nil {
  1270  			return 0, err
  1271  		}
  1272  		i -= size
  1273  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  1274  	}
  1275  	i--
  1276  	dAtA[i] = 0x12
  1277  	i -= len(m.Name)
  1278  	copy(dAtA[i:], m.Name)
  1279  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
  1280  	i--
  1281  	dAtA[i] = 0xa
  1282  	return len(dAtA) - i, nil
  1283  }
  1284  
  1285  func (m *MutatingWebhookConfiguration) Marshal() (dAtA []byte, err error) {
  1286  	size := m.Size()
  1287  	dAtA = make([]byte, size)
  1288  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1289  	if err != nil {
  1290  		return nil, err
  1291  	}
  1292  	return dAtA[:n], nil
  1293  }
  1294  
  1295  func (m *MutatingWebhookConfiguration) MarshalTo(dAtA []byte) (int, error) {
  1296  	size := m.Size()
  1297  	return m.MarshalToSizedBuffer(dAtA[:size])
  1298  }
  1299  
  1300  func (m *MutatingWebhookConfiguration) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1301  	i := len(dAtA)
  1302  	_ = i
  1303  	var l int
  1304  	_ = l
  1305  	if len(m.Webhooks) > 0 {
  1306  		for iNdEx := len(m.Webhooks) - 1; iNdEx >= 0; iNdEx-- {
  1307  			{
  1308  				size, err := m.Webhooks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  1309  				if err != nil {
  1310  					return 0, err
  1311  				}
  1312  				i -= size
  1313  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  1314  			}
  1315  			i--
  1316  			dAtA[i] = 0x12
  1317  		}
  1318  	}
  1319  	{
  1320  		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
  1321  		if err != nil {
  1322  			return 0, err
  1323  		}
  1324  		i -= size
  1325  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  1326  	}
  1327  	i--
  1328  	dAtA[i] = 0xa
  1329  	return len(dAtA) - i, nil
  1330  }
  1331  
  1332  func (m *MutatingWebhookConfigurationList) Marshal() (dAtA []byte, err error) {
  1333  	size := m.Size()
  1334  	dAtA = make([]byte, size)
  1335  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1336  	if err != nil {
  1337  		return nil, err
  1338  	}
  1339  	return dAtA[:n], nil
  1340  }
  1341  
  1342  func (m *MutatingWebhookConfigurationList) MarshalTo(dAtA []byte) (int, error) {
  1343  	size := m.Size()
  1344  	return m.MarshalToSizedBuffer(dAtA[:size])
  1345  }
  1346  
  1347  func (m *MutatingWebhookConfigurationList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1348  	i := len(dAtA)
  1349  	_ = i
  1350  	var l int
  1351  	_ = l
  1352  	if len(m.Items) > 0 {
  1353  		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
  1354  			{
  1355  				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  1356  				if err != nil {
  1357  					return 0, err
  1358  				}
  1359  				i -= size
  1360  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  1361  			}
  1362  			i--
  1363  			dAtA[i] = 0x12
  1364  		}
  1365  	}
  1366  	{
  1367  		size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
  1368  		if err != nil {
  1369  			return 0, err
  1370  		}
  1371  		i -= size
  1372  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  1373  	}
  1374  	i--
  1375  	dAtA[i] = 0xa
  1376  	return len(dAtA) - i, nil
  1377  }
  1378  
  1379  func (m *NamedRuleWithOperations) Marshal() (dAtA []byte, err error) {
  1380  	size := m.Size()
  1381  	dAtA = make([]byte, size)
  1382  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1383  	if err != nil {
  1384  		return nil, err
  1385  	}
  1386  	return dAtA[:n], nil
  1387  }
  1388  
  1389  func (m *NamedRuleWithOperations) MarshalTo(dAtA []byte) (int, error) {
  1390  	size := m.Size()
  1391  	return m.MarshalToSizedBuffer(dAtA[:size])
  1392  }
  1393  
  1394  func (m *NamedRuleWithOperations) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1395  	i := len(dAtA)
  1396  	_ = i
  1397  	var l int
  1398  	_ = l
  1399  	{
  1400  		size, err := m.RuleWithOperations.MarshalToSizedBuffer(dAtA[:i])
  1401  		if err != nil {
  1402  			return 0, err
  1403  		}
  1404  		i -= size
  1405  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  1406  	}
  1407  	i--
  1408  	dAtA[i] = 0x12
  1409  	if len(m.ResourceNames) > 0 {
  1410  		for iNdEx := len(m.ResourceNames) - 1; iNdEx >= 0; iNdEx-- {
  1411  			i -= len(m.ResourceNames[iNdEx])
  1412  			copy(dAtA[i:], m.ResourceNames[iNdEx])
  1413  			i = encodeVarintGenerated(dAtA, i, uint64(len(m.ResourceNames[iNdEx])))
  1414  			i--
  1415  			dAtA[i] = 0xa
  1416  		}
  1417  	}
  1418  	return len(dAtA) - i, nil
  1419  }
  1420  
  1421  func (m *ParamKind) Marshal() (dAtA []byte, err error) {
  1422  	size := m.Size()
  1423  	dAtA = make([]byte, size)
  1424  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1425  	if err != nil {
  1426  		return nil, err
  1427  	}
  1428  	return dAtA[:n], nil
  1429  }
  1430  
  1431  func (m *ParamKind) MarshalTo(dAtA []byte) (int, error) {
  1432  	size := m.Size()
  1433  	return m.MarshalToSizedBuffer(dAtA[:size])
  1434  }
  1435  
  1436  func (m *ParamKind) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1437  	i := len(dAtA)
  1438  	_ = i
  1439  	var l int
  1440  	_ = l
  1441  	i -= len(m.Kind)
  1442  	copy(dAtA[i:], m.Kind)
  1443  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
  1444  	i--
  1445  	dAtA[i] = 0x12
  1446  	i -= len(m.APIVersion)
  1447  	copy(dAtA[i:], m.APIVersion)
  1448  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.APIVersion)))
  1449  	i--
  1450  	dAtA[i] = 0xa
  1451  	return len(dAtA) - i, nil
  1452  }
  1453  
  1454  func (m *ParamRef) Marshal() (dAtA []byte, err error) {
  1455  	size := m.Size()
  1456  	dAtA = make([]byte, size)
  1457  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1458  	if err != nil {
  1459  		return nil, err
  1460  	}
  1461  	return dAtA[:n], nil
  1462  }
  1463  
  1464  func (m *ParamRef) MarshalTo(dAtA []byte) (int, error) {
  1465  	size := m.Size()
  1466  	return m.MarshalToSizedBuffer(dAtA[:size])
  1467  }
  1468  
  1469  func (m *ParamRef) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1470  	i := len(dAtA)
  1471  	_ = i
  1472  	var l int
  1473  	_ = l
  1474  	if m.ParameterNotFoundAction != nil {
  1475  		i -= len(*m.ParameterNotFoundAction)
  1476  		copy(dAtA[i:], *m.ParameterNotFoundAction)
  1477  		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.ParameterNotFoundAction)))
  1478  		i--
  1479  		dAtA[i] = 0x22
  1480  	}
  1481  	if m.Selector != nil {
  1482  		{
  1483  			size, err := m.Selector.MarshalToSizedBuffer(dAtA[:i])
  1484  			if err != nil {
  1485  				return 0, err
  1486  			}
  1487  			i -= size
  1488  			i = encodeVarintGenerated(dAtA, i, uint64(size))
  1489  		}
  1490  		i--
  1491  		dAtA[i] = 0x1a
  1492  	}
  1493  	i -= len(m.Namespace)
  1494  	copy(dAtA[i:], m.Namespace)
  1495  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Namespace)))
  1496  	i--
  1497  	dAtA[i] = 0x12
  1498  	i -= len(m.Name)
  1499  	copy(dAtA[i:], m.Name)
  1500  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
  1501  	i--
  1502  	dAtA[i] = 0xa
  1503  	return len(dAtA) - i, nil
  1504  }
  1505  
  1506  func (m *Rule) Marshal() (dAtA []byte, err error) {
  1507  	size := m.Size()
  1508  	dAtA = make([]byte, size)
  1509  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1510  	if err != nil {
  1511  		return nil, err
  1512  	}
  1513  	return dAtA[:n], nil
  1514  }
  1515  
  1516  func (m *Rule) MarshalTo(dAtA []byte) (int, error) {
  1517  	size := m.Size()
  1518  	return m.MarshalToSizedBuffer(dAtA[:size])
  1519  }
  1520  
  1521  func (m *Rule) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1522  	i := len(dAtA)
  1523  	_ = i
  1524  	var l int
  1525  	_ = l
  1526  	if m.Scope != nil {
  1527  		i -= len(*m.Scope)
  1528  		copy(dAtA[i:], *m.Scope)
  1529  		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Scope)))
  1530  		i--
  1531  		dAtA[i] = 0x22
  1532  	}
  1533  	if len(m.Resources) > 0 {
  1534  		for iNdEx := len(m.Resources) - 1; iNdEx >= 0; iNdEx-- {
  1535  			i -= len(m.Resources[iNdEx])
  1536  			copy(dAtA[i:], m.Resources[iNdEx])
  1537  			i = encodeVarintGenerated(dAtA, i, uint64(len(m.Resources[iNdEx])))
  1538  			i--
  1539  			dAtA[i] = 0x1a
  1540  		}
  1541  	}
  1542  	if len(m.APIVersions) > 0 {
  1543  		for iNdEx := len(m.APIVersions) - 1; iNdEx >= 0; iNdEx-- {
  1544  			i -= len(m.APIVersions[iNdEx])
  1545  			copy(dAtA[i:], m.APIVersions[iNdEx])
  1546  			i = encodeVarintGenerated(dAtA, i, uint64(len(m.APIVersions[iNdEx])))
  1547  			i--
  1548  			dAtA[i] = 0x12
  1549  		}
  1550  	}
  1551  	if len(m.APIGroups) > 0 {
  1552  		for iNdEx := len(m.APIGroups) - 1; iNdEx >= 0; iNdEx-- {
  1553  			i -= len(m.APIGroups[iNdEx])
  1554  			copy(dAtA[i:], m.APIGroups[iNdEx])
  1555  			i = encodeVarintGenerated(dAtA, i, uint64(len(m.APIGroups[iNdEx])))
  1556  			i--
  1557  			dAtA[i] = 0xa
  1558  		}
  1559  	}
  1560  	return len(dAtA) - i, nil
  1561  }
  1562  
  1563  func (m *RuleWithOperations) Marshal() (dAtA []byte, err error) {
  1564  	size := m.Size()
  1565  	dAtA = make([]byte, size)
  1566  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1567  	if err != nil {
  1568  		return nil, err
  1569  	}
  1570  	return dAtA[:n], nil
  1571  }
  1572  
  1573  func (m *RuleWithOperations) MarshalTo(dAtA []byte) (int, error) {
  1574  	size := m.Size()
  1575  	return m.MarshalToSizedBuffer(dAtA[:size])
  1576  }
  1577  
  1578  func (m *RuleWithOperations) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1579  	i := len(dAtA)
  1580  	_ = i
  1581  	var l int
  1582  	_ = l
  1583  	{
  1584  		size, err := m.Rule.MarshalToSizedBuffer(dAtA[:i])
  1585  		if err != nil {
  1586  			return 0, err
  1587  		}
  1588  		i -= size
  1589  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  1590  	}
  1591  	i--
  1592  	dAtA[i] = 0x12
  1593  	if len(m.Operations) > 0 {
  1594  		for iNdEx := len(m.Operations) - 1; iNdEx >= 0; iNdEx-- {
  1595  			i -= len(m.Operations[iNdEx])
  1596  			copy(dAtA[i:], m.Operations[iNdEx])
  1597  			i = encodeVarintGenerated(dAtA, i, uint64(len(m.Operations[iNdEx])))
  1598  			i--
  1599  			dAtA[i] = 0xa
  1600  		}
  1601  	}
  1602  	return len(dAtA) - i, nil
  1603  }
  1604  
  1605  func (m *ServiceReference) Marshal() (dAtA []byte, err error) {
  1606  	size := m.Size()
  1607  	dAtA = make([]byte, size)
  1608  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1609  	if err != nil {
  1610  		return nil, err
  1611  	}
  1612  	return dAtA[:n], nil
  1613  }
  1614  
  1615  func (m *ServiceReference) MarshalTo(dAtA []byte) (int, error) {
  1616  	size := m.Size()
  1617  	return m.MarshalToSizedBuffer(dAtA[:size])
  1618  }
  1619  
  1620  func (m *ServiceReference) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1621  	i := len(dAtA)
  1622  	_ = i
  1623  	var l int
  1624  	_ = l
  1625  	if m.Port != nil {
  1626  		i = encodeVarintGenerated(dAtA, i, uint64(*m.Port))
  1627  		i--
  1628  		dAtA[i] = 0x20
  1629  	}
  1630  	if m.Path != nil {
  1631  		i -= len(*m.Path)
  1632  		copy(dAtA[i:], *m.Path)
  1633  		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Path)))
  1634  		i--
  1635  		dAtA[i] = 0x1a
  1636  	}
  1637  	i -= len(m.Name)
  1638  	copy(dAtA[i:], m.Name)
  1639  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
  1640  	i--
  1641  	dAtA[i] = 0x12
  1642  	i -= len(m.Namespace)
  1643  	copy(dAtA[i:], m.Namespace)
  1644  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Namespace)))
  1645  	i--
  1646  	dAtA[i] = 0xa
  1647  	return len(dAtA) - i, nil
  1648  }
  1649  
  1650  func (m *TypeChecking) Marshal() (dAtA []byte, err error) {
  1651  	size := m.Size()
  1652  	dAtA = make([]byte, size)
  1653  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1654  	if err != nil {
  1655  		return nil, err
  1656  	}
  1657  	return dAtA[:n], nil
  1658  }
  1659  
  1660  func (m *TypeChecking) MarshalTo(dAtA []byte) (int, error) {
  1661  	size := m.Size()
  1662  	return m.MarshalToSizedBuffer(dAtA[:size])
  1663  }
  1664  
  1665  func (m *TypeChecking) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1666  	i := len(dAtA)
  1667  	_ = i
  1668  	var l int
  1669  	_ = l
  1670  	if len(m.ExpressionWarnings) > 0 {
  1671  		for iNdEx := len(m.ExpressionWarnings) - 1; iNdEx >= 0; iNdEx-- {
  1672  			{
  1673  				size, err := m.ExpressionWarnings[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  1674  				if err != nil {
  1675  					return 0, err
  1676  				}
  1677  				i -= size
  1678  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  1679  			}
  1680  			i--
  1681  			dAtA[i] = 0xa
  1682  		}
  1683  	}
  1684  	return len(dAtA) - i, nil
  1685  }
  1686  
  1687  func (m *ValidatingAdmissionPolicy) Marshal() (dAtA []byte, err error) {
  1688  	size := m.Size()
  1689  	dAtA = make([]byte, size)
  1690  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1691  	if err != nil {
  1692  		return nil, err
  1693  	}
  1694  	return dAtA[:n], nil
  1695  }
  1696  
  1697  func (m *ValidatingAdmissionPolicy) MarshalTo(dAtA []byte) (int, error) {
  1698  	size := m.Size()
  1699  	return m.MarshalToSizedBuffer(dAtA[:size])
  1700  }
  1701  
  1702  func (m *ValidatingAdmissionPolicy) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1703  	i := len(dAtA)
  1704  	_ = i
  1705  	var l int
  1706  	_ = l
  1707  	{
  1708  		size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
  1709  		if err != nil {
  1710  			return 0, err
  1711  		}
  1712  		i -= size
  1713  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  1714  	}
  1715  	i--
  1716  	dAtA[i] = 0x1a
  1717  	{
  1718  		size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
  1719  		if err != nil {
  1720  			return 0, err
  1721  		}
  1722  		i -= size
  1723  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  1724  	}
  1725  	i--
  1726  	dAtA[i] = 0x12
  1727  	{
  1728  		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
  1729  		if err != nil {
  1730  			return 0, err
  1731  		}
  1732  		i -= size
  1733  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  1734  	}
  1735  	i--
  1736  	dAtA[i] = 0xa
  1737  	return len(dAtA) - i, nil
  1738  }
  1739  
  1740  func (m *ValidatingAdmissionPolicyBinding) Marshal() (dAtA []byte, err error) {
  1741  	size := m.Size()
  1742  	dAtA = make([]byte, size)
  1743  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1744  	if err != nil {
  1745  		return nil, err
  1746  	}
  1747  	return dAtA[:n], nil
  1748  }
  1749  
  1750  func (m *ValidatingAdmissionPolicyBinding) MarshalTo(dAtA []byte) (int, error) {
  1751  	size := m.Size()
  1752  	return m.MarshalToSizedBuffer(dAtA[:size])
  1753  }
  1754  
  1755  func (m *ValidatingAdmissionPolicyBinding) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1756  	i := len(dAtA)
  1757  	_ = i
  1758  	var l int
  1759  	_ = l
  1760  	{
  1761  		size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
  1762  		if err != nil {
  1763  			return 0, err
  1764  		}
  1765  		i -= size
  1766  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  1767  	}
  1768  	i--
  1769  	dAtA[i] = 0x12
  1770  	{
  1771  		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
  1772  		if err != nil {
  1773  			return 0, err
  1774  		}
  1775  		i -= size
  1776  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  1777  	}
  1778  	i--
  1779  	dAtA[i] = 0xa
  1780  	return len(dAtA) - i, nil
  1781  }
  1782  
  1783  func (m *ValidatingAdmissionPolicyBindingList) Marshal() (dAtA []byte, err error) {
  1784  	size := m.Size()
  1785  	dAtA = make([]byte, size)
  1786  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1787  	if err != nil {
  1788  		return nil, err
  1789  	}
  1790  	return dAtA[:n], nil
  1791  }
  1792  
  1793  func (m *ValidatingAdmissionPolicyBindingList) MarshalTo(dAtA []byte) (int, error) {
  1794  	size := m.Size()
  1795  	return m.MarshalToSizedBuffer(dAtA[:size])
  1796  }
  1797  
  1798  func (m *ValidatingAdmissionPolicyBindingList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1799  	i := len(dAtA)
  1800  	_ = i
  1801  	var l int
  1802  	_ = l
  1803  	if len(m.Items) > 0 {
  1804  		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
  1805  			{
  1806  				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  1807  				if err != nil {
  1808  					return 0, err
  1809  				}
  1810  				i -= size
  1811  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  1812  			}
  1813  			i--
  1814  			dAtA[i] = 0x12
  1815  		}
  1816  	}
  1817  	{
  1818  		size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
  1819  		if err != nil {
  1820  			return 0, err
  1821  		}
  1822  		i -= size
  1823  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  1824  	}
  1825  	i--
  1826  	dAtA[i] = 0xa
  1827  	return len(dAtA) - i, nil
  1828  }
  1829  
  1830  func (m *ValidatingAdmissionPolicyBindingSpec) Marshal() (dAtA []byte, err error) {
  1831  	size := m.Size()
  1832  	dAtA = make([]byte, size)
  1833  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1834  	if err != nil {
  1835  		return nil, err
  1836  	}
  1837  	return dAtA[:n], nil
  1838  }
  1839  
  1840  func (m *ValidatingAdmissionPolicyBindingSpec) MarshalTo(dAtA []byte) (int, error) {
  1841  	size := m.Size()
  1842  	return m.MarshalToSizedBuffer(dAtA[:size])
  1843  }
  1844  
  1845  func (m *ValidatingAdmissionPolicyBindingSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1846  	i := len(dAtA)
  1847  	_ = i
  1848  	var l int
  1849  	_ = l
  1850  	if len(m.ValidationActions) > 0 {
  1851  		for iNdEx := len(m.ValidationActions) - 1; iNdEx >= 0; iNdEx-- {
  1852  			i -= len(m.ValidationActions[iNdEx])
  1853  			copy(dAtA[i:], m.ValidationActions[iNdEx])
  1854  			i = encodeVarintGenerated(dAtA, i, uint64(len(m.ValidationActions[iNdEx])))
  1855  			i--
  1856  			dAtA[i] = 0x22
  1857  		}
  1858  	}
  1859  	if m.MatchResources != nil {
  1860  		{
  1861  			size, err := m.MatchResources.MarshalToSizedBuffer(dAtA[:i])
  1862  			if err != nil {
  1863  				return 0, err
  1864  			}
  1865  			i -= size
  1866  			i = encodeVarintGenerated(dAtA, i, uint64(size))
  1867  		}
  1868  		i--
  1869  		dAtA[i] = 0x1a
  1870  	}
  1871  	if m.ParamRef != nil {
  1872  		{
  1873  			size, err := m.ParamRef.MarshalToSizedBuffer(dAtA[:i])
  1874  			if err != nil {
  1875  				return 0, err
  1876  			}
  1877  			i -= size
  1878  			i = encodeVarintGenerated(dAtA, i, uint64(size))
  1879  		}
  1880  		i--
  1881  		dAtA[i] = 0x12
  1882  	}
  1883  	i -= len(m.PolicyName)
  1884  	copy(dAtA[i:], m.PolicyName)
  1885  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.PolicyName)))
  1886  	i--
  1887  	dAtA[i] = 0xa
  1888  	return len(dAtA) - i, nil
  1889  }
  1890  
  1891  func (m *ValidatingAdmissionPolicyList) Marshal() (dAtA []byte, err error) {
  1892  	size := m.Size()
  1893  	dAtA = make([]byte, size)
  1894  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1895  	if err != nil {
  1896  		return nil, err
  1897  	}
  1898  	return dAtA[:n], nil
  1899  }
  1900  
  1901  func (m *ValidatingAdmissionPolicyList) MarshalTo(dAtA []byte) (int, error) {
  1902  	size := m.Size()
  1903  	return m.MarshalToSizedBuffer(dAtA[:size])
  1904  }
  1905  
  1906  func (m *ValidatingAdmissionPolicyList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1907  	i := len(dAtA)
  1908  	_ = i
  1909  	var l int
  1910  	_ = l
  1911  	if len(m.Items) > 0 {
  1912  		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
  1913  			{
  1914  				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  1915  				if err != nil {
  1916  					return 0, err
  1917  				}
  1918  				i -= size
  1919  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  1920  			}
  1921  			i--
  1922  			dAtA[i] = 0x12
  1923  		}
  1924  	}
  1925  	{
  1926  		size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
  1927  		if err != nil {
  1928  			return 0, err
  1929  		}
  1930  		i -= size
  1931  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  1932  	}
  1933  	i--
  1934  	dAtA[i] = 0xa
  1935  	return len(dAtA) - i, nil
  1936  }
  1937  
  1938  func (m *ValidatingAdmissionPolicySpec) Marshal() (dAtA []byte, err error) {
  1939  	size := m.Size()
  1940  	dAtA = make([]byte, size)
  1941  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1942  	if err != nil {
  1943  		return nil, err
  1944  	}
  1945  	return dAtA[:n], nil
  1946  }
  1947  
  1948  func (m *ValidatingAdmissionPolicySpec) MarshalTo(dAtA []byte) (int, error) {
  1949  	size := m.Size()
  1950  	return m.MarshalToSizedBuffer(dAtA[:size])
  1951  }
  1952  
  1953  func (m *ValidatingAdmissionPolicySpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1954  	i := len(dAtA)
  1955  	_ = i
  1956  	var l int
  1957  	_ = l
  1958  	if len(m.Variables) > 0 {
  1959  		for iNdEx := len(m.Variables) - 1; iNdEx >= 0; iNdEx-- {
  1960  			{
  1961  				size, err := m.Variables[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  1962  				if err != nil {
  1963  					return 0, err
  1964  				}
  1965  				i -= size
  1966  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  1967  			}
  1968  			i--
  1969  			dAtA[i] = 0x3a
  1970  		}
  1971  	}
  1972  	if len(m.MatchConditions) > 0 {
  1973  		for iNdEx := len(m.MatchConditions) - 1; iNdEx >= 0; iNdEx-- {
  1974  			{
  1975  				size, err := m.MatchConditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  1976  				if err != nil {
  1977  					return 0, err
  1978  				}
  1979  				i -= size
  1980  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  1981  			}
  1982  			i--
  1983  			dAtA[i] = 0x32
  1984  		}
  1985  	}
  1986  	if len(m.AuditAnnotations) > 0 {
  1987  		for iNdEx := len(m.AuditAnnotations) - 1; iNdEx >= 0; iNdEx-- {
  1988  			{
  1989  				size, err := m.AuditAnnotations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  1990  				if err != nil {
  1991  					return 0, err
  1992  				}
  1993  				i -= size
  1994  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  1995  			}
  1996  			i--
  1997  			dAtA[i] = 0x2a
  1998  		}
  1999  	}
  2000  	if m.FailurePolicy != nil {
  2001  		i -= len(*m.FailurePolicy)
  2002  		copy(dAtA[i:], *m.FailurePolicy)
  2003  		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.FailurePolicy)))
  2004  		i--
  2005  		dAtA[i] = 0x22
  2006  	}
  2007  	if len(m.Validations) > 0 {
  2008  		for iNdEx := len(m.Validations) - 1; iNdEx >= 0; iNdEx-- {
  2009  			{
  2010  				size, err := m.Validations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  2011  				if err != nil {
  2012  					return 0, err
  2013  				}
  2014  				i -= size
  2015  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  2016  			}
  2017  			i--
  2018  			dAtA[i] = 0x1a
  2019  		}
  2020  	}
  2021  	if m.MatchConstraints != nil {
  2022  		{
  2023  			size, err := m.MatchConstraints.MarshalToSizedBuffer(dAtA[:i])
  2024  			if err != nil {
  2025  				return 0, err
  2026  			}
  2027  			i -= size
  2028  			i = encodeVarintGenerated(dAtA, i, uint64(size))
  2029  		}
  2030  		i--
  2031  		dAtA[i] = 0x12
  2032  	}
  2033  	if m.ParamKind != nil {
  2034  		{
  2035  			size, err := m.ParamKind.MarshalToSizedBuffer(dAtA[:i])
  2036  			if err != nil {
  2037  				return 0, err
  2038  			}
  2039  			i -= size
  2040  			i = encodeVarintGenerated(dAtA, i, uint64(size))
  2041  		}
  2042  		i--
  2043  		dAtA[i] = 0xa
  2044  	}
  2045  	return len(dAtA) - i, nil
  2046  }
  2047  
  2048  func (m *ValidatingAdmissionPolicyStatus) Marshal() (dAtA []byte, err error) {
  2049  	size := m.Size()
  2050  	dAtA = make([]byte, size)
  2051  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2052  	if err != nil {
  2053  		return nil, err
  2054  	}
  2055  	return dAtA[:n], nil
  2056  }
  2057  
  2058  func (m *ValidatingAdmissionPolicyStatus) MarshalTo(dAtA []byte) (int, error) {
  2059  	size := m.Size()
  2060  	return m.MarshalToSizedBuffer(dAtA[:size])
  2061  }
  2062  
  2063  func (m *ValidatingAdmissionPolicyStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2064  	i := len(dAtA)
  2065  	_ = i
  2066  	var l int
  2067  	_ = l
  2068  	if len(m.Conditions) > 0 {
  2069  		for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- {
  2070  			{
  2071  				size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  2072  				if err != nil {
  2073  					return 0, err
  2074  				}
  2075  				i -= size
  2076  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  2077  			}
  2078  			i--
  2079  			dAtA[i] = 0x1a
  2080  		}
  2081  	}
  2082  	if m.TypeChecking != nil {
  2083  		{
  2084  			size, err := m.TypeChecking.MarshalToSizedBuffer(dAtA[:i])
  2085  			if err != nil {
  2086  				return 0, err
  2087  			}
  2088  			i -= size
  2089  			i = encodeVarintGenerated(dAtA, i, uint64(size))
  2090  		}
  2091  		i--
  2092  		dAtA[i] = 0x12
  2093  	}
  2094  	i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration))
  2095  	i--
  2096  	dAtA[i] = 0x8
  2097  	return len(dAtA) - i, nil
  2098  }
  2099  
  2100  func (m *ValidatingWebhook) Marshal() (dAtA []byte, err error) {
  2101  	size := m.Size()
  2102  	dAtA = make([]byte, size)
  2103  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2104  	if err != nil {
  2105  		return nil, err
  2106  	}
  2107  	return dAtA[:n], nil
  2108  }
  2109  
  2110  func (m *ValidatingWebhook) MarshalTo(dAtA []byte) (int, error) {
  2111  	size := m.Size()
  2112  	return m.MarshalToSizedBuffer(dAtA[:size])
  2113  }
  2114  
  2115  func (m *ValidatingWebhook) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2116  	i := len(dAtA)
  2117  	_ = i
  2118  	var l int
  2119  	_ = l
  2120  	if len(m.MatchConditions) > 0 {
  2121  		for iNdEx := len(m.MatchConditions) - 1; iNdEx >= 0; iNdEx-- {
  2122  			{
  2123  				size, err := m.MatchConditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  2124  				if err != nil {
  2125  					return 0, err
  2126  				}
  2127  				i -= size
  2128  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  2129  			}
  2130  			i--
  2131  			dAtA[i] = 0x5a
  2132  		}
  2133  	}
  2134  	if m.ObjectSelector != nil {
  2135  		{
  2136  			size, err := m.ObjectSelector.MarshalToSizedBuffer(dAtA[:i])
  2137  			if err != nil {
  2138  				return 0, err
  2139  			}
  2140  			i -= size
  2141  			i = encodeVarintGenerated(dAtA, i, uint64(size))
  2142  		}
  2143  		i--
  2144  		dAtA[i] = 0x52
  2145  	}
  2146  	if m.MatchPolicy != nil {
  2147  		i -= len(*m.MatchPolicy)
  2148  		copy(dAtA[i:], *m.MatchPolicy)
  2149  		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.MatchPolicy)))
  2150  		i--
  2151  		dAtA[i] = 0x4a
  2152  	}
  2153  	if len(m.AdmissionReviewVersions) > 0 {
  2154  		for iNdEx := len(m.AdmissionReviewVersions) - 1; iNdEx >= 0; iNdEx-- {
  2155  			i -= len(m.AdmissionReviewVersions[iNdEx])
  2156  			copy(dAtA[i:], m.AdmissionReviewVersions[iNdEx])
  2157  			i = encodeVarintGenerated(dAtA, i, uint64(len(m.AdmissionReviewVersions[iNdEx])))
  2158  			i--
  2159  			dAtA[i] = 0x42
  2160  		}
  2161  	}
  2162  	if m.TimeoutSeconds != nil {
  2163  		i = encodeVarintGenerated(dAtA, i, uint64(*m.TimeoutSeconds))
  2164  		i--
  2165  		dAtA[i] = 0x38
  2166  	}
  2167  	if m.SideEffects != nil {
  2168  		i -= len(*m.SideEffects)
  2169  		copy(dAtA[i:], *m.SideEffects)
  2170  		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.SideEffects)))
  2171  		i--
  2172  		dAtA[i] = 0x32
  2173  	}
  2174  	if m.NamespaceSelector != nil {
  2175  		{
  2176  			size, err := m.NamespaceSelector.MarshalToSizedBuffer(dAtA[:i])
  2177  			if err != nil {
  2178  				return 0, err
  2179  			}
  2180  			i -= size
  2181  			i = encodeVarintGenerated(dAtA, i, uint64(size))
  2182  		}
  2183  		i--
  2184  		dAtA[i] = 0x2a
  2185  	}
  2186  	if m.FailurePolicy != nil {
  2187  		i -= len(*m.FailurePolicy)
  2188  		copy(dAtA[i:], *m.FailurePolicy)
  2189  		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.FailurePolicy)))
  2190  		i--
  2191  		dAtA[i] = 0x22
  2192  	}
  2193  	if len(m.Rules) > 0 {
  2194  		for iNdEx := len(m.Rules) - 1; iNdEx >= 0; iNdEx-- {
  2195  			{
  2196  				size, err := m.Rules[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  2197  				if err != nil {
  2198  					return 0, err
  2199  				}
  2200  				i -= size
  2201  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  2202  			}
  2203  			i--
  2204  			dAtA[i] = 0x1a
  2205  		}
  2206  	}
  2207  	{
  2208  		size, err := m.ClientConfig.MarshalToSizedBuffer(dAtA[:i])
  2209  		if err != nil {
  2210  			return 0, err
  2211  		}
  2212  		i -= size
  2213  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  2214  	}
  2215  	i--
  2216  	dAtA[i] = 0x12
  2217  	i -= len(m.Name)
  2218  	copy(dAtA[i:], m.Name)
  2219  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
  2220  	i--
  2221  	dAtA[i] = 0xa
  2222  	return len(dAtA) - i, nil
  2223  }
  2224  
  2225  func (m *ValidatingWebhookConfiguration) Marshal() (dAtA []byte, err error) {
  2226  	size := m.Size()
  2227  	dAtA = make([]byte, size)
  2228  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2229  	if err != nil {
  2230  		return nil, err
  2231  	}
  2232  	return dAtA[:n], nil
  2233  }
  2234  
  2235  func (m *ValidatingWebhookConfiguration) MarshalTo(dAtA []byte) (int, error) {
  2236  	size := m.Size()
  2237  	return m.MarshalToSizedBuffer(dAtA[:size])
  2238  }
  2239  
  2240  func (m *ValidatingWebhookConfiguration) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2241  	i := len(dAtA)
  2242  	_ = i
  2243  	var l int
  2244  	_ = l
  2245  	if len(m.Webhooks) > 0 {
  2246  		for iNdEx := len(m.Webhooks) - 1; iNdEx >= 0; iNdEx-- {
  2247  			{
  2248  				size, err := m.Webhooks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  2249  				if err != nil {
  2250  					return 0, err
  2251  				}
  2252  				i -= size
  2253  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  2254  			}
  2255  			i--
  2256  			dAtA[i] = 0x12
  2257  		}
  2258  	}
  2259  	{
  2260  		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
  2261  		if err != nil {
  2262  			return 0, err
  2263  		}
  2264  		i -= size
  2265  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  2266  	}
  2267  	i--
  2268  	dAtA[i] = 0xa
  2269  	return len(dAtA) - i, nil
  2270  }
  2271  
  2272  func (m *ValidatingWebhookConfigurationList) Marshal() (dAtA []byte, err error) {
  2273  	size := m.Size()
  2274  	dAtA = make([]byte, size)
  2275  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2276  	if err != nil {
  2277  		return nil, err
  2278  	}
  2279  	return dAtA[:n], nil
  2280  }
  2281  
  2282  func (m *ValidatingWebhookConfigurationList) MarshalTo(dAtA []byte) (int, error) {
  2283  	size := m.Size()
  2284  	return m.MarshalToSizedBuffer(dAtA[:size])
  2285  }
  2286  
  2287  func (m *ValidatingWebhookConfigurationList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2288  	i := len(dAtA)
  2289  	_ = i
  2290  	var l int
  2291  	_ = l
  2292  	if len(m.Items) > 0 {
  2293  		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
  2294  			{
  2295  				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  2296  				if err != nil {
  2297  					return 0, err
  2298  				}
  2299  				i -= size
  2300  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  2301  			}
  2302  			i--
  2303  			dAtA[i] = 0x12
  2304  		}
  2305  	}
  2306  	{
  2307  		size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
  2308  		if err != nil {
  2309  			return 0, err
  2310  		}
  2311  		i -= size
  2312  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  2313  	}
  2314  	i--
  2315  	dAtA[i] = 0xa
  2316  	return len(dAtA) - i, nil
  2317  }
  2318  
  2319  func (m *Validation) Marshal() (dAtA []byte, err error) {
  2320  	size := m.Size()
  2321  	dAtA = make([]byte, size)
  2322  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2323  	if err != nil {
  2324  		return nil, err
  2325  	}
  2326  	return dAtA[:n], nil
  2327  }
  2328  
  2329  func (m *Validation) MarshalTo(dAtA []byte) (int, error) {
  2330  	size := m.Size()
  2331  	return m.MarshalToSizedBuffer(dAtA[:size])
  2332  }
  2333  
  2334  func (m *Validation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2335  	i := len(dAtA)
  2336  	_ = i
  2337  	var l int
  2338  	_ = l
  2339  	i -= len(m.MessageExpression)
  2340  	copy(dAtA[i:], m.MessageExpression)
  2341  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.MessageExpression)))
  2342  	i--
  2343  	dAtA[i] = 0x22
  2344  	if m.Reason != nil {
  2345  		i -= len(*m.Reason)
  2346  		copy(dAtA[i:], *m.Reason)
  2347  		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Reason)))
  2348  		i--
  2349  		dAtA[i] = 0x1a
  2350  	}
  2351  	i -= len(m.Message)
  2352  	copy(dAtA[i:], m.Message)
  2353  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
  2354  	i--
  2355  	dAtA[i] = 0x12
  2356  	i -= len(m.Expression)
  2357  	copy(dAtA[i:], m.Expression)
  2358  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Expression)))
  2359  	i--
  2360  	dAtA[i] = 0xa
  2361  	return len(dAtA) - i, nil
  2362  }
  2363  
  2364  func (m *Variable) Marshal() (dAtA []byte, err error) {
  2365  	size := m.Size()
  2366  	dAtA = make([]byte, size)
  2367  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2368  	if err != nil {
  2369  		return nil, err
  2370  	}
  2371  	return dAtA[:n], nil
  2372  }
  2373  
  2374  func (m *Variable) MarshalTo(dAtA []byte) (int, error) {
  2375  	size := m.Size()
  2376  	return m.MarshalToSizedBuffer(dAtA[:size])
  2377  }
  2378  
  2379  func (m *Variable) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2380  	i := len(dAtA)
  2381  	_ = i
  2382  	var l int
  2383  	_ = l
  2384  	i -= len(m.Expression)
  2385  	copy(dAtA[i:], m.Expression)
  2386  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Expression)))
  2387  	i--
  2388  	dAtA[i] = 0x12
  2389  	i -= len(m.Name)
  2390  	copy(dAtA[i:], m.Name)
  2391  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
  2392  	i--
  2393  	dAtA[i] = 0xa
  2394  	return len(dAtA) - i, nil
  2395  }
  2396  
  2397  func (m *WebhookClientConfig) Marshal() (dAtA []byte, err error) {
  2398  	size := m.Size()
  2399  	dAtA = make([]byte, size)
  2400  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2401  	if err != nil {
  2402  		return nil, err
  2403  	}
  2404  	return dAtA[:n], nil
  2405  }
  2406  
  2407  func (m *WebhookClientConfig) MarshalTo(dAtA []byte) (int, error) {
  2408  	size := m.Size()
  2409  	return m.MarshalToSizedBuffer(dAtA[:size])
  2410  }
  2411  
  2412  func (m *WebhookClientConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2413  	i := len(dAtA)
  2414  	_ = i
  2415  	var l int
  2416  	_ = l
  2417  	if m.URL != nil {
  2418  		i -= len(*m.URL)
  2419  		copy(dAtA[i:], *m.URL)
  2420  		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.URL)))
  2421  		i--
  2422  		dAtA[i] = 0x1a
  2423  	}
  2424  	if m.CABundle != nil {
  2425  		i -= len(m.CABundle)
  2426  		copy(dAtA[i:], m.CABundle)
  2427  		i = encodeVarintGenerated(dAtA, i, uint64(len(m.CABundle)))
  2428  		i--
  2429  		dAtA[i] = 0x12
  2430  	}
  2431  	if m.Service != nil {
  2432  		{
  2433  			size, err := m.Service.MarshalToSizedBuffer(dAtA[:i])
  2434  			if err != nil {
  2435  				return 0, err
  2436  			}
  2437  			i -= size
  2438  			i = encodeVarintGenerated(dAtA, i, uint64(size))
  2439  		}
  2440  		i--
  2441  		dAtA[i] = 0xa
  2442  	}
  2443  	return len(dAtA) - i, nil
  2444  }
  2445  
  2446  func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
  2447  	offset -= sovGenerated(v)
  2448  	base := offset
  2449  	for v >= 1<<7 {
  2450  		dAtA[offset] = uint8(v&0x7f | 0x80)
  2451  		v >>= 7
  2452  		offset++
  2453  	}
  2454  	dAtA[offset] = uint8(v)
  2455  	return base
  2456  }
  2457  func (m *AuditAnnotation) Size() (n int) {
  2458  	if m == nil {
  2459  		return 0
  2460  	}
  2461  	var l int
  2462  	_ = l
  2463  	l = len(m.Key)
  2464  	n += 1 + l + sovGenerated(uint64(l))
  2465  	l = len(m.ValueExpression)
  2466  	n += 1 + l + sovGenerated(uint64(l))
  2467  	return n
  2468  }
  2469  
  2470  func (m *ExpressionWarning) Size() (n int) {
  2471  	if m == nil {
  2472  		return 0
  2473  	}
  2474  	var l int
  2475  	_ = l
  2476  	l = len(m.FieldRef)
  2477  	n += 1 + l + sovGenerated(uint64(l))
  2478  	l = len(m.Warning)
  2479  	n += 1 + l + sovGenerated(uint64(l))
  2480  	return n
  2481  }
  2482  
  2483  func (m *MatchCondition) Size() (n int) {
  2484  	if m == nil {
  2485  		return 0
  2486  	}
  2487  	var l int
  2488  	_ = l
  2489  	l = len(m.Name)
  2490  	n += 1 + l + sovGenerated(uint64(l))
  2491  	l = len(m.Expression)
  2492  	n += 1 + l + sovGenerated(uint64(l))
  2493  	return n
  2494  }
  2495  
  2496  func (m *MatchResources) Size() (n int) {
  2497  	if m == nil {
  2498  		return 0
  2499  	}
  2500  	var l int
  2501  	_ = l
  2502  	if m.NamespaceSelector != nil {
  2503  		l = m.NamespaceSelector.Size()
  2504  		n += 1 + l + sovGenerated(uint64(l))
  2505  	}
  2506  	if m.ObjectSelector != nil {
  2507  		l = m.ObjectSelector.Size()
  2508  		n += 1 + l + sovGenerated(uint64(l))
  2509  	}
  2510  	if len(m.ResourceRules) > 0 {
  2511  		for _, e := range m.ResourceRules {
  2512  			l = e.Size()
  2513  			n += 1 + l + sovGenerated(uint64(l))
  2514  		}
  2515  	}
  2516  	if len(m.ExcludeResourceRules) > 0 {
  2517  		for _, e := range m.ExcludeResourceRules {
  2518  			l = e.Size()
  2519  			n += 1 + l + sovGenerated(uint64(l))
  2520  		}
  2521  	}
  2522  	if m.MatchPolicy != nil {
  2523  		l = len(*m.MatchPolicy)
  2524  		n += 1 + l + sovGenerated(uint64(l))
  2525  	}
  2526  	return n
  2527  }
  2528  
  2529  func (m *MutatingWebhook) Size() (n int) {
  2530  	if m == nil {
  2531  		return 0
  2532  	}
  2533  	var l int
  2534  	_ = l
  2535  	l = len(m.Name)
  2536  	n += 1 + l + sovGenerated(uint64(l))
  2537  	l = m.ClientConfig.Size()
  2538  	n += 1 + l + sovGenerated(uint64(l))
  2539  	if len(m.Rules) > 0 {
  2540  		for _, e := range m.Rules {
  2541  			l = e.Size()
  2542  			n += 1 + l + sovGenerated(uint64(l))
  2543  		}
  2544  	}
  2545  	if m.FailurePolicy != nil {
  2546  		l = len(*m.FailurePolicy)
  2547  		n += 1 + l + sovGenerated(uint64(l))
  2548  	}
  2549  	if m.NamespaceSelector != nil {
  2550  		l = m.NamespaceSelector.Size()
  2551  		n += 1 + l + sovGenerated(uint64(l))
  2552  	}
  2553  	if m.SideEffects != nil {
  2554  		l = len(*m.SideEffects)
  2555  		n += 1 + l + sovGenerated(uint64(l))
  2556  	}
  2557  	if m.TimeoutSeconds != nil {
  2558  		n += 1 + sovGenerated(uint64(*m.TimeoutSeconds))
  2559  	}
  2560  	if len(m.AdmissionReviewVersions) > 0 {
  2561  		for _, s := range m.AdmissionReviewVersions {
  2562  			l = len(s)
  2563  			n += 1 + l + sovGenerated(uint64(l))
  2564  		}
  2565  	}
  2566  	if m.MatchPolicy != nil {
  2567  		l = len(*m.MatchPolicy)
  2568  		n += 1 + l + sovGenerated(uint64(l))
  2569  	}
  2570  	if m.ReinvocationPolicy != nil {
  2571  		l = len(*m.ReinvocationPolicy)
  2572  		n += 1 + l + sovGenerated(uint64(l))
  2573  	}
  2574  	if m.ObjectSelector != nil {
  2575  		l = m.ObjectSelector.Size()
  2576  		n += 1 + l + sovGenerated(uint64(l))
  2577  	}
  2578  	if len(m.MatchConditions) > 0 {
  2579  		for _, e := range m.MatchConditions {
  2580  			l = e.Size()
  2581  			n += 1 + l + sovGenerated(uint64(l))
  2582  		}
  2583  	}
  2584  	return n
  2585  }
  2586  
  2587  func (m *MutatingWebhookConfiguration) Size() (n int) {
  2588  	if m == nil {
  2589  		return 0
  2590  	}
  2591  	var l int
  2592  	_ = l
  2593  	l = m.ObjectMeta.Size()
  2594  	n += 1 + l + sovGenerated(uint64(l))
  2595  	if len(m.Webhooks) > 0 {
  2596  		for _, e := range m.Webhooks {
  2597  			l = e.Size()
  2598  			n += 1 + l + sovGenerated(uint64(l))
  2599  		}
  2600  	}
  2601  	return n
  2602  }
  2603  
  2604  func (m *MutatingWebhookConfigurationList) Size() (n int) {
  2605  	if m == nil {
  2606  		return 0
  2607  	}
  2608  	var l int
  2609  	_ = l
  2610  	l = m.ListMeta.Size()
  2611  	n += 1 + l + sovGenerated(uint64(l))
  2612  	if len(m.Items) > 0 {
  2613  		for _, e := range m.Items {
  2614  			l = e.Size()
  2615  			n += 1 + l + sovGenerated(uint64(l))
  2616  		}
  2617  	}
  2618  	return n
  2619  }
  2620  
  2621  func (m *NamedRuleWithOperations) Size() (n int) {
  2622  	if m == nil {
  2623  		return 0
  2624  	}
  2625  	var l int
  2626  	_ = l
  2627  	if len(m.ResourceNames) > 0 {
  2628  		for _, s := range m.ResourceNames {
  2629  			l = len(s)
  2630  			n += 1 + l + sovGenerated(uint64(l))
  2631  		}
  2632  	}
  2633  	l = m.RuleWithOperations.Size()
  2634  	n += 1 + l + sovGenerated(uint64(l))
  2635  	return n
  2636  }
  2637  
  2638  func (m *ParamKind) Size() (n int) {
  2639  	if m == nil {
  2640  		return 0
  2641  	}
  2642  	var l int
  2643  	_ = l
  2644  	l = len(m.APIVersion)
  2645  	n += 1 + l + sovGenerated(uint64(l))
  2646  	l = len(m.Kind)
  2647  	n += 1 + l + sovGenerated(uint64(l))
  2648  	return n
  2649  }
  2650  
  2651  func (m *ParamRef) Size() (n int) {
  2652  	if m == nil {
  2653  		return 0
  2654  	}
  2655  	var l int
  2656  	_ = l
  2657  	l = len(m.Name)
  2658  	n += 1 + l + sovGenerated(uint64(l))
  2659  	l = len(m.Namespace)
  2660  	n += 1 + l + sovGenerated(uint64(l))
  2661  	if m.Selector != nil {
  2662  		l = m.Selector.Size()
  2663  		n += 1 + l + sovGenerated(uint64(l))
  2664  	}
  2665  	if m.ParameterNotFoundAction != nil {
  2666  		l = len(*m.ParameterNotFoundAction)
  2667  		n += 1 + l + sovGenerated(uint64(l))
  2668  	}
  2669  	return n
  2670  }
  2671  
  2672  func (m *Rule) Size() (n int) {
  2673  	if m == nil {
  2674  		return 0
  2675  	}
  2676  	var l int
  2677  	_ = l
  2678  	if len(m.APIGroups) > 0 {
  2679  		for _, s := range m.APIGroups {
  2680  			l = len(s)
  2681  			n += 1 + l + sovGenerated(uint64(l))
  2682  		}
  2683  	}
  2684  	if len(m.APIVersions) > 0 {
  2685  		for _, s := range m.APIVersions {
  2686  			l = len(s)
  2687  			n += 1 + l + sovGenerated(uint64(l))
  2688  		}
  2689  	}
  2690  	if len(m.Resources) > 0 {
  2691  		for _, s := range m.Resources {
  2692  			l = len(s)
  2693  			n += 1 + l + sovGenerated(uint64(l))
  2694  		}
  2695  	}
  2696  	if m.Scope != nil {
  2697  		l = len(*m.Scope)
  2698  		n += 1 + l + sovGenerated(uint64(l))
  2699  	}
  2700  	return n
  2701  }
  2702  
  2703  func (m *RuleWithOperations) Size() (n int) {
  2704  	if m == nil {
  2705  		return 0
  2706  	}
  2707  	var l int
  2708  	_ = l
  2709  	if len(m.Operations) > 0 {
  2710  		for _, s := range m.Operations {
  2711  			l = len(s)
  2712  			n += 1 + l + sovGenerated(uint64(l))
  2713  		}
  2714  	}
  2715  	l = m.Rule.Size()
  2716  	n += 1 + l + sovGenerated(uint64(l))
  2717  	return n
  2718  }
  2719  
  2720  func (m *ServiceReference) Size() (n int) {
  2721  	if m == nil {
  2722  		return 0
  2723  	}
  2724  	var l int
  2725  	_ = l
  2726  	l = len(m.Namespace)
  2727  	n += 1 + l + sovGenerated(uint64(l))
  2728  	l = len(m.Name)
  2729  	n += 1 + l + sovGenerated(uint64(l))
  2730  	if m.Path != nil {
  2731  		l = len(*m.Path)
  2732  		n += 1 + l + sovGenerated(uint64(l))
  2733  	}
  2734  	if m.Port != nil {
  2735  		n += 1 + sovGenerated(uint64(*m.Port))
  2736  	}
  2737  	return n
  2738  }
  2739  
  2740  func (m *TypeChecking) Size() (n int) {
  2741  	if m == nil {
  2742  		return 0
  2743  	}
  2744  	var l int
  2745  	_ = l
  2746  	if len(m.ExpressionWarnings) > 0 {
  2747  		for _, e := range m.ExpressionWarnings {
  2748  			l = e.Size()
  2749  			n += 1 + l + sovGenerated(uint64(l))
  2750  		}
  2751  	}
  2752  	return n
  2753  }
  2754  
  2755  func (m *ValidatingAdmissionPolicy) Size() (n int) {
  2756  	if m == nil {
  2757  		return 0
  2758  	}
  2759  	var l int
  2760  	_ = l
  2761  	l = m.ObjectMeta.Size()
  2762  	n += 1 + l + sovGenerated(uint64(l))
  2763  	l = m.Spec.Size()
  2764  	n += 1 + l + sovGenerated(uint64(l))
  2765  	l = m.Status.Size()
  2766  	n += 1 + l + sovGenerated(uint64(l))
  2767  	return n
  2768  }
  2769  
  2770  func (m *ValidatingAdmissionPolicyBinding) Size() (n int) {
  2771  	if m == nil {
  2772  		return 0
  2773  	}
  2774  	var l int
  2775  	_ = l
  2776  	l = m.ObjectMeta.Size()
  2777  	n += 1 + l + sovGenerated(uint64(l))
  2778  	l = m.Spec.Size()
  2779  	n += 1 + l + sovGenerated(uint64(l))
  2780  	return n
  2781  }
  2782  
  2783  func (m *ValidatingAdmissionPolicyBindingList) Size() (n int) {
  2784  	if m == nil {
  2785  		return 0
  2786  	}
  2787  	var l int
  2788  	_ = l
  2789  	l = m.ListMeta.Size()
  2790  	n += 1 + l + sovGenerated(uint64(l))
  2791  	if len(m.Items) > 0 {
  2792  		for _, e := range m.Items {
  2793  			l = e.Size()
  2794  			n += 1 + l + sovGenerated(uint64(l))
  2795  		}
  2796  	}
  2797  	return n
  2798  }
  2799  
  2800  func (m *ValidatingAdmissionPolicyBindingSpec) Size() (n int) {
  2801  	if m == nil {
  2802  		return 0
  2803  	}
  2804  	var l int
  2805  	_ = l
  2806  	l = len(m.PolicyName)
  2807  	n += 1 + l + sovGenerated(uint64(l))
  2808  	if m.ParamRef != nil {
  2809  		l = m.ParamRef.Size()
  2810  		n += 1 + l + sovGenerated(uint64(l))
  2811  	}
  2812  	if m.MatchResources != nil {
  2813  		l = m.MatchResources.Size()
  2814  		n += 1 + l + sovGenerated(uint64(l))
  2815  	}
  2816  	if len(m.ValidationActions) > 0 {
  2817  		for _, s := range m.ValidationActions {
  2818  			l = len(s)
  2819  			n += 1 + l + sovGenerated(uint64(l))
  2820  		}
  2821  	}
  2822  	return n
  2823  }
  2824  
  2825  func (m *ValidatingAdmissionPolicyList) Size() (n int) {
  2826  	if m == nil {
  2827  		return 0
  2828  	}
  2829  	var l int
  2830  	_ = l
  2831  	l = m.ListMeta.Size()
  2832  	n += 1 + l + sovGenerated(uint64(l))
  2833  	if len(m.Items) > 0 {
  2834  		for _, e := range m.Items {
  2835  			l = e.Size()
  2836  			n += 1 + l + sovGenerated(uint64(l))
  2837  		}
  2838  	}
  2839  	return n
  2840  }
  2841  
  2842  func (m *ValidatingAdmissionPolicySpec) Size() (n int) {
  2843  	if m == nil {
  2844  		return 0
  2845  	}
  2846  	var l int
  2847  	_ = l
  2848  	if m.ParamKind != nil {
  2849  		l = m.ParamKind.Size()
  2850  		n += 1 + l + sovGenerated(uint64(l))
  2851  	}
  2852  	if m.MatchConstraints != nil {
  2853  		l = m.MatchConstraints.Size()
  2854  		n += 1 + l + sovGenerated(uint64(l))
  2855  	}
  2856  	if len(m.Validations) > 0 {
  2857  		for _, e := range m.Validations {
  2858  			l = e.Size()
  2859  			n += 1 + l + sovGenerated(uint64(l))
  2860  		}
  2861  	}
  2862  	if m.FailurePolicy != nil {
  2863  		l = len(*m.FailurePolicy)
  2864  		n += 1 + l + sovGenerated(uint64(l))
  2865  	}
  2866  	if len(m.AuditAnnotations) > 0 {
  2867  		for _, e := range m.AuditAnnotations {
  2868  			l = e.Size()
  2869  			n += 1 + l + sovGenerated(uint64(l))
  2870  		}
  2871  	}
  2872  	if len(m.MatchConditions) > 0 {
  2873  		for _, e := range m.MatchConditions {
  2874  			l = e.Size()
  2875  			n += 1 + l + sovGenerated(uint64(l))
  2876  		}
  2877  	}
  2878  	if len(m.Variables) > 0 {
  2879  		for _, e := range m.Variables {
  2880  			l = e.Size()
  2881  			n += 1 + l + sovGenerated(uint64(l))
  2882  		}
  2883  	}
  2884  	return n
  2885  }
  2886  
  2887  func (m *ValidatingAdmissionPolicyStatus) Size() (n int) {
  2888  	if m == nil {
  2889  		return 0
  2890  	}
  2891  	var l int
  2892  	_ = l
  2893  	n += 1 + sovGenerated(uint64(m.ObservedGeneration))
  2894  	if m.TypeChecking != nil {
  2895  		l = m.TypeChecking.Size()
  2896  		n += 1 + l + sovGenerated(uint64(l))
  2897  	}
  2898  	if len(m.Conditions) > 0 {
  2899  		for _, e := range m.Conditions {
  2900  			l = e.Size()
  2901  			n += 1 + l + sovGenerated(uint64(l))
  2902  		}
  2903  	}
  2904  	return n
  2905  }
  2906  
  2907  func (m *ValidatingWebhook) Size() (n int) {
  2908  	if m == nil {
  2909  		return 0
  2910  	}
  2911  	var l int
  2912  	_ = l
  2913  	l = len(m.Name)
  2914  	n += 1 + l + sovGenerated(uint64(l))
  2915  	l = m.ClientConfig.Size()
  2916  	n += 1 + l + sovGenerated(uint64(l))
  2917  	if len(m.Rules) > 0 {
  2918  		for _, e := range m.Rules {
  2919  			l = e.Size()
  2920  			n += 1 + l + sovGenerated(uint64(l))
  2921  		}
  2922  	}
  2923  	if m.FailurePolicy != nil {
  2924  		l = len(*m.FailurePolicy)
  2925  		n += 1 + l + sovGenerated(uint64(l))
  2926  	}
  2927  	if m.NamespaceSelector != nil {
  2928  		l = m.NamespaceSelector.Size()
  2929  		n += 1 + l + sovGenerated(uint64(l))
  2930  	}
  2931  	if m.SideEffects != nil {
  2932  		l = len(*m.SideEffects)
  2933  		n += 1 + l + sovGenerated(uint64(l))
  2934  	}
  2935  	if m.TimeoutSeconds != nil {
  2936  		n += 1 + sovGenerated(uint64(*m.TimeoutSeconds))
  2937  	}
  2938  	if len(m.AdmissionReviewVersions) > 0 {
  2939  		for _, s := range m.AdmissionReviewVersions {
  2940  			l = len(s)
  2941  			n += 1 + l + sovGenerated(uint64(l))
  2942  		}
  2943  	}
  2944  	if m.MatchPolicy != nil {
  2945  		l = len(*m.MatchPolicy)
  2946  		n += 1 + l + sovGenerated(uint64(l))
  2947  	}
  2948  	if m.ObjectSelector != nil {
  2949  		l = m.ObjectSelector.Size()
  2950  		n += 1 + l + sovGenerated(uint64(l))
  2951  	}
  2952  	if len(m.MatchConditions) > 0 {
  2953  		for _, e := range m.MatchConditions {
  2954  			l = e.Size()
  2955  			n += 1 + l + sovGenerated(uint64(l))
  2956  		}
  2957  	}
  2958  	return n
  2959  }
  2960  
  2961  func (m *ValidatingWebhookConfiguration) Size() (n int) {
  2962  	if m == nil {
  2963  		return 0
  2964  	}
  2965  	var l int
  2966  	_ = l
  2967  	l = m.ObjectMeta.Size()
  2968  	n += 1 + l + sovGenerated(uint64(l))
  2969  	if len(m.Webhooks) > 0 {
  2970  		for _, e := range m.Webhooks {
  2971  			l = e.Size()
  2972  			n += 1 + l + sovGenerated(uint64(l))
  2973  		}
  2974  	}
  2975  	return n
  2976  }
  2977  
  2978  func (m *ValidatingWebhookConfigurationList) Size() (n int) {
  2979  	if m == nil {
  2980  		return 0
  2981  	}
  2982  	var l int
  2983  	_ = l
  2984  	l = m.ListMeta.Size()
  2985  	n += 1 + l + sovGenerated(uint64(l))
  2986  	if len(m.Items) > 0 {
  2987  		for _, e := range m.Items {
  2988  			l = e.Size()
  2989  			n += 1 + l + sovGenerated(uint64(l))
  2990  		}
  2991  	}
  2992  	return n
  2993  }
  2994  
  2995  func (m *Validation) Size() (n int) {
  2996  	if m == nil {
  2997  		return 0
  2998  	}
  2999  	var l int
  3000  	_ = l
  3001  	l = len(m.Expression)
  3002  	n += 1 + l + sovGenerated(uint64(l))
  3003  	l = len(m.Message)
  3004  	n += 1 + l + sovGenerated(uint64(l))
  3005  	if m.Reason != nil {
  3006  		l = len(*m.Reason)
  3007  		n += 1 + l + sovGenerated(uint64(l))
  3008  	}
  3009  	l = len(m.MessageExpression)
  3010  	n += 1 + l + sovGenerated(uint64(l))
  3011  	return n
  3012  }
  3013  
  3014  func (m *Variable) Size() (n int) {
  3015  	if m == nil {
  3016  		return 0
  3017  	}
  3018  	var l int
  3019  	_ = l
  3020  	l = len(m.Name)
  3021  	n += 1 + l + sovGenerated(uint64(l))
  3022  	l = len(m.Expression)
  3023  	n += 1 + l + sovGenerated(uint64(l))
  3024  	return n
  3025  }
  3026  
  3027  func (m *WebhookClientConfig) Size() (n int) {
  3028  	if m == nil {
  3029  		return 0
  3030  	}
  3031  	var l int
  3032  	_ = l
  3033  	if m.Service != nil {
  3034  		l = m.Service.Size()
  3035  		n += 1 + l + sovGenerated(uint64(l))
  3036  	}
  3037  	if m.CABundle != nil {
  3038  		l = len(m.CABundle)
  3039  		n += 1 + l + sovGenerated(uint64(l))
  3040  	}
  3041  	if m.URL != nil {
  3042  		l = len(*m.URL)
  3043  		n += 1 + l + sovGenerated(uint64(l))
  3044  	}
  3045  	return n
  3046  }
  3047  
  3048  func sovGenerated(x uint64) (n int) {
  3049  	return (math_bits.Len64(x|1) + 6) / 7
  3050  }
  3051  func sozGenerated(x uint64) (n int) {
  3052  	return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
  3053  }
  3054  func (this *AuditAnnotation) String() string {
  3055  	if this == nil {
  3056  		return "nil"
  3057  	}
  3058  	s := strings.Join([]string{`&AuditAnnotation{`,
  3059  		`Key:` + fmt.Sprintf("%v", this.Key) + `,`,
  3060  		`ValueExpression:` + fmt.Sprintf("%v", this.ValueExpression) + `,`,
  3061  		`}`,
  3062  	}, "")
  3063  	return s
  3064  }
  3065  func (this *ExpressionWarning) String() string {
  3066  	if this == nil {
  3067  		return "nil"
  3068  	}
  3069  	s := strings.Join([]string{`&ExpressionWarning{`,
  3070  		`FieldRef:` + fmt.Sprintf("%v", this.FieldRef) + `,`,
  3071  		`Warning:` + fmt.Sprintf("%v", this.Warning) + `,`,
  3072  		`}`,
  3073  	}, "")
  3074  	return s
  3075  }
  3076  func (this *MatchCondition) String() string {
  3077  	if this == nil {
  3078  		return "nil"
  3079  	}
  3080  	s := strings.Join([]string{`&MatchCondition{`,
  3081  		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
  3082  		`Expression:` + fmt.Sprintf("%v", this.Expression) + `,`,
  3083  		`}`,
  3084  	}, "")
  3085  	return s
  3086  }
  3087  func (this *MatchResources) String() string {
  3088  	if this == nil {
  3089  		return "nil"
  3090  	}
  3091  	repeatedStringForResourceRules := "[]NamedRuleWithOperations{"
  3092  	for _, f := range this.ResourceRules {
  3093  		repeatedStringForResourceRules += strings.Replace(strings.Replace(f.String(), "NamedRuleWithOperations", "NamedRuleWithOperations", 1), `&`, ``, 1) + ","
  3094  	}
  3095  	repeatedStringForResourceRules += "}"
  3096  	repeatedStringForExcludeResourceRules := "[]NamedRuleWithOperations{"
  3097  	for _, f := range this.ExcludeResourceRules {
  3098  		repeatedStringForExcludeResourceRules += strings.Replace(strings.Replace(f.String(), "NamedRuleWithOperations", "NamedRuleWithOperations", 1), `&`, ``, 1) + ","
  3099  	}
  3100  	repeatedStringForExcludeResourceRules += "}"
  3101  	s := strings.Join([]string{`&MatchResources{`,
  3102  		`NamespaceSelector:` + strings.Replace(fmt.Sprintf("%v", this.NamespaceSelector), "LabelSelector", "v1.LabelSelector", 1) + `,`,
  3103  		`ObjectSelector:` + strings.Replace(fmt.Sprintf("%v", this.ObjectSelector), "LabelSelector", "v1.LabelSelector", 1) + `,`,
  3104  		`ResourceRules:` + repeatedStringForResourceRules + `,`,
  3105  		`ExcludeResourceRules:` + repeatedStringForExcludeResourceRules + `,`,
  3106  		`MatchPolicy:` + valueToStringGenerated(this.MatchPolicy) + `,`,
  3107  		`}`,
  3108  	}, "")
  3109  	return s
  3110  }
  3111  func (this *MutatingWebhook) String() string {
  3112  	if this == nil {
  3113  		return "nil"
  3114  	}
  3115  	repeatedStringForRules := "[]RuleWithOperations{"
  3116  	for _, f := range this.Rules {
  3117  		repeatedStringForRules += strings.Replace(strings.Replace(f.String(), "RuleWithOperations", "RuleWithOperations", 1), `&`, ``, 1) + ","
  3118  	}
  3119  	repeatedStringForRules += "}"
  3120  	repeatedStringForMatchConditions := "[]MatchCondition{"
  3121  	for _, f := range this.MatchConditions {
  3122  		repeatedStringForMatchConditions += strings.Replace(strings.Replace(f.String(), "MatchCondition", "MatchCondition", 1), `&`, ``, 1) + ","
  3123  	}
  3124  	repeatedStringForMatchConditions += "}"
  3125  	s := strings.Join([]string{`&MutatingWebhook{`,
  3126  		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
  3127  		`ClientConfig:` + strings.Replace(strings.Replace(this.ClientConfig.String(), "WebhookClientConfig", "WebhookClientConfig", 1), `&`, ``, 1) + `,`,
  3128  		`Rules:` + repeatedStringForRules + `,`,
  3129  		`FailurePolicy:` + valueToStringGenerated(this.FailurePolicy) + `,`,
  3130  		`NamespaceSelector:` + strings.Replace(fmt.Sprintf("%v", this.NamespaceSelector), "LabelSelector", "v1.LabelSelector", 1) + `,`,
  3131  		`SideEffects:` + valueToStringGenerated(this.SideEffects) + `,`,
  3132  		`TimeoutSeconds:` + valueToStringGenerated(this.TimeoutSeconds) + `,`,
  3133  		`AdmissionReviewVersions:` + fmt.Sprintf("%v", this.AdmissionReviewVersions) + `,`,
  3134  		`MatchPolicy:` + valueToStringGenerated(this.MatchPolicy) + `,`,
  3135  		`ReinvocationPolicy:` + valueToStringGenerated(this.ReinvocationPolicy) + `,`,
  3136  		`ObjectSelector:` + strings.Replace(fmt.Sprintf("%v", this.ObjectSelector), "LabelSelector", "v1.LabelSelector", 1) + `,`,
  3137  		`MatchConditions:` + repeatedStringForMatchConditions + `,`,
  3138  		`}`,
  3139  	}, "")
  3140  	return s
  3141  }
  3142  func (this *MutatingWebhookConfiguration) String() string {
  3143  	if this == nil {
  3144  		return "nil"
  3145  	}
  3146  	repeatedStringForWebhooks := "[]MutatingWebhook{"
  3147  	for _, f := range this.Webhooks {
  3148  		repeatedStringForWebhooks += strings.Replace(strings.Replace(f.String(), "MutatingWebhook", "MutatingWebhook", 1), `&`, ``, 1) + ","
  3149  	}
  3150  	repeatedStringForWebhooks += "}"
  3151  	s := strings.Join([]string{`&MutatingWebhookConfiguration{`,
  3152  		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
  3153  		`Webhooks:` + repeatedStringForWebhooks + `,`,
  3154  		`}`,
  3155  	}, "")
  3156  	return s
  3157  }
  3158  func (this *MutatingWebhookConfigurationList) String() string {
  3159  	if this == nil {
  3160  		return "nil"
  3161  	}
  3162  	repeatedStringForItems := "[]MutatingWebhookConfiguration{"
  3163  	for _, f := range this.Items {
  3164  		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "MutatingWebhookConfiguration", "MutatingWebhookConfiguration", 1), `&`, ``, 1) + ","
  3165  	}
  3166  	repeatedStringForItems += "}"
  3167  	s := strings.Join([]string{`&MutatingWebhookConfigurationList{`,
  3168  		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
  3169  		`Items:` + repeatedStringForItems + `,`,
  3170  		`}`,
  3171  	}, "")
  3172  	return s
  3173  }
  3174  func (this *NamedRuleWithOperations) String() string {
  3175  	if this == nil {
  3176  		return "nil"
  3177  	}
  3178  	s := strings.Join([]string{`&NamedRuleWithOperations{`,
  3179  		`ResourceNames:` + fmt.Sprintf("%v", this.ResourceNames) + `,`,
  3180  		`RuleWithOperations:` + strings.Replace(strings.Replace(this.RuleWithOperations.String(), "RuleWithOperations", "RuleWithOperations", 1), `&`, ``, 1) + `,`,
  3181  		`}`,
  3182  	}, "")
  3183  	return s
  3184  }
  3185  func (this *ParamKind) String() string {
  3186  	if this == nil {
  3187  		return "nil"
  3188  	}
  3189  	s := strings.Join([]string{`&ParamKind{`,
  3190  		`APIVersion:` + fmt.Sprintf("%v", this.APIVersion) + `,`,
  3191  		`Kind:` + fmt.Sprintf("%v", this.Kind) + `,`,
  3192  		`}`,
  3193  	}, "")
  3194  	return s
  3195  }
  3196  func (this *ParamRef) String() string {
  3197  	if this == nil {
  3198  		return "nil"
  3199  	}
  3200  	s := strings.Join([]string{`&ParamRef{`,
  3201  		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
  3202  		`Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`,
  3203  		`Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "v1.LabelSelector", 1) + `,`,
  3204  		`ParameterNotFoundAction:` + valueToStringGenerated(this.ParameterNotFoundAction) + `,`,
  3205  		`}`,
  3206  	}, "")
  3207  	return s
  3208  }
  3209  func (this *Rule) String() string {
  3210  	if this == nil {
  3211  		return "nil"
  3212  	}
  3213  	s := strings.Join([]string{`&Rule{`,
  3214  		`APIGroups:` + fmt.Sprintf("%v", this.APIGroups) + `,`,
  3215  		`APIVersions:` + fmt.Sprintf("%v", this.APIVersions) + `,`,
  3216  		`Resources:` + fmt.Sprintf("%v", this.Resources) + `,`,
  3217  		`Scope:` + valueToStringGenerated(this.Scope) + `,`,
  3218  		`}`,
  3219  	}, "")
  3220  	return s
  3221  }
  3222  func (this *RuleWithOperations) String() string {
  3223  	if this == nil {
  3224  		return "nil"
  3225  	}
  3226  	s := strings.Join([]string{`&RuleWithOperations{`,
  3227  		`Operations:` + fmt.Sprintf("%v", this.Operations) + `,`,
  3228  		`Rule:` + strings.Replace(strings.Replace(this.Rule.String(), "Rule", "Rule", 1), `&`, ``, 1) + `,`,
  3229  		`}`,
  3230  	}, "")
  3231  	return s
  3232  }
  3233  func (this *ServiceReference) String() string {
  3234  	if this == nil {
  3235  		return "nil"
  3236  	}
  3237  	s := strings.Join([]string{`&ServiceReference{`,
  3238  		`Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`,
  3239  		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
  3240  		`Path:` + valueToStringGenerated(this.Path) + `,`,
  3241  		`Port:` + valueToStringGenerated(this.Port) + `,`,
  3242  		`}`,
  3243  	}, "")
  3244  	return s
  3245  }
  3246  func (this *TypeChecking) String() string {
  3247  	if this == nil {
  3248  		return "nil"
  3249  	}
  3250  	repeatedStringForExpressionWarnings := "[]ExpressionWarning{"
  3251  	for _, f := range this.ExpressionWarnings {
  3252  		repeatedStringForExpressionWarnings += strings.Replace(strings.Replace(f.String(), "ExpressionWarning", "ExpressionWarning", 1), `&`, ``, 1) + ","
  3253  	}
  3254  	repeatedStringForExpressionWarnings += "}"
  3255  	s := strings.Join([]string{`&TypeChecking{`,
  3256  		`ExpressionWarnings:` + repeatedStringForExpressionWarnings + `,`,
  3257  		`}`,
  3258  	}, "")
  3259  	return s
  3260  }
  3261  func (this *ValidatingAdmissionPolicy) String() string {
  3262  	if this == nil {
  3263  		return "nil"
  3264  	}
  3265  	s := strings.Join([]string{`&ValidatingAdmissionPolicy{`,
  3266  		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
  3267  		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "ValidatingAdmissionPolicySpec", "ValidatingAdmissionPolicySpec", 1), `&`, ``, 1) + `,`,
  3268  		`Status:` + strings.Replace(strings.Replace(this.Status.String(), "ValidatingAdmissionPolicyStatus", "ValidatingAdmissionPolicyStatus", 1), `&`, ``, 1) + `,`,
  3269  		`}`,
  3270  	}, "")
  3271  	return s
  3272  }
  3273  func (this *ValidatingAdmissionPolicyBinding) String() string {
  3274  	if this == nil {
  3275  		return "nil"
  3276  	}
  3277  	s := strings.Join([]string{`&ValidatingAdmissionPolicyBinding{`,
  3278  		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
  3279  		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "ValidatingAdmissionPolicyBindingSpec", "ValidatingAdmissionPolicyBindingSpec", 1), `&`, ``, 1) + `,`,
  3280  		`}`,
  3281  	}, "")
  3282  	return s
  3283  }
  3284  func (this *ValidatingAdmissionPolicyBindingList) String() string {
  3285  	if this == nil {
  3286  		return "nil"
  3287  	}
  3288  	repeatedStringForItems := "[]ValidatingAdmissionPolicyBinding{"
  3289  	for _, f := range this.Items {
  3290  		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "ValidatingAdmissionPolicyBinding", "ValidatingAdmissionPolicyBinding", 1), `&`, ``, 1) + ","
  3291  	}
  3292  	repeatedStringForItems += "}"
  3293  	s := strings.Join([]string{`&ValidatingAdmissionPolicyBindingList{`,
  3294  		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
  3295  		`Items:` + repeatedStringForItems + `,`,
  3296  		`}`,
  3297  	}, "")
  3298  	return s
  3299  }
  3300  func (this *ValidatingAdmissionPolicyBindingSpec) String() string {
  3301  	if this == nil {
  3302  		return "nil"
  3303  	}
  3304  	s := strings.Join([]string{`&ValidatingAdmissionPolicyBindingSpec{`,
  3305  		`PolicyName:` + fmt.Sprintf("%v", this.PolicyName) + `,`,
  3306  		`ParamRef:` + strings.Replace(this.ParamRef.String(), "ParamRef", "ParamRef", 1) + `,`,
  3307  		`MatchResources:` + strings.Replace(this.MatchResources.String(), "MatchResources", "MatchResources", 1) + `,`,
  3308  		`ValidationActions:` + fmt.Sprintf("%v", this.ValidationActions) + `,`,
  3309  		`}`,
  3310  	}, "")
  3311  	return s
  3312  }
  3313  func (this *ValidatingAdmissionPolicyList) String() string {
  3314  	if this == nil {
  3315  		return "nil"
  3316  	}
  3317  	repeatedStringForItems := "[]ValidatingAdmissionPolicy{"
  3318  	for _, f := range this.Items {
  3319  		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "ValidatingAdmissionPolicy", "ValidatingAdmissionPolicy", 1), `&`, ``, 1) + ","
  3320  	}
  3321  	repeatedStringForItems += "}"
  3322  	s := strings.Join([]string{`&ValidatingAdmissionPolicyList{`,
  3323  		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
  3324  		`Items:` + repeatedStringForItems + `,`,
  3325  		`}`,
  3326  	}, "")
  3327  	return s
  3328  }
  3329  func (this *ValidatingAdmissionPolicySpec) String() string {
  3330  	if this == nil {
  3331  		return "nil"
  3332  	}
  3333  	repeatedStringForValidations := "[]Validation{"
  3334  	for _, f := range this.Validations {
  3335  		repeatedStringForValidations += strings.Replace(strings.Replace(f.String(), "Validation", "Validation", 1), `&`, ``, 1) + ","
  3336  	}
  3337  	repeatedStringForValidations += "}"
  3338  	repeatedStringForAuditAnnotations := "[]AuditAnnotation{"
  3339  	for _, f := range this.AuditAnnotations {
  3340  		repeatedStringForAuditAnnotations += strings.Replace(strings.Replace(f.String(), "AuditAnnotation", "AuditAnnotation", 1), `&`, ``, 1) + ","
  3341  	}
  3342  	repeatedStringForAuditAnnotations += "}"
  3343  	repeatedStringForMatchConditions := "[]MatchCondition{"
  3344  	for _, f := range this.MatchConditions {
  3345  		repeatedStringForMatchConditions += strings.Replace(strings.Replace(f.String(), "MatchCondition", "MatchCondition", 1), `&`, ``, 1) + ","
  3346  	}
  3347  	repeatedStringForMatchConditions += "}"
  3348  	repeatedStringForVariables := "[]Variable{"
  3349  	for _, f := range this.Variables {
  3350  		repeatedStringForVariables += strings.Replace(strings.Replace(f.String(), "Variable", "Variable", 1), `&`, ``, 1) + ","
  3351  	}
  3352  	repeatedStringForVariables += "}"
  3353  	s := strings.Join([]string{`&ValidatingAdmissionPolicySpec{`,
  3354  		`ParamKind:` + strings.Replace(this.ParamKind.String(), "ParamKind", "ParamKind", 1) + `,`,
  3355  		`MatchConstraints:` + strings.Replace(this.MatchConstraints.String(), "MatchResources", "MatchResources", 1) + `,`,
  3356  		`Validations:` + repeatedStringForValidations + `,`,
  3357  		`FailurePolicy:` + valueToStringGenerated(this.FailurePolicy) + `,`,
  3358  		`AuditAnnotations:` + repeatedStringForAuditAnnotations + `,`,
  3359  		`MatchConditions:` + repeatedStringForMatchConditions + `,`,
  3360  		`Variables:` + repeatedStringForVariables + `,`,
  3361  		`}`,
  3362  	}, "")
  3363  	return s
  3364  }
  3365  func (this *ValidatingAdmissionPolicyStatus) String() string {
  3366  	if this == nil {
  3367  		return "nil"
  3368  	}
  3369  	repeatedStringForConditions := "[]Condition{"
  3370  	for _, f := range this.Conditions {
  3371  		repeatedStringForConditions += fmt.Sprintf("%v", f) + ","
  3372  	}
  3373  	repeatedStringForConditions += "}"
  3374  	s := strings.Join([]string{`&ValidatingAdmissionPolicyStatus{`,
  3375  		`ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
  3376  		`TypeChecking:` + strings.Replace(this.TypeChecking.String(), "TypeChecking", "TypeChecking", 1) + `,`,
  3377  		`Conditions:` + repeatedStringForConditions + `,`,
  3378  		`}`,
  3379  	}, "")
  3380  	return s
  3381  }
  3382  func (this *ValidatingWebhook) String() string {
  3383  	if this == nil {
  3384  		return "nil"
  3385  	}
  3386  	repeatedStringForRules := "[]RuleWithOperations{"
  3387  	for _, f := range this.Rules {
  3388  		repeatedStringForRules += strings.Replace(strings.Replace(f.String(), "RuleWithOperations", "RuleWithOperations", 1), `&`, ``, 1) + ","
  3389  	}
  3390  	repeatedStringForRules += "}"
  3391  	repeatedStringForMatchConditions := "[]MatchCondition{"
  3392  	for _, f := range this.MatchConditions {
  3393  		repeatedStringForMatchConditions += strings.Replace(strings.Replace(f.String(), "MatchCondition", "MatchCondition", 1), `&`, ``, 1) + ","
  3394  	}
  3395  	repeatedStringForMatchConditions += "}"
  3396  	s := strings.Join([]string{`&ValidatingWebhook{`,
  3397  		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
  3398  		`ClientConfig:` + strings.Replace(strings.Replace(this.ClientConfig.String(), "WebhookClientConfig", "WebhookClientConfig", 1), `&`, ``, 1) + `,`,
  3399  		`Rules:` + repeatedStringForRules + `,`,
  3400  		`FailurePolicy:` + valueToStringGenerated(this.FailurePolicy) + `,`,
  3401  		`NamespaceSelector:` + strings.Replace(fmt.Sprintf("%v", this.NamespaceSelector), "LabelSelector", "v1.LabelSelector", 1) + `,`,
  3402  		`SideEffects:` + valueToStringGenerated(this.SideEffects) + `,`,
  3403  		`TimeoutSeconds:` + valueToStringGenerated(this.TimeoutSeconds) + `,`,
  3404  		`AdmissionReviewVersions:` + fmt.Sprintf("%v", this.AdmissionReviewVersions) + `,`,
  3405  		`MatchPolicy:` + valueToStringGenerated(this.MatchPolicy) + `,`,
  3406  		`ObjectSelector:` + strings.Replace(fmt.Sprintf("%v", this.ObjectSelector), "LabelSelector", "v1.LabelSelector", 1) + `,`,
  3407  		`MatchConditions:` + repeatedStringForMatchConditions + `,`,
  3408  		`}`,
  3409  	}, "")
  3410  	return s
  3411  }
  3412  func (this *ValidatingWebhookConfiguration) String() string {
  3413  	if this == nil {
  3414  		return "nil"
  3415  	}
  3416  	repeatedStringForWebhooks := "[]ValidatingWebhook{"
  3417  	for _, f := range this.Webhooks {
  3418  		repeatedStringForWebhooks += strings.Replace(strings.Replace(f.String(), "ValidatingWebhook", "ValidatingWebhook", 1), `&`, ``, 1) + ","
  3419  	}
  3420  	repeatedStringForWebhooks += "}"
  3421  	s := strings.Join([]string{`&ValidatingWebhookConfiguration{`,
  3422  		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
  3423  		`Webhooks:` + repeatedStringForWebhooks + `,`,
  3424  		`}`,
  3425  	}, "")
  3426  	return s
  3427  }
  3428  func (this *ValidatingWebhookConfigurationList) String() string {
  3429  	if this == nil {
  3430  		return "nil"
  3431  	}
  3432  	repeatedStringForItems := "[]ValidatingWebhookConfiguration{"
  3433  	for _, f := range this.Items {
  3434  		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "ValidatingWebhookConfiguration", "ValidatingWebhookConfiguration", 1), `&`, ``, 1) + ","
  3435  	}
  3436  	repeatedStringForItems += "}"
  3437  	s := strings.Join([]string{`&ValidatingWebhookConfigurationList{`,
  3438  		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
  3439  		`Items:` + repeatedStringForItems + `,`,
  3440  		`}`,
  3441  	}, "")
  3442  	return s
  3443  }
  3444  func (this *Validation) String() string {
  3445  	if this == nil {
  3446  		return "nil"
  3447  	}
  3448  	s := strings.Join([]string{`&Validation{`,
  3449  		`Expression:` + fmt.Sprintf("%v", this.Expression) + `,`,
  3450  		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
  3451  		`Reason:` + valueToStringGenerated(this.Reason) + `,`,
  3452  		`MessageExpression:` + fmt.Sprintf("%v", this.MessageExpression) + `,`,
  3453  		`}`,
  3454  	}, "")
  3455  	return s
  3456  }
  3457  func (this *Variable) String() string {
  3458  	if this == nil {
  3459  		return "nil"
  3460  	}
  3461  	s := strings.Join([]string{`&Variable{`,
  3462  		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
  3463  		`Expression:` + fmt.Sprintf("%v", this.Expression) + `,`,
  3464  		`}`,
  3465  	}, "")
  3466  	return s
  3467  }
  3468  func (this *WebhookClientConfig) String() string {
  3469  	if this == nil {
  3470  		return "nil"
  3471  	}
  3472  	s := strings.Join([]string{`&WebhookClientConfig{`,
  3473  		`Service:` + strings.Replace(this.Service.String(), "ServiceReference", "ServiceReference", 1) + `,`,
  3474  		`CABundle:` + valueToStringGenerated(this.CABundle) + `,`,
  3475  		`URL:` + valueToStringGenerated(this.URL) + `,`,
  3476  		`}`,
  3477  	}, "")
  3478  	return s
  3479  }
  3480  func valueToStringGenerated(v interface{}) string {
  3481  	rv := reflect.ValueOf(v)
  3482  	if rv.IsNil() {
  3483  		return "nil"
  3484  	}
  3485  	pv := reflect.Indirect(rv).Interface()
  3486  	return fmt.Sprintf("*%v", pv)
  3487  }
  3488  func (m *AuditAnnotation) Unmarshal(dAtA []byte) error {
  3489  	l := len(dAtA)
  3490  	iNdEx := 0
  3491  	for iNdEx < l {
  3492  		preIndex := iNdEx
  3493  		var wire uint64
  3494  		for shift := uint(0); ; shift += 7 {
  3495  			if shift >= 64 {
  3496  				return ErrIntOverflowGenerated
  3497  			}
  3498  			if iNdEx >= l {
  3499  				return io.ErrUnexpectedEOF
  3500  			}
  3501  			b := dAtA[iNdEx]
  3502  			iNdEx++
  3503  			wire |= uint64(b&0x7F) << shift
  3504  			if b < 0x80 {
  3505  				break
  3506  			}
  3507  		}
  3508  		fieldNum := int32(wire >> 3)
  3509  		wireType := int(wire & 0x7)
  3510  		if wireType == 4 {
  3511  			return fmt.Errorf("proto: AuditAnnotation: wiretype end group for non-group")
  3512  		}
  3513  		if fieldNum <= 0 {
  3514  			return fmt.Errorf("proto: AuditAnnotation: illegal tag %d (wire type %d)", fieldNum, wire)
  3515  		}
  3516  		switch fieldNum {
  3517  		case 1:
  3518  			if wireType != 2 {
  3519  				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
  3520  			}
  3521  			var stringLen uint64
  3522  			for shift := uint(0); ; shift += 7 {
  3523  				if shift >= 64 {
  3524  					return ErrIntOverflowGenerated
  3525  				}
  3526  				if iNdEx >= l {
  3527  					return io.ErrUnexpectedEOF
  3528  				}
  3529  				b := dAtA[iNdEx]
  3530  				iNdEx++
  3531  				stringLen |= uint64(b&0x7F) << shift
  3532  				if b < 0x80 {
  3533  					break
  3534  				}
  3535  			}
  3536  			intStringLen := int(stringLen)
  3537  			if intStringLen < 0 {
  3538  				return ErrInvalidLengthGenerated
  3539  			}
  3540  			postIndex := iNdEx + intStringLen
  3541  			if postIndex < 0 {
  3542  				return ErrInvalidLengthGenerated
  3543  			}
  3544  			if postIndex > l {
  3545  				return io.ErrUnexpectedEOF
  3546  			}
  3547  			m.Key = string(dAtA[iNdEx:postIndex])
  3548  			iNdEx = postIndex
  3549  		case 2:
  3550  			if wireType != 2 {
  3551  				return fmt.Errorf("proto: wrong wireType = %d for field ValueExpression", wireType)
  3552  			}
  3553  			var stringLen uint64
  3554  			for shift := uint(0); ; shift += 7 {
  3555  				if shift >= 64 {
  3556  					return ErrIntOverflowGenerated
  3557  				}
  3558  				if iNdEx >= l {
  3559  					return io.ErrUnexpectedEOF
  3560  				}
  3561  				b := dAtA[iNdEx]
  3562  				iNdEx++
  3563  				stringLen |= uint64(b&0x7F) << shift
  3564  				if b < 0x80 {
  3565  					break
  3566  				}
  3567  			}
  3568  			intStringLen := int(stringLen)
  3569  			if intStringLen < 0 {
  3570  				return ErrInvalidLengthGenerated
  3571  			}
  3572  			postIndex := iNdEx + intStringLen
  3573  			if postIndex < 0 {
  3574  				return ErrInvalidLengthGenerated
  3575  			}
  3576  			if postIndex > l {
  3577  				return io.ErrUnexpectedEOF
  3578  			}
  3579  			m.ValueExpression = string(dAtA[iNdEx:postIndex])
  3580  			iNdEx = postIndex
  3581  		default:
  3582  			iNdEx = preIndex
  3583  			skippy, err := skipGenerated(dAtA[iNdEx:])
  3584  			if err != nil {
  3585  				return err
  3586  			}
  3587  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  3588  				return ErrInvalidLengthGenerated
  3589  			}
  3590  			if (iNdEx + skippy) > l {
  3591  				return io.ErrUnexpectedEOF
  3592  			}
  3593  			iNdEx += skippy
  3594  		}
  3595  	}
  3596  
  3597  	if iNdEx > l {
  3598  		return io.ErrUnexpectedEOF
  3599  	}
  3600  	return nil
  3601  }
  3602  func (m *ExpressionWarning) Unmarshal(dAtA []byte) error {
  3603  	l := len(dAtA)
  3604  	iNdEx := 0
  3605  	for iNdEx < l {
  3606  		preIndex := iNdEx
  3607  		var wire uint64
  3608  		for shift := uint(0); ; shift += 7 {
  3609  			if shift >= 64 {
  3610  				return ErrIntOverflowGenerated
  3611  			}
  3612  			if iNdEx >= l {
  3613  				return io.ErrUnexpectedEOF
  3614  			}
  3615  			b := dAtA[iNdEx]
  3616  			iNdEx++
  3617  			wire |= uint64(b&0x7F) << shift
  3618  			if b < 0x80 {
  3619  				break
  3620  			}
  3621  		}
  3622  		fieldNum := int32(wire >> 3)
  3623  		wireType := int(wire & 0x7)
  3624  		if wireType == 4 {
  3625  			return fmt.Errorf("proto: ExpressionWarning: wiretype end group for non-group")
  3626  		}
  3627  		if fieldNum <= 0 {
  3628  			return fmt.Errorf("proto: ExpressionWarning: illegal tag %d (wire type %d)", fieldNum, wire)
  3629  		}
  3630  		switch fieldNum {
  3631  		case 2:
  3632  			if wireType != 2 {
  3633  				return fmt.Errorf("proto: wrong wireType = %d for field FieldRef", wireType)
  3634  			}
  3635  			var stringLen uint64
  3636  			for shift := uint(0); ; shift += 7 {
  3637  				if shift >= 64 {
  3638  					return ErrIntOverflowGenerated
  3639  				}
  3640  				if iNdEx >= l {
  3641  					return io.ErrUnexpectedEOF
  3642  				}
  3643  				b := dAtA[iNdEx]
  3644  				iNdEx++
  3645  				stringLen |= uint64(b&0x7F) << shift
  3646  				if b < 0x80 {
  3647  					break
  3648  				}
  3649  			}
  3650  			intStringLen := int(stringLen)
  3651  			if intStringLen < 0 {
  3652  				return ErrInvalidLengthGenerated
  3653  			}
  3654  			postIndex := iNdEx + intStringLen
  3655  			if postIndex < 0 {
  3656  				return ErrInvalidLengthGenerated
  3657  			}
  3658  			if postIndex > l {
  3659  				return io.ErrUnexpectedEOF
  3660  			}
  3661  			m.FieldRef = string(dAtA[iNdEx:postIndex])
  3662  			iNdEx = postIndex
  3663  		case 3:
  3664  			if wireType != 2 {
  3665  				return fmt.Errorf("proto: wrong wireType = %d for field Warning", wireType)
  3666  			}
  3667  			var stringLen uint64
  3668  			for shift := uint(0); ; shift += 7 {
  3669  				if shift >= 64 {
  3670  					return ErrIntOverflowGenerated
  3671  				}
  3672  				if iNdEx >= l {
  3673  					return io.ErrUnexpectedEOF
  3674  				}
  3675  				b := dAtA[iNdEx]
  3676  				iNdEx++
  3677  				stringLen |= uint64(b&0x7F) << shift
  3678  				if b < 0x80 {
  3679  					break
  3680  				}
  3681  			}
  3682  			intStringLen := int(stringLen)
  3683  			if intStringLen < 0 {
  3684  				return ErrInvalidLengthGenerated
  3685  			}
  3686  			postIndex := iNdEx + intStringLen
  3687  			if postIndex < 0 {
  3688  				return ErrInvalidLengthGenerated
  3689  			}
  3690  			if postIndex > l {
  3691  				return io.ErrUnexpectedEOF
  3692  			}
  3693  			m.Warning = string(dAtA[iNdEx:postIndex])
  3694  			iNdEx = postIndex
  3695  		default:
  3696  			iNdEx = preIndex
  3697  			skippy, err := skipGenerated(dAtA[iNdEx:])
  3698  			if err != nil {
  3699  				return err
  3700  			}
  3701  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  3702  				return ErrInvalidLengthGenerated
  3703  			}
  3704  			if (iNdEx + skippy) > l {
  3705  				return io.ErrUnexpectedEOF
  3706  			}
  3707  			iNdEx += skippy
  3708  		}
  3709  	}
  3710  
  3711  	if iNdEx > l {
  3712  		return io.ErrUnexpectedEOF
  3713  	}
  3714  	return nil
  3715  }
  3716  func (m *MatchCondition) Unmarshal(dAtA []byte) error {
  3717  	l := len(dAtA)
  3718  	iNdEx := 0
  3719  	for iNdEx < l {
  3720  		preIndex := iNdEx
  3721  		var wire uint64
  3722  		for shift := uint(0); ; shift += 7 {
  3723  			if shift >= 64 {
  3724  				return ErrIntOverflowGenerated
  3725  			}
  3726  			if iNdEx >= l {
  3727  				return io.ErrUnexpectedEOF
  3728  			}
  3729  			b := dAtA[iNdEx]
  3730  			iNdEx++
  3731  			wire |= uint64(b&0x7F) << shift
  3732  			if b < 0x80 {
  3733  				break
  3734  			}
  3735  		}
  3736  		fieldNum := int32(wire >> 3)
  3737  		wireType := int(wire & 0x7)
  3738  		if wireType == 4 {
  3739  			return fmt.Errorf("proto: MatchCondition: wiretype end group for non-group")
  3740  		}
  3741  		if fieldNum <= 0 {
  3742  			return fmt.Errorf("proto: MatchCondition: illegal tag %d (wire type %d)", fieldNum, wire)
  3743  		}
  3744  		switch fieldNum {
  3745  		case 1:
  3746  			if wireType != 2 {
  3747  				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
  3748  			}
  3749  			var stringLen uint64
  3750  			for shift := uint(0); ; shift += 7 {
  3751  				if shift >= 64 {
  3752  					return ErrIntOverflowGenerated
  3753  				}
  3754  				if iNdEx >= l {
  3755  					return io.ErrUnexpectedEOF
  3756  				}
  3757  				b := dAtA[iNdEx]
  3758  				iNdEx++
  3759  				stringLen |= uint64(b&0x7F) << shift
  3760  				if b < 0x80 {
  3761  					break
  3762  				}
  3763  			}
  3764  			intStringLen := int(stringLen)
  3765  			if intStringLen < 0 {
  3766  				return ErrInvalidLengthGenerated
  3767  			}
  3768  			postIndex := iNdEx + intStringLen
  3769  			if postIndex < 0 {
  3770  				return ErrInvalidLengthGenerated
  3771  			}
  3772  			if postIndex > l {
  3773  				return io.ErrUnexpectedEOF
  3774  			}
  3775  			m.Name = string(dAtA[iNdEx:postIndex])
  3776  			iNdEx = postIndex
  3777  		case 2:
  3778  			if wireType != 2 {
  3779  				return fmt.Errorf("proto: wrong wireType = %d for field Expression", wireType)
  3780  			}
  3781  			var stringLen uint64
  3782  			for shift := uint(0); ; shift += 7 {
  3783  				if shift >= 64 {
  3784  					return ErrIntOverflowGenerated
  3785  				}
  3786  				if iNdEx >= l {
  3787  					return io.ErrUnexpectedEOF
  3788  				}
  3789  				b := dAtA[iNdEx]
  3790  				iNdEx++
  3791  				stringLen |= uint64(b&0x7F) << shift
  3792  				if b < 0x80 {
  3793  					break
  3794  				}
  3795  			}
  3796  			intStringLen := int(stringLen)
  3797  			if intStringLen < 0 {
  3798  				return ErrInvalidLengthGenerated
  3799  			}
  3800  			postIndex := iNdEx + intStringLen
  3801  			if postIndex < 0 {
  3802  				return ErrInvalidLengthGenerated
  3803  			}
  3804  			if postIndex > l {
  3805  				return io.ErrUnexpectedEOF
  3806  			}
  3807  			m.Expression = string(dAtA[iNdEx:postIndex])
  3808  			iNdEx = postIndex
  3809  		default:
  3810  			iNdEx = preIndex
  3811  			skippy, err := skipGenerated(dAtA[iNdEx:])
  3812  			if err != nil {
  3813  				return err
  3814  			}
  3815  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  3816  				return ErrInvalidLengthGenerated
  3817  			}
  3818  			if (iNdEx + skippy) > l {
  3819  				return io.ErrUnexpectedEOF
  3820  			}
  3821  			iNdEx += skippy
  3822  		}
  3823  	}
  3824  
  3825  	if iNdEx > l {
  3826  		return io.ErrUnexpectedEOF
  3827  	}
  3828  	return nil
  3829  }
  3830  func (m *MatchResources) Unmarshal(dAtA []byte) error {
  3831  	l := len(dAtA)
  3832  	iNdEx := 0
  3833  	for iNdEx < l {
  3834  		preIndex := iNdEx
  3835  		var wire uint64
  3836  		for shift := uint(0); ; shift += 7 {
  3837  			if shift >= 64 {
  3838  				return ErrIntOverflowGenerated
  3839  			}
  3840  			if iNdEx >= l {
  3841  				return io.ErrUnexpectedEOF
  3842  			}
  3843  			b := dAtA[iNdEx]
  3844  			iNdEx++
  3845  			wire |= uint64(b&0x7F) << shift
  3846  			if b < 0x80 {
  3847  				break
  3848  			}
  3849  		}
  3850  		fieldNum := int32(wire >> 3)
  3851  		wireType := int(wire & 0x7)
  3852  		if wireType == 4 {
  3853  			return fmt.Errorf("proto: MatchResources: wiretype end group for non-group")
  3854  		}
  3855  		if fieldNum <= 0 {
  3856  			return fmt.Errorf("proto: MatchResources: illegal tag %d (wire type %d)", fieldNum, wire)
  3857  		}
  3858  		switch fieldNum {
  3859  		case 1:
  3860  			if wireType != 2 {
  3861  				return fmt.Errorf("proto: wrong wireType = %d for field NamespaceSelector", wireType)
  3862  			}
  3863  			var msglen int
  3864  			for shift := uint(0); ; shift += 7 {
  3865  				if shift >= 64 {
  3866  					return ErrIntOverflowGenerated
  3867  				}
  3868  				if iNdEx >= l {
  3869  					return io.ErrUnexpectedEOF
  3870  				}
  3871  				b := dAtA[iNdEx]
  3872  				iNdEx++
  3873  				msglen |= int(b&0x7F) << shift
  3874  				if b < 0x80 {
  3875  					break
  3876  				}
  3877  			}
  3878  			if msglen < 0 {
  3879  				return ErrInvalidLengthGenerated
  3880  			}
  3881  			postIndex := iNdEx + msglen
  3882  			if postIndex < 0 {
  3883  				return ErrInvalidLengthGenerated
  3884  			}
  3885  			if postIndex > l {
  3886  				return io.ErrUnexpectedEOF
  3887  			}
  3888  			if m.NamespaceSelector == nil {
  3889  				m.NamespaceSelector = &v1.LabelSelector{}
  3890  			}
  3891  			if err := m.NamespaceSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  3892  				return err
  3893  			}
  3894  			iNdEx = postIndex
  3895  		case 2:
  3896  			if wireType != 2 {
  3897  				return fmt.Errorf("proto: wrong wireType = %d for field ObjectSelector", wireType)
  3898  			}
  3899  			var msglen int
  3900  			for shift := uint(0); ; shift += 7 {
  3901  				if shift >= 64 {
  3902  					return ErrIntOverflowGenerated
  3903  				}
  3904  				if iNdEx >= l {
  3905  					return io.ErrUnexpectedEOF
  3906  				}
  3907  				b := dAtA[iNdEx]
  3908  				iNdEx++
  3909  				msglen |= int(b&0x7F) << shift
  3910  				if b < 0x80 {
  3911  					break
  3912  				}
  3913  			}
  3914  			if msglen < 0 {
  3915  				return ErrInvalidLengthGenerated
  3916  			}
  3917  			postIndex := iNdEx + msglen
  3918  			if postIndex < 0 {
  3919  				return ErrInvalidLengthGenerated
  3920  			}
  3921  			if postIndex > l {
  3922  				return io.ErrUnexpectedEOF
  3923  			}
  3924  			if m.ObjectSelector == nil {
  3925  				m.ObjectSelector = &v1.LabelSelector{}
  3926  			}
  3927  			if err := m.ObjectSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  3928  				return err
  3929  			}
  3930  			iNdEx = postIndex
  3931  		case 3:
  3932  			if wireType != 2 {
  3933  				return fmt.Errorf("proto: wrong wireType = %d for field ResourceRules", wireType)
  3934  			}
  3935  			var msglen int
  3936  			for shift := uint(0); ; shift += 7 {
  3937  				if shift >= 64 {
  3938  					return ErrIntOverflowGenerated
  3939  				}
  3940  				if iNdEx >= l {
  3941  					return io.ErrUnexpectedEOF
  3942  				}
  3943  				b := dAtA[iNdEx]
  3944  				iNdEx++
  3945  				msglen |= int(b&0x7F) << shift
  3946  				if b < 0x80 {
  3947  					break
  3948  				}
  3949  			}
  3950  			if msglen < 0 {
  3951  				return ErrInvalidLengthGenerated
  3952  			}
  3953  			postIndex := iNdEx + msglen
  3954  			if postIndex < 0 {
  3955  				return ErrInvalidLengthGenerated
  3956  			}
  3957  			if postIndex > l {
  3958  				return io.ErrUnexpectedEOF
  3959  			}
  3960  			m.ResourceRules = append(m.ResourceRules, NamedRuleWithOperations{})
  3961  			if err := m.ResourceRules[len(m.ResourceRules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  3962  				return err
  3963  			}
  3964  			iNdEx = postIndex
  3965  		case 4:
  3966  			if wireType != 2 {
  3967  				return fmt.Errorf("proto: wrong wireType = %d for field ExcludeResourceRules", wireType)
  3968  			}
  3969  			var msglen int
  3970  			for shift := uint(0); ; shift += 7 {
  3971  				if shift >= 64 {
  3972  					return ErrIntOverflowGenerated
  3973  				}
  3974  				if iNdEx >= l {
  3975  					return io.ErrUnexpectedEOF
  3976  				}
  3977  				b := dAtA[iNdEx]
  3978  				iNdEx++
  3979  				msglen |= int(b&0x7F) << shift
  3980  				if b < 0x80 {
  3981  					break
  3982  				}
  3983  			}
  3984  			if msglen < 0 {
  3985  				return ErrInvalidLengthGenerated
  3986  			}
  3987  			postIndex := iNdEx + msglen
  3988  			if postIndex < 0 {
  3989  				return ErrInvalidLengthGenerated
  3990  			}
  3991  			if postIndex > l {
  3992  				return io.ErrUnexpectedEOF
  3993  			}
  3994  			m.ExcludeResourceRules = append(m.ExcludeResourceRules, NamedRuleWithOperations{})
  3995  			if err := m.ExcludeResourceRules[len(m.ExcludeResourceRules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  3996  				return err
  3997  			}
  3998  			iNdEx = postIndex
  3999  		case 7:
  4000  			if wireType != 2 {
  4001  				return fmt.Errorf("proto: wrong wireType = %d for field MatchPolicy", wireType)
  4002  			}
  4003  			var stringLen uint64
  4004  			for shift := uint(0); ; shift += 7 {
  4005  				if shift >= 64 {
  4006  					return ErrIntOverflowGenerated
  4007  				}
  4008  				if iNdEx >= l {
  4009  					return io.ErrUnexpectedEOF
  4010  				}
  4011  				b := dAtA[iNdEx]
  4012  				iNdEx++
  4013  				stringLen |= uint64(b&0x7F) << shift
  4014  				if b < 0x80 {
  4015  					break
  4016  				}
  4017  			}
  4018  			intStringLen := int(stringLen)
  4019  			if intStringLen < 0 {
  4020  				return ErrInvalidLengthGenerated
  4021  			}
  4022  			postIndex := iNdEx + intStringLen
  4023  			if postIndex < 0 {
  4024  				return ErrInvalidLengthGenerated
  4025  			}
  4026  			if postIndex > l {
  4027  				return io.ErrUnexpectedEOF
  4028  			}
  4029  			s := MatchPolicyType(dAtA[iNdEx:postIndex])
  4030  			m.MatchPolicy = &s
  4031  			iNdEx = postIndex
  4032  		default:
  4033  			iNdEx = preIndex
  4034  			skippy, err := skipGenerated(dAtA[iNdEx:])
  4035  			if err != nil {
  4036  				return err
  4037  			}
  4038  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  4039  				return ErrInvalidLengthGenerated
  4040  			}
  4041  			if (iNdEx + skippy) > l {
  4042  				return io.ErrUnexpectedEOF
  4043  			}
  4044  			iNdEx += skippy
  4045  		}
  4046  	}
  4047  
  4048  	if iNdEx > l {
  4049  		return io.ErrUnexpectedEOF
  4050  	}
  4051  	return nil
  4052  }
  4053  func (m *MutatingWebhook) Unmarshal(dAtA []byte) error {
  4054  	l := len(dAtA)
  4055  	iNdEx := 0
  4056  	for iNdEx < l {
  4057  		preIndex := iNdEx
  4058  		var wire uint64
  4059  		for shift := uint(0); ; shift += 7 {
  4060  			if shift >= 64 {
  4061  				return ErrIntOverflowGenerated
  4062  			}
  4063  			if iNdEx >= l {
  4064  				return io.ErrUnexpectedEOF
  4065  			}
  4066  			b := dAtA[iNdEx]
  4067  			iNdEx++
  4068  			wire |= uint64(b&0x7F) << shift
  4069  			if b < 0x80 {
  4070  				break
  4071  			}
  4072  		}
  4073  		fieldNum := int32(wire >> 3)
  4074  		wireType := int(wire & 0x7)
  4075  		if wireType == 4 {
  4076  			return fmt.Errorf("proto: MutatingWebhook: wiretype end group for non-group")
  4077  		}
  4078  		if fieldNum <= 0 {
  4079  			return fmt.Errorf("proto: MutatingWebhook: illegal tag %d (wire type %d)", fieldNum, wire)
  4080  		}
  4081  		switch fieldNum {
  4082  		case 1:
  4083  			if wireType != 2 {
  4084  				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
  4085  			}
  4086  			var stringLen uint64
  4087  			for shift := uint(0); ; shift += 7 {
  4088  				if shift >= 64 {
  4089  					return ErrIntOverflowGenerated
  4090  				}
  4091  				if iNdEx >= l {
  4092  					return io.ErrUnexpectedEOF
  4093  				}
  4094  				b := dAtA[iNdEx]
  4095  				iNdEx++
  4096  				stringLen |= uint64(b&0x7F) << shift
  4097  				if b < 0x80 {
  4098  					break
  4099  				}
  4100  			}
  4101  			intStringLen := int(stringLen)
  4102  			if intStringLen < 0 {
  4103  				return ErrInvalidLengthGenerated
  4104  			}
  4105  			postIndex := iNdEx + intStringLen
  4106  			if postIndex < 0 {
  4107  				return ErrInvalidLengthGenerated
  4108  			}
  4109  			if postIndex > l {
  4110  				return io.ErrUnexpectedEOF
  4111  			}
  4112  			m.Name = string(dAtA[iNdEx:postIndex])
  4113  			iNdEx = postIndex
  4114  		case 2:
  4115  			if wireType != 2 {
  4116  				return fmt.Errorf("proto: wrong wireType = %d for field ClientConfig", wireType)
  4117  			}
  4118  			var msglen int
  4119  			for shift := uint(0); ; shift += 7 {
  4120  				if shift >= 64 {
  4121  					return ErrIntOverflowGenerated
  4122  				}
  4123  				if iNdEx >= l {
  4124  					return io.ErrUnexpectedEOF
  4125  				}
  4126  				b := dAtA[iNdEx]
  4127  				iNdEx++
  4128  				msglen |= int(b&0x7F) << shift
  4129  				if b < 0x80 {
  4130  					break
  4131  				}
  4132  			}
  4133  			if msglen < 0 {
  4134  				return ErrInvalidLengthGenerated
  4135  			}
  4136  			postIndex := iNdEx + msglen
  4137  			if postIndex < 0 {
  4138  				return ErrInvalidLengthGenerated
  4139  			}
  4140  			if postIndex > l {
  4141  				return io.ErrUnexpectedEOF
  4142  			}
  4143  			if err := m.ClientConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  4144  				return err
  4145  			}
  4146  			iNdEx = postIndex
  4147  		case 3:
  4148  			if wireType != 2 {
  4149  				return fmt.Errorf("proto: wrong wireType = %d for field Rules", wireType)
  4150  			}
  4151  			var msglen int
  4152  			for shift := uint(0); ; shift += 7 {
  4153  				if shift >= 64 {
  4154  					return ErrIntOverflowGenerated
  4155  				}
  4156  				if iNdEx >= l {
  4157  					return io.ErrUnexpectedEOF
  4158  				}
  4159  				b := dAtA[iNdEx]
  4160  				iNdEx++
  4161  				msglen |= int(b&0x7F) << shift
  4162  				if b < 0x80 {
  4163  					break
  4164  				}
  4165  			}
  4166  			if msglen < 0 {
  4167  				return ErrInvalidLengthGenerated
  4168  			}
  4169  			postIndex := iNdEx + msglen
  4170  			if postIndex < 0 {
  4171  				return ErrInvalidLengthGenerated
  4172  			}
  4173  			if postIndex > l {
  4174  				return io.ErrUnexpectedEOF
  4175  			}
  4176  			m.Rules = append(m.Rules, RuleWithOperations{})
  4177  			if err := m.Rules[len(m.Rules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  4178  				return err
  4179  			}
  4180  			iNdEx = postIndex
  4181  		case 4:
  4182  			if wireType != 2 {
  4183  				return fmt.Errorf("proto: wrong wireType = %d for field FailurePolicy", wireType)
  4184  			}
  4185  			var stringLen uint64
  4186  			for shift := uint(0); ; shift += 7 {
  4187  				if shift >= 64 {
  4188  					return ErrIntOverflowGenerated
  4189  				}
  4190  				if iNdEx >= l {
  4191  					return io.ErrUnexpectedEOF
  4192  				}
  4193  				b := dAtA[iNdEx]
  4194  				iNdEx++
  4195  				stringLen |= uint64(b&0x7F) << shift
  4196  				if b < 0x80 {
  4197  					break
  4198  				}
  4199  			}
  4200  			intStringLen := int(stringLen)
  4201  			if intStringLen < 0 {
  4202  				return ErrInvalidLengthGenerated
  4203  			}
  4204  			postIndex := iNdEx + intStringLen
  4205  			if postIndex < 0 {
  4206  				return ErrInvalidLengthGenerated
  4207  			}
  4208  			if postIndex > l {
  4209  				return io.ErrUnexpectedEOF
  4210  			}
  4211  			s := FailurePolicyType(dAtA[iNdEx:postIndex])
  4212  			m.FailurePolicy = &s
  4213  			iNdEx = postIndex
  4214  		case 5:
  4215  			if wireType != 2 {
  4216  				return fmt.Errorf("proto: wrong wireType = %d for field NamespaceSelector", wireType)
  4217  			}
  4218  			var msglen int
  4219  			for shift := uint(0); ; shift += 7 {
  4220  				if shift >= 64 {
  4221  					return ErrIntOverflowGenerated
  4222  				}
  4223  				if iNdEx >= l {
  4224  					return io.ErrUnexpectedEOF
  4225  				}
  4226  				b := dAtA[iNdEx]
  4227  				iNdEx++
  4228  				msglen |= int(b&0x7F) << shift
  4229  				if b < 0x80 {
  4230  					break
  4231  				}
  4232  			}
  4233  			if msglen < 0 {
  4234  				return ErrInvalidLengthGenerated
  4235  			}
  4236  			postIndex := iNdEx + msglen
  4237  			if postIndex < 0 {
  4238  				return ErrInvalidLengthGenerated
  4239  			}
  4240  			if postIndex > l {
  4241  				return io.ErrUnexpectedEOF
  4242  			}
  4243  			if m.NamespaceSelector == nil {
  4244  				m.NamespaceSelector = &v1.LabelSelector{}
  4245  			}
  4246  			if err := m.NamespaceSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  4247  				return err
  4248  			}
  4249  			iNdEx = postIndex
  4250  		case 6:
  4251  			if wireType != 2 {
  4252  				return fmt.Errorf("proto: wrong wireType = %d for field SideEffects", wireType)
  4253  			}
  4254  			var stringLen uint64
  4255  			for shift := uint(0); ; shift += 7 {
  4256  				if shift >= 64 {
  4257  					return ErrIntOverflowGenerated
  4258  				}
  4259  				if iNdEx >= l {
  4260  					return io.ErrUnexpectedEOF
  4261  				}
  4262  				b := dAtA[iNdEx]
  4263  				iNdEx++
  4264  				stringLen |= uint64(b&0x7F) << shift
  4265  				if b < 0x80 {
  4266  					break
  4267  				}
  4268  			}
  4269  			intStringLen := int(stringLen)
  4270  			if intStringLen < 0 {
  4271  				return ErrInvalidLengthGenerated
  4272  			}
  4273  			postIndex := iNdEx + intStringLen
  4274  			if postIndex < 0 {
  4275  				return ErrInvalidLengthGenerated
  4276  			}
  4277  			if postIndex > l {
  4278  				return io.ErrUnexpectedEOF
  4279  			}
  4280  			s := SideEffectClass(dAtA[iNdEx:postIndex])
  4281  			m.SideEffects = &s
  4282  			iNdEx = postIndex
  4283  		case 7:
  4284  			if wireType != 0 {
  4285  				return fmt.Errorf("proto: wrong wireType = %d for field TimeoutSeconds", wireType)
  4286  			}
  4287  			var v int32
  4288  			for shift := uint(0); ; shift += 7 {
  4289  				if shift >= 64 {
  4290  					return ErrIntOverflowGenerated
  4291  				}
  4292  				if iNdEx >= l {
  4293  					return io.ErrUnexpectedEOF
  4294  				}
  4295  				b := dAtA[iNdEx]
  4296  				iNdEx++
  4297  				v |= int32(b&0x7F) << shift
  4298  				if b < 0x80 {
  4299  					break
  4300  				}
  4301  			}
  4302  			m.TimeoutSeconds = &v
  4303  		case 8:
  4304  			if wireType != 2 {
  4305  				return fmt.Errorf("proto: wrong wireType = %d for field AdmissionReviewVersions", wireType)
  4306  			}
  4307  			var stringLen uint64
  4308  			for shift := uint(0); ; shift += 7 {
  4309  				if shift >= 64 {
  4310  					return ErrIntOverflowGenerated
  4311  				}
  4312  				if iNdEx >= l {
  4313  					return io.ErrUnexpectedEOF
  4314  				}
  4315  				b := dAtA[iNdEx]
  4316  				iNdEx++
  4317  				stringLen |= uint64(b&0x7F) << shift
  4318  				if b < 0x80 {
  4319  					break
  4320  				}
  4321  			}
  4322  			intStringLen := int(stringLen)
  4323  			if intStringLen < 0 {
  4324  				return ErrInvalidLengthGenerated
  4325  			}
  4326  			postIndex := iNdEx + intStringLen
  4327  			if postIndex < 0 {
  4328  				return ErrInvalidLengthGenerated
  4329  			}
  4330  			if postIndex > l {
  4331  				return io.ErrUnexpectedEOF
  4332  			}
  4333  			m.AdmissionReviewVersions = append(m.AdmissionReviewVersions, string(dAtA[iNdEx:postIndex]))
  4334  			iNdEx = postIndex
  4335  		case 9:
  4336  			if wireType != 2 {
  4337  				return fmt.Errorf("proto: wrong wireType = %d for field MatchPolicy", wireType)
  4338  			}
  4339  			var stringLen uint64
  4340  			for shift := uint(0); ; shift += 7 {
  4341  				if shift >= 64 {
  4342  					return ErrIntOverflowGenerated
  4343  				}
  4344  				if iNdEx >= l {
  4345  					return io.ErrUnexpectedEOF
  4346  				}
  4347  				b := dAtA[iNdEx]
  4348  				iNdEx++
  4349  				stringLen |= uint64(b&0x7F) << shift
  4350  				if b < 0x80 {
  4351  					break
  4352  				}
  4353  			}
  4354  			intStringLen := int(stringLen)
  4355  			if intStringLen < 0 {
  4356  				return ErrInvalidLengthGenerated
  4357  			}
  4358  			postIndex := iNdEx + intStringLen
  4359  			if postIndex < 0 {
  4360  				return ErrInvalidLengthGenerated
  4361  			}
  4362  			if postIndex > l {
  4363  				return io.ErrUnexpectedEOF
  4364  			}
  4365  			s := MatchPolicyType(dAtA[iNdEx:postIndex])
  4366  			m.MatchPolicy = &s
  4367  			iNdEx = postIndex
  4368  		case 10:
  4369  			if wireType != 2 {
  4370  				return fmt.Errorf("proto: wrong wireType = %d for field ReinvocationPolicy", wireType)
  4371  			}
  4372  			var stringLen uint64
  4373  			for shift := uint(0); ; shift += 7 {
  4374  				if shift >= 64 {
  4375  					return ErrIntOverflowGenerated
  4376  				}
  4377  				if iNdEx >= l {
  4378  					return io.ErrUnexpectedEOF
  4379  				}
  4380  				b := dAtA[iNdEx]
  4381  				iNdEx++
  4382  				stringLen |= uint64(b&0x7F) << shift
  4383  				if b < 0x80 {
  4384  					break
  4385  				}
  4386  			}
  4387  			intStringLen := int(stringLen)
  4388  			if intStringLen < 0 {
  4389  				return ErrInvalidLengthGenerated
  4390  			}
  4391  			postIndex := iNdEx + intStringLen
  4392  			if postIndex < 0 {
  4393  				return ErrInvalidLengthGenerated
  4394  			}
  4395  			if postIndex > l {
  4396  				return io.ErrUnexpectedEOF
  4397  			}
  4398  			s := ReinvocationPolicyType(dAtA[iNdEx:postIndex])
  4399  			m.ReinvocationPolicy = &s
  4400  			iNdEx = postIndex
  4401  		case 11:
  4402  			if wireType != 2 {
  4403  				return fmt.Errorf("proto: wrong wireType = %d for field ObjectSelector", wireType)
  4404  			}
  4405  			var msglen int
  4406  			for shift := uint(0); ; shift += 7 {
  4407  				if shift >= 64 {
  4408  					return ErrIntOverflowGenerated
  4409  				}
  4410  				if iNdEx >= l {
  4411  					return io.ErrUnexpectedEOF
  4412  				}
  4413  				b := dAtA[iNdEx]
  4414  				iNdEx++
  4415  				msglen |= int(b&0x7F) << shift
  4416  				if b < 0x80 {
  4417  					break
  4418  				}
  4419  			}
  4420  			if msglen < 0 {
  4421  				return ErrInvalidLengthGenerated
  4422  			}
  4423  			postIndex := iNdEx + msglen
  4424  			if postIndex < 0 {
  4425  				return ErrInvalidLengthGenerated
  4426  			}
  4427  			if postIndex > l {
  4428  				return io.ErrUnexpectedEOF
  4429  			}
  4430  			if m.ObjectSelector == nil {
  4431  				m.ObjectSelector = &v1.LabelSelector{}
  4432  			}
  4433  			if err := m.ObjectSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  4434  				return err
  4435  			}
  4436  			iNdEx = postIndex
  4437  		case 12:
  4438  			if wireType != 2 {
  4439  				return fmt.Errorf("proto: wrong wireType = %d for field MatchConditions", wireType)
  4440  			}
  4441  			var msglen int
  4442  			for shift := uint(0); ; shift += 7 {
  4443  				if shift >= 64 {
  4444  					return ErrIntOverflowGenerated
  4445  				}
  4446  				if iNdEx >= l {
  4447  					return io.ErrUnexpectedEOF
  4448  				}
  4449  				b := dAtA[iNdEx]
  4450  				iNdEx++
  4451  				msglen |= int(b&0x7F) << shift
  4452  				if b < 0x80 {
  4453  					break
  4454  				}
  4455  			}
  4456  			if msglen < 0 {
  4457  				return ErrInvalidLengthGenerated
  4458  			}
  4459  			postIndex := iNdEx + msglen
  4460  			if postIndex < 0 {
  4461  				return ErrInvalidLengthGenerated
  4462  			}
  4463  			if postIndex > l {
  4464  				return io.ErrUnexpectedEOF
  4465  			}
  4466  			m.MatchConditions = append(m.MatchConditions, MatchCondition{})
  4467  			if err := m.MatchConditions[len(m.MatchConditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  4468  				return err
  4469  			}
  4470  			iNdEx = postIndex
  4471  		default:
  4472  			iNdEx = preIndex
  4473  			skippy, err := skipGenerated(dAtA[iNdEx:])
  4474  			if err != nil {
  4475  				return err
  4476  			}
  4477  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  4478  				return ErrInvalidLengthGenerated
  4479  			}
  4480  			if (iNdEx + skippy) > l {
  4481  				return io.ErrUnexpectedEOF
  4482  			}
  4483  			iNdEx += skippy
  4484  		}
  4485  	}
  4486  
  4487  	if iNdEx > l {
  4488  		return io.ErrUnexpectedEOF
  4489  	}
  4490  	return nil
  4491  }
  4492  func (m *MutatingWebhookConfiguration) Unmarshal(dAtA []byte) error {
  4493  	l := len(dAtA)
  4494  	iNdEx := 0
  4495  	for iNdEx < l {
  4496  		preIndex := iNdEx
  4497  		var wire uint64
  4498  		for shift := uint(0); ; shift += 7 {
  4499  			if shift >= 64 {
  4500  				return ErrIntOverflowGenerated
  4501  			}
  4502  			if iNdEx >= l {
  4503  				return io.ErrUnexpectedEOF
  4504  			}
  4505  			b := dAtA[iNdEx]
  4506  			iNdEx++
  4507  			wire |= uint64(b&0x7F) << shift
  4508  			if b < 0x80 {
  4509  				break
  4510  			}
  4511  		}
  4512  		fieldNum := int32(wire >> 3)
  4513  		wireType := int(wire & 0x7)
  4514  		if wireType == 4 {
  4515  			return fmt.Errorf("proto: MutatingWebhookConfiguration: wiretype end group for non-group")
  4516  		}
  4517  		if fieldNum <= 0 {
  4518  			return fmt.Errorf("proto: MutatingWebhookConfiguration: illegal tag %d (wire type %d)", fieldNum, wire)
  4519  		}
  4520  		switch fieldNum {
  4521  		case 1:
  4522  			if wireType != 2 {
  4523  				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
  4524  			}
  4525  			var msglen int
  4526  			for shift := uint(0); ; shift += 7 {
  4527  				if shift >= 64 {
  4528  					return ErrIntOverflowGenerated
  4529  				}
  4530  				if iNdEx >= l {
  4531  					return io.ErrUnexpectedEOF
  4532  				}
  4533  				b := dAtA[iNdEx]
  4534  				iNdEx++
  4535  				msglen |= int(b&0x7F) << shift
  4536  				if b < 0x80 {
  4537  					break
  4538  				}
  4539  			}
  4540  			if msglen < 0 {
  4541  				return ErrInvalidLengthGenerated
  4542  			}
  4543  			postIndex := iNdEx + msglen
  4544  			if postIndex < 0 {
  4545  				return ErrInvalidLengthGenerated
  4546  			}
  4547  			if postIndex > l {
  4548  				return io.ErrUnexpectedEOF
  4549  			}
  4550  			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  4551  				return err
  4552  			}
  4553  			iNdEx = postIndex
  4554  		case 2:
  4555  			if wireType != 2 {
  4556  				return fmt.Errorf("proto: wrong wireType = %d for field Webhooks", wireType)
  4557  			}
  4558  			var msglen int
  4559  			for shift := uint(0); ; shift += 7 {
  4560  				if shift >= 64 {
  4561  					return ErrIntOverflowGenerated
  4562  				}
  4563  				if iNdEx >= l {
  4564  					return io.ErrUnexpectedEOF
  4565  				}
  4566  				b := dAtA[iNdEx]
  4567  				iNdEx++
  4568  				msglen |= int(b&0x7F) << shift
  4569  				if b < 0x80 {
  4570  					break
  4571  				}
  4572  			}
  4573  			if msglen < 0 {
  4574  				return ErrInvalidLengthGenerated
  4575  			}
  4576  			postIndex := iNdEx + msglen
  4577  			if postIndex < 0 {
  4578  				return ErrInvalidLengthGenerated
  4579  			}
  4580  			if postIndex > l {
  4581  				return io.ErrUnexpectedEOF
  4582  			}
  4583  			m.Webhooks = append(m.Webhooks, MutatingWebhook{})
  4584  			if err := m.Webhooks[len(m.Webhooks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  4585  				return err
  4586  			}
  4587  			iNdEx = postIndex
  4588  		default:
  4589  			iNdEx = preIndex
  4590  			skippy, err := skipGenerated(dAtA[iNdEx:])
  4591  			if err != nil {
  4592  				return err
  4593  			}
  4594  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  4595  				return ErrInvalidLengthGenerated
  4596  			}
  4597  			if (iNdEx + skippy) > l {
  4598  				return io.ErrUnexpectedEOF
  4599  			}
  4600  			iNdEx += skippy
  4601  		}
  4602  	}
  4603  
  4604  	if iNdEx > l {
  4605  		return io.ErrUnexpectedEOF
  4606  	}
  4607  	return nil
  4608  }
  4609  func (m *MutatingWebhookConfigurationList) Unmarshal(dAtA []byte) error {
  4610  	l := len(dAtA)
  4611  	iNdEx := 0
  4612  	for iNdEx < l {
  4613  		preIndex := iNdEx
  4614  		var wire uint64
  4615  		for shift := uint(0); ; shift += 7 {
  4616  			if shift >= 64 {
  4617  				return ErrIntOverflowGenerated
  4618  			}
  4619  			if iNdEx >= l {
  4620  				return io.ErrUnexpectedEOF
  4621  			}
  4622  			b := dAtA[iNdEx]
  4623  			iNdEx++
  4624  			wire |= uint64(b&0x7F) << shift
  4625  			if b < 0x80 {
  4626  				break
  4627  			}
  4628  		}
  4629  		fieldNum := int32(wire >> 3)
  4630  		wireType := int(wire & 0x7)
  4631  		if wireType == 4 {
  4632  			return fmt.Errorf("proto: MutatingWebhookConfigurationList: wiretype end group for non-group")
  4633  		}
  4634  		if fieldNum <= 0 {
  4635  			return fmt.Errorf("proto: MutatingWebhookConfigurationList: illegal tag %d (wire type %d)", fieldNum, wire)
  4636  		}
  4637  		switch fieldNum {
  4638  		case 1:
  4639  			if wireType != 2 {
  4640  				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
  4641  			}
  4642  			var msglen int
  4643  			for shift := uint(0); ; shift += 7 {
  4644  				if shift >= 64 {
  4645  					return ErrIntOverflowGenerated
  4646  				}
  4647  				if iNdEx >= l {
  4648  					return io.ErrUnexpectedEOF
  4649  				}
  4650  				b := dAtA[iNdEx]
  4651  				iNdEx++
  4652  				msglen |= int(b&0x7F) << shift
  4653  				if b < 0x80 {
  4654  					break
  4655  				}
  4656  			}
  4657  			if msglen < 0 {
  4658  				return ErrInvalidLengthGenerated
  4659  			}
  4660  			postIndex := iNdEx + msglen
  4661  			if postIndex < 0 {
  4662  				return ErrInvalidLengthGenerated
  4663  			}
  4664  			if postIndex > l {
  4665  				return io.ErrUnexpectedEOF
  4666  			}
  4667  			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  4668  				return err
  4669  			}
  4670  			iNdEx = postIndex
  4671  		case 2:
  4672  			if wireType != 2 {
  4673  				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
  4674  			}
  4675  			var msglen int
  4676  			for shift := uint(0); ; shift += 7 {
  4677  				if shift >= 64 {
  4678  					return ErrIntOverflowGenerated
  4679  				}
  4680  				if iNdEx >= l {
  4681  					return io.ErrUnexpectedEOF
  4682  				}
  4683  				b := dAtA[iNdEx]
  4684  				iNdEx++
  4685  				msglen |= int(b&0x7F) << shift
  4686  				if b < 0x80 {
  4687  					break
  4688  				}
  4689  			}
  4690  			if msglen < 0 {
  4691  				return ErrInvalidLengthGenerated
  4692  			}
  4693  			postIndex := iNdEx + msglen
  4694  			if postIndex < 0 {
  4695  				return ErrInvalidLengthGenerated
  4696  			}
  4697  			if postIndex > l {
  4698  				return io.ErrUnexpectedEOF
  4699  			}
  4700  			m.Items = append(m.Items, MutatingWebhookConfiguration{})
  4701  			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  4702  				return err
  4703  			}
  4704  			iNdEx = postIndex
  4705  		default:
  4706  			iNdEx = preIndex
  4707  			skippy, err := skipGenerated(dAtA[iNdEx:])
  4708  			if err != nil {
  4709  				return err
  4710  			}
  4711  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  4712  				return ErrInvalidLengthGenerated
  4713  			}
  4714  			if (iNdEx + skippy) > l {
  4715  				return io.ErrUnexpectedEOF
  4716  			}
  4717  			iNdEx += skippy
  4718  		}
  4719  	}
  4720  
  4721  	if iNdEx > l {
  4722  		return io.ErrUnexpectedEOF
  4723  	}
  4724  	return nil
  4725  }
  4726  func (m *NamedRuleWithOperations) Unmarshal(dAtA []byte) error {
  4727  	l := len(dAtA)
  4728  	iNdEx := 0
  4729  	for iNdEx < l {
  4730  		preIndex := iNdEx
  4731  		var wire uint64
  4732  		for shift := uint(0); ; shift += 7 {
  4733  			if shift >= 64 {
  4734  				return ErrIntOverflowGenerated
  4735  			}
  4736  			if iNdEx >= l {
  4737  				return io.ErrUnexpectedEOF
  4738  			}
  4739  			b := dAtA[iNdEx]
  4740  			iNdEx++
  4741  			wire |= uint64(b&0x7F) << shift
  4742  			if b < 0x80 {
  4743  				break
  4744  			}
  4745  		}
  4746  		fieldNum := int32(wire >> 3)
  4747  		wireType := int(wire & 0x7)
  4748  		if wireType == 4 {
  4749  			return fmt.Errorf("proto: NamedRuleWithOperations: wiretype end group for non-group")
  4750  		}
  4751  		if fieldNum <= 0 {
  4752  			return fmt.Errorf("proto: NamedRuleWithOperations: illegal tag %d (wire type %d)", fieldNum, wire)
  4753  		}
  4754  		switch fieldNum {
  4755  		case 1:
  4756  			if wireType != 2 {
  4757  				return fmt.Errorf("proto: wrong wireType = %d for field ResourceNames", wireType)
  4758  			}
  4759  			var stringLen uint64
  4760  			for shift := uint(0); ; shift += 7 {
  4761  				if shift >= 64 {
  4762  					return ErrIntOverflowGenerated
  4763  				}
  4764  				if iNdEx >= l {
  4765  					return io.ErrUnexpectedEOF
  4766  				}
  4767  				b := dAtA[iNdEx]
  4768  				iNdEx++
  4769  				stringLen |= uint64(b&0x7F) << shift
  4770  				if b < 0x80 {
  4771  					break
  4772  				}
  4773  			}
  4774  			intStringLen := int(stringLen)
  4775  			if intStringLen < 0 {
  4776  				return ErrInvalidLengthGenerated
  4777  			}
  4778  			postIndex := iNdEx + intStringLen
  4779  			if postIndex < 0 {
  4780  				return ErrInvalidLengthGenerated
  4781  			}
  4782  			if postIndex > l {
  4783  				return io.ErrUnexpectedEOF
  4784  			}
  4785  			m.ResourceNames = append(m.ResourceNames, string(dAtA[iNdEx:postIndex]))
  4786  			iNdEx = postIndex
  4787  		case 2:
  4788  			if wireType != 2 {
  4789  				return fmt.Errorf("proto: wrong wireType = %d for field RuleWithOperations", wireType)
  4790  			}
  4791  			var msglen int
  4792  			for shift := uint(0); ; shift += 7 {
  4793  				if shift >= 64 {
  4794  					return ErrIntOverflowGenerated
  4795  				}
  4796  				if iNdEx >= l {
  4797  					return io.ErrUnexpectedEOF
  4798  				}
  4799  				b := dAtA[iNdEx]
  4800  				iNdEx++
  4801  				msglen |= int(b&0x7F) << shift
  4802  				if b < 0x80 {
  4803  					break
  4804  				}
  4805  			}
  4806  			if msglen < 0 {
  4807  				return ErrInvalidLengthGenerated
  4808  			}
  4809  			postIndex := iNdEx + msglen
  4810  			if postIndex < 0 {
  4811  				return ErrInvalidLengthGenerated
  4812  			}
  4813  			if postIndex > l {
  4814  				return io.ErrUnexpectedEOF
  4815  			}
  4816  			if err := m.RuleWithOperations.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  4817  				return err
  4818  			}
  4819  			iNdEx = postIndex
  4820  		default:
  4821  			iNdEx = preIndex
  4822  			skippy, err := skipGenerated(dAtA[iNdEx:])
  4823  			if err != nil {
  4824  				return err
  4825  			}
  4826  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  4827  				return ErrInvalidLengthGenerated
  4828  			}
  4829  			if (iNdEx + skippy) > l {
  4830  				return io.ErrUnexpectedEOF
  4831  			}
  4832  			iNdEx += skippy
  4833  		}
  4834  	}
  4835  
  4836  	if iNdEx > l {
  4837  		return io.ErrUnexpectedEOF
  4838  	}
  4839  	return nil
  4840  }
  4841  func (m *ParamKind) Unmarshal(dAtA []byte) error {
  4842  	l := len(dAtA)
  4843  	iNdEx := 0
  4844  	for iNdEx < l {
  4845  		preIndex := iNdEx
  4846  		var wire uint64
  4847  		for shift := uint(0); ; shift += 7 {
  4848  			if shift >= 64 {
  4849  				return ErrIntOverflowGenerated
  4850  			}
  4851  			if iNdEx >= l {
  4852  				return io.ErrUnexpectedEOF
  4853  			}
  4854  			b := dAtA[iNdEx]
  4855  			iNdEx++
  4856  			wire |= uint64(b&0x7F) << shift
  4857  			if b < 0x80 {
  4858  				break
  4859  			}
  4860  		}
  4861  		fieldNum := int32(wire >> 3)
  4862  		wireType := int(wire & 0x7)
  4863  		if wireType == 4 {
  4864  			return fmt.Errorf("proto: ParamKind: wiretype end group for non-group")
  4865  		}
  4866  		if fieldNum <= 0 {
  4867  			return fmt.Errorf("proto: ParamKind: illegal tag %d (wire type %d)", fieldNum, wire)
  4868  		}
  4869  		switch fieldNum {
  4870  		case 1:
  4871  			if wireType != 2 {
  4872  				return fmt.Errorf("proto: wrong wireType = %d for field APIVersion", wireType)
  4873  			}
  4874  			var stringLen uint64
  4875  			for shift := uint(0); ; shift += 7 {
  4876  				if shift >= 64 {
  4877  					return ErrIntOverflowGenerated
  4878  				}
  4879  				if iNdEx >= l {
  4880  					return io.ErrUnexpectedEOF
  4881  				}
  4882  				b := dAtA[iNdEx]
  4883  				iNdEx++
  4884  				stringLen |= uint64(b&0x7F) << shift
  4885  				if b < 0x80 {
  4886  					break
  4887  				}
  4888  			}
  4889  			intStringLen := int(stringLen)
  4890  			if intStringLen < 0 {
  4891  				return ErrInvalidLengthGenerated
  4892  			}
  4893  			postIndex := iNdEx + intStringLen
  4894  			if postIndex < 0 {
  4895  				return ErrInvalidLengthGenerated
  4896  			}
  4897  			if postIndex > l {
  4898  				return io.ErrUnexpectedEOF
  4899  			}
  4900  			m.APIVersion = string(dAtA[iNdEx:postIndex])
  4901  			iNdEx = postIndex
  4902  		case 2:
  4903  			if wireType != 2 {
  4904  				return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
  4905  			}
  4906  			var stringLen uint64
  4907  			for shift := uint(0); ; shift += 7 {
  4908  				if shift >= 64 {
  4909  					return ErrIntOverflowGenerated
  4910  				}
  4911  				if iNdEx >= l {
  4912  					return io.ErrUnexpectedEOF
  4913  				}
  4914  				b := dAtA[iNdEx]
  4915  				iNdEx++
  4916  				stringLen |= uint64(b&0x7F) << shift
  4917  				if b < 0x80 {
  4918  					break
  4919  				}
  4920  			}
  4921  			intStringLen := int(stringLen)
  4922  			if intStringLen < 0 {
  4923  				return ErrInvalidLengthGenerated
  4924  			}
  4925  			postIndex := iNdEx + intStringLen
  4926  			if postIndex < 0 {
  4927  				return ErrInvalidLengthGenerated
  4928  			}
  4929  			if postIndex > l {
  4930  				return io.ErrUnexpectedEOF
  4931  			}
  4932  			m.Kind = string(dAtA[iNdEx:postIndex])
  4933  			iNdEx = postIndex
  4934  		default:
  4935  			iNdEx = preIndex
  4936  			skippy, err := skipGenerated(dAtA[iNdEx:])
  4937  			if err != nil {
  4938  				return err
  4939  			}
  4940  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  4941  				return ErrInvalidLengthGenerated
  4942  			}
  4943  			if (iNdEx + skippy) > l {
  4944  				return io.ErrUnexpectedEOF
  4945  			}
  4946  			iNdEx += skippy
  4947  		}
  4948  	}
  4949  
  4950  	if iNdEx > l {
  4951  		return io.ErrUnexpectedEOF
  4952  	}
  4953  	return nil
  4954  }
  4955  func (m *ParamRef) Unmarshal(dAtA []byte) error {
  4956  	l := len(dAtA)
  4957  	iNdEx := 0
  4958  	for iNdEx < l {
  4959  		preIndex := iNdEx
  4960  		var wire uint64
  4961  		for shift := uint(0); ; shift += 7 {
  4962  			if shift >= 64 {
  4963  				return ErrIntOverflowGenerated
  4964  			}
  4965  			if iNdEx >= l {
  4966  				return io.ErrUnexpectedEOF
  4967  			}
  4968  			b := dAtA[iNdEx]
  4969  			iNdEx++
  4970  			wire |= uint64(b&0x7F) << shift
  4971  			if b < 0x80 {
  4972  				break
  4973  			}
  4974  		}
  4975  		fieldNum := int32(wire >> 3)
  4976  		wireType := int(wire & 0x7)
  4977  		if wireType == 4 {
  4978  			return fmt.Errorf("proto: ParamRef: wiretype end group for non-group")
  4979  		}
  4980  		if fieldNum <= 0 {
  4981  			return fmt.Errorf("proto: ParamRef: illegal tag %d (wire type %d)", fieldNum, wire)
  4982  		}
  4983  		switch fieldNum {
  4984  		case 1:
  4985  			if wireType != 2 {
  4986  				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
  4987  			}
  4988  			var stringLen uint64
  4989  			for shift := uint(0); ; shift += 7 {
  4990  				if shift >= 64 {
  4991  					return ErrIntOverflowGenerated
  4992  				}
  4993  				if iNdEx >= l {
  4994  					return io.ErrUnexpectedEOF
  4995  				}
  4996  				b := dAtA[iNdEx]
  4997  				iNdEx++
  4998  				stringLen |= uint64(b&0x7F) << shift
  4999  				if b < 0x80 {
  5000  					break
  5001  				}
  5002  			}
  5003  			intStringLen := int(stringLen)
  5004  			if intStringLen < 0 {
  5005  				return ErrInvalidLengthGenerated
  5006  			}
  5007  			postIndex := iNdEx + intStringLen
  5008  			if postIndex < 0 {
  5009  				return ErrInvalidLengthGenerated
  5010  			}
  5011  			if postIndex > l {
  5012  				return io.ErrUnexpectedEOF
  5013  			}
  5014  			m.Name = string(dAtA[iNdEx:postIndex])
  5015  			iNdEx = postIndex
  5016  		case 2:
  5017  			if wireType != 2 {
  5018  				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
  5019  			}
  5020  			var stringLen uint64
  5021  			for shift := uint(0); ; shift += 7 {
  5022  				if shift >= 64 {
  5023  					return ErrIntOverflowGenerated
  5024  				}
  5025  				if iNdEx >= l {
  5026  					return io.ErrUnexpectedEOF
  5027  				}
  5028  				b := dAtA[iNdEx]
  5029  				iNdEx++
  5030  				stringLen |= uint64(b&0x7F) << shift
  5031  				if b < 0x80 {
  5032  					break
  5033  				}
  5034  			}
  5035  			intStringLen := int(stringLen)
  5036  			if intStringLen < 0 {
  5037  				return ErrInvalidLengthGenerated
  5038  			}
  5039  			postIndex := iNdEx + intStringLen
  5040  			if postIndex < 0 {
  5041  				return ErrInvalidLengthGenerated
  5042  			}
  5043  			if postIndex > l {
  5044  				return io.ErrUnexpectedEOF
  5045  			}
  5046  			m.Namespace = string(dAtA[iNdEx:postIndex])
  5047  			iNdEx = postIndex
  5048  		case 3:
  5049  			if wireType != 2 {
  5050  				return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
  5051  			}
  5052  			var msglen int
  5053  			for shift := uint(0); ; shift += 7 {
  5054  				if shift >= 64 {
  5055  					return ErrIntOverflowGenerated
  5056  				}
  5057  				if iNdEx >= l {
  5058  					return io.ErrUnexpectedEOF
  5059  				}
  5060  				b := dAtA[iNdEx]
  5061  				iNdEx++
  5062  				msglen |= int(b&0x7F) << shift
  5063  				if b < 0x80 {
  5064  					break
  5065  				}
  5066  			}
  5067  			if msglen < 0 {
  5068  				return ErrInvalidLengthGenerated
  5069  			}
  5070  			postIndex := iNdEx + msglen
  5071  			if postIndex < 0 {
  5072  				return ErrInvalidLengthGenerated
  5073  			}
  5074  			if postIndex > l {
  5075  				return io.ErrUnexpectedEOF
  5076  			}
  5077  			if m.Selector == nil {
  5078  				m.Selector = &v1.LabelSelector{}
  5079  			}
  5080  			if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  5081  				return err
  5082  			}
  5083  			iNdEx = postIndex
  5084  		case 4:
  5085  			if wireType != 2 {
  5086  				return fmt.Errorf("proto: wrong wireType = %d for field ParameterNotFoundAction", wireType)
  5087  			}
  5088  			var stringLen uint64
  5089  			for shift := uint(0); ; shift += 7 {
  5090  				if shift >= 64 {
  5091  					return ErrIntOverflowGenerated
  5092  				}
  5093  				if iNdEx >= l {
  5094  					return io.ErrUnexpectedEOF
  5095  				}
  5096  				b := dAtA[iNdEx]
  5097  				iNdEx++
  5098  				stringLen |= uint64(b&0x7F) << shift
  5099  				if b < 0x80 {
  5100  					break
  5101  				}
  5102  			}
  5103  			intStringLen := int(stringLen)
  5104  			if intStringLen < 0 {
  5105  				return ErrInvalidLengthGenerated
  5106  			}
  5107  			postIndex := iNdEx + intStringLen
  5108  			if postIndex < 0 {
  5109  				return ErrInvalidLengthGenerated
  5110  			}
  5111  			if postIndex > l {
  5112  				return io.ErrUnexpectedEOF
  5113  			}
  5114  			s := ParameterNotFoundActionType(dAtA[iNdEx:postIndex])
  5115  			m.ParameterNotFoundAction = &s
  5116  			iNdEx = postIndex
  5117  		default:
  5118  			iNdEx = preIndex
  5119  			skippy, err := skipGenerated(dAtA[iNdEx:])
  5120  			if err != nil {
  5121  				return err
  5122  			}
  5123  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  5124  				return ErrInvalidLengthGenerated
  5125  			}
  5126  			if (iNdEx + skippy) > l {
  5127  				return io.ErrUnexpectedEOF
  5128  			}
  5129  			iNdEx += skippy
  5130  		}
  5131  	}
  5132  
  5133  	if iNdEx > l {
  5134  		return io.ErrUnexpectedEOF
  5135  	}
  5136  	return nil
  5137  }
  5138  func (m *Rule) Unmarshal(dAtA []byte) error {
  5139  	l := len(dAtA)
  5140  	iNdEx := 0
  5141  	for iNdEx < l {
  5142  		preIndex := iNdEx
  5143  		var wire uint64
  5144  		for shift := uint(0); ; shift += 7 {
  5145  			if shift >= 64 {
  5146  				return ErrIntOverflowGenerated
  5147  			}
  5148  			if iNdEx >= l {
  5149  				return io.ErrUnexpectedEOF
  5150  			}
  5151  			b := dAtA[iNdEx]
  5152  			iNdEx++
  5153  			wire |= uint64(b&0x7F) << shift
  5154  			if b < 0x80 {
  5155  				break
  5156  			}
  5157  		}
  5158  		fieldNum := int32(wire >> 3)
  5159  		wireType := int(wire & 0x7)
  5160  		if wireType == 4 {
  5161  			return fmt.Errorf("proto: Rule: wiretype end group for non-group")
  5162  		}
  5163  		if fieldNum <= 0 {
  5164  			return fmt.Errorf("proto: Rule: illegal tag %d (wire type %d)", fieldNum, wire)
  5165  		}
  5166  		switch fieldNum {
  5167  		case 1:
  5168  			if wireType != 2 {
  5169  				return fmt.Errorf("proto: wrong wireType = %d for field APIGroups", wireType)
  5170  			}
  5171  			var stringLen uint64
  5172  			for shift := uint(0); ; shift += 7 {
  5173  				if shift >= 64 {
  5174  					return ErrIntOverflowGenerated
  5175  				}
  5176  				if iNdEx >= l {
  5177  					return io.ErrUnexpectedEOF
  5178  				}
  5179  				b := dAtA[iNdEx]
  5180  				iNdEx++
  5181  				stringLen |= uint64(b&0x7F) << shift
  5182  				if b < 0x80 {
  5183  					break
  5184  				}
  5185  			}
  5186  			intStringLen := int(stringLen)
  5187  			if intStringLen < 0 {
  5188  				return ErrInvalidLengthGenerated
  5189  			}
  5190  			postIndex := iNdEx + intStringLen
  5191  			if postIndex < 0 {
  5192  				return ErrInvalidLengthGenerated
  5193  			}
  5194  			if postIndex > l {
  5195  				return io.ErrUnexpectedEOF
  5196  			}
  5197  			m.APIGroups = append(m.APIGroups, string(dAtA[iNdEx:postIndex]))
  5198  			iNdEx = postIndex
  5199  		case 2:
  5200  			if wireType != 2 {
  5201  				return fmt.Errorf("proto: wrong wireType = %d for field APIVersions", wireType)
  5202  			}
  5203  			var stringLen uint64
  5204  			for shift := uint(0); ; shift += 7 {
  5205  				if shift >= 64 {
  5206  					return ErrIntOverflowGenerated
  5207  				}
  5208  				if iNdEx >= l {
  5209  					return io.ErrUnexpectedEOF
  5210  				}
  5211  				b := dAtA[iNdEx]
  5212  				iNdEx++
  5213  				stringLen |= uint64(b&0x7F) << shift
  5214  				if b < 0x80 {
  5215  					break
  5216  				}
  5217  			}
  5218  			intStringLen := int(stringLen)
  5219  			if intStringLen < 0 {
  5220  				return ErrInvalidLengthGenerated
  5221  			}
  5222  			postIndex := iNdEx + intStringLen
  5223  			if postIndex < 0 {
  5224  				return ErrInvalidLengthGenerated
  5225  			}
  5226  			if postIndex > l {
  5227  				return io.ErrUnexpectedEOF
  5228  			}
  5229  			m.APIVersions = append(m.APIVersions, string(dAtA[iNdEx:postIndex]))
  5230  			iNdEx = postIndex
  5231  		case 3:
  5232  			if wireType != 2 {
  5233  				return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType)
  5234  			}
  5235  			var stringLen uint64
  5236  			for shift := uint(0); ; shift += 7 {
  5237  				if shift >= 64 {
  5238  					return ErrIntOverflowGenerated
  5239  				}
  5240  				if iNdEx >= l {
  5241  					return io.ErrUnexpectedEOF
  5242  				}
  5243  				b := dAtA[iNdEx]
  5244  				iNdEx++
  5245  				stringLen |= uint64(b&0x7F) << shift
  5246  				if b < 0x80 {
  5247  					break
  5248  				}
  5249  			}
  5250  			intStringLen := int(stringLen)
  5251  			if intStringLen < 0 {
  5252  				return ErrInvalidLengthGenerated
  5253  			}
  5254  			postIndex := iNdEx + intStringLen
  5255  			if postIndex < 0 {
  5256  				return ErrInvalidLengthGenerated
  5257  			}
  5258  			if postIndex > l {
  5259  				return io.ErrUnexpectedEOF
  5260  			}
  5261  			m.Resources = append(m.Resources, string(dAtA[iNdEx:postIndex]))
  5262  			iNdEx = postIndex
  5263  		case 4:
  5264  			if wireType != 2 {
  5265  				return fmt.Errorf("proto: wrong wireType = %d for field Scope", wireType)
  5266  			}
  5267  			var stringLen uint64
  5268  			for shift := uint(0); ; shift += 7 {
  5269  				if shift >= 64 {
  5270  					return ErrIntOverflowGenerated
  5271  				}
  5272  				if iNdEx >= l {
  5273  					return io.ErrUnexpectedEOF
  5274  				}
  5275  				b := dAtA[iNdEx]
  5276  				iNdEx++
  5277  				stringLen |= uint64(b&0x7F) << shift
  5278  				if b < 0x80 {
  5279  					break
  5280  				}
  5281  			}
  5282  			intStringLen := int(stringLen)
  5283  			if intStringLen < 0 {
  5284  				return ErrInvalidLengthGenerated
  5285  			}
  5286  			postIndex := iNdEx + intStringLen
  5287  			if postIndex < 0 {
  5288  				return ErrInvalidLengthGenerated
  5289  			}
  5290  			if postIndex > l {
  5291  				return io.ErrUnexpectedEOF
  5292  			}
  5293  			s := ScopeType(dAtA[iNdEx:postIndex])
  5294  			m.Scope = &s
  5295  			iNdEx = postIndex
  5296  		default:
  5297  			iNdEx = preIndex
  5298  			skippy, err := skipGenerated(dAtA[iNdEx:])
  5299  			if err != nil {
  5300  				return err
  5301  			}
  5302  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  5303  				return ErrInvalidLengthGenerated
  5304  			}
  5305  			if (iNdEx + skippy) > l {
  5306  				return io.ErrUnexpectedEOF
  5307  			}
  5308  			iNdEx += skippy
  5309  		}
  5310  	}
  5311  
  5312  	if iNdEx > l {
  5313  		return io.ErrUnexpectedEOF
  5314  	}
  5315  	return nil
  5316  }
  5317  func (m *RuleWithOperations) Unmarshal(dAtA []byte) error {
  5318  	l := len(dAtA)
  5319  	iNdEx := 0
  5320  	for iNdEx < l {
  5321  		preIndex := iNdEx
  5322  		var wire uint64
  5323  		for shift := uint(0); ; shift += 7 {
  5324  			if shift >= 64 {
  5325  				return ErrIntOverflowGenerated
  5326  			}
  5327  			if iNdEx >= l {
  5328  				return io.ErrUnexpectedEOF
  5329  			}
  5330  			b := dAtA[iNdEx]
  5331  			iNdEx++
  5332  			wire |= uint64(b&0x7F) << shift
  5333  			if b < 0x80 {
  5334  				break
  5335  			}
  5336  		}
  5337  		fieldNum := int32(wire >> 3)
  5338  		wireType := int(wire & 0x7)
  5339  		if wireType == 4 {
  5340  			return fmt.Errorf("proto: RuleWithOperations: wiretype end group for non-group")
  5341  		}
  5342  		if fieldNum <= 0 {
  5343  			return fmt.Errorf("proto: RuleWithOperations: illegal tag %d (wire type %d)", fieldNum, wire)
  5344  		}
  5345  		switch fieldNum {
  5346  		case 1:
  5347  			if wireType != 2 {
  5348  				return fmt.Errorf("proto: wrong wireType = %d for field Operations", wireType)
  5349  			}
  5350  			var stringLen uint64
  5351  			for shift := uint(0); ; shift += 7 {
  5352  				if shift >= 64 {
  5353  					return ErrIntOverflowGenerated
  5354  				}
  5355  				if iNdEx >= l {
  5356  					return io.ErrUnexpectedEOF
  5357  				}
  5358  				b := dAtA[iNdEx]
  5359  				iNdEx++
  5360  				stringLen |= uint64(b&0x7F) << shift
  5361  				if b < 0x80 {
  5362  					break
  5363  				}
  5364  			}
  5365  			intStringLen := int(stringLen)
  5366  			if intStringLen < 0 {
  5367  				return ErrInvalidLengthGenerated
  5368  			}
  5369  			postIndex := iNdEx + intStringLen
  5370  			if postIndex < 0 {
  5371  				return ErrInvalidLengthGenerated
  5372  			}
  5373  			if postIndex > l {
  5374  				return io.ErrUnexpectedEOF
  5375  			}
  5376  			m.Operations = append(m.Operations, OperationType(dAtA[iNdEx:postIndex]))
  5377  			iNdEx = postIndex
  5378  		case 2:
  5379  			if wireType != 2 {
  5380  				return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType)
  5381  			}
  5382  			var msglen int
  5383  			for shift := uint(0); ; shift += 7 {
  5384  				if shift >= 64 {
  5385  					return ErrIntOverflowGenerated
  5386  				}
  5387  				if iNdEx >= l {
  5388  					return io.ErrUnexpectedEOF
  5389  				}
  5390  				b := dAtA[iNdEx]
  5391  				iNdEx++
  5392  				msglen |= int(b&0x7F) << shift
  5393  				if b < 0x80 {
  5394  					break
  5395  				}
  5396  			}
  5397  			if msglen < 0 {
  5398  				return ErrInvalidLengthGenerated
  5399  			}
  5400  			postIndex := iNdEx + msglen
  5401  			if postIndex < 0 {
  5402  				return ErrInvalidLengthGenerated
  5403  			}
  5404  			if postIndex > l {
  5405  				return io.ErrUnexpectedEOF
  5406  			}
  5407  			if err := m.Rule.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  5408  				return err
  5409  			}
  5410  			iNdEx = postIndex
  5411  		default:
  5412  			iNdEx = preIndex
  5413  			skippy, err := skipGenerated(dAtA[iNdEx:])
  5414  			if err != nil {
  5415  				return err
  5416  			}
  5417  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  5418  				return ErrInvalidLengthGenerated
  5419  			}
  5420  			if (iNdEx + skippy) > l {
  5421  				return io.ErrUnexpectedEOF
  5422  			}
  5423  			iNdEx += skippy
  5424  		}
  5425  	}
  5426  
  5427  	if iNdEx > l {
  5428  		return io.ErrUnexpectedEOF
  5429  	}
  5430  	return nil
  5431  }
  5432  func (m *ServiceReference) Unmarshal(dAtA []byte) error {
  5433  	l := len(dAtA)
  5434  	iNdEx := 0
  5435  	for iNdEx < l {
  5436  		preIndex := iNdEx
  5437  		var wire uint64
  5438  		for shift := uint(0); ; shift += 7 {
  5439  			if shift >= 64 {
  5440  				return ErrIntOverflowGenerated
  5441  			}
  5442  			if iNdEx >= l {
  5443  				return io.ErrUnexpectedEOF
  5444  			}
  5445  			b := dAtA[iNdEx]
  5446  			iNdEx++
  5447  			wire |= uint64(b&0x7F) << shift
  5448  			if b < 0x80 {
  5449  				break
  5450  			}
  5451  		}
  5452  		fieldNum := int32(wire >> 3)
  5453  		wireType := int(wire & 0x7)
  5454  		if wireType == 4 {
  5455  			return fmt.Errorf("proto: ServiceReference: wiretype end group for non-group")
  5456  		}
  5457  		if fieldNum <= 0 {
  5458  			return fmt.Errorf("proto: ServiceReference: illegal tag %d (wire type %d)", fieldNum, wire)
  5459  		}
  5460  		switch fieldNum {
  5461  		case 1:
  5462  			if wireType != 2 {
  5463  				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
  5464  			}
  5465  			var stringLen uint64
  5466  			for shift := uint(0); ; shift += 7 {
  5467  				if shift >= 64 {
  5468  					return ErrIntOverflowGenerated
  5469  				}
  5470  				if iNdEx >= l {
  5471  					return io.ErrUnexpectedEOF
  5472  				}
  5473  				b := dAtA[iNdEx]
  5474  				iNdEx++
  5475  				stringLen |= uint64(b&0x7F) << shift
  5476  				if b < 0x80 {
  5477  					break
  5478  				}
  5479  			}
  5480  			intStringLen := int(stringLen)
  5481  			if intStringLen < 0 {
  5482  				return ErrInvalidLengthGenerated
  5483  			}
  5484  			postIndex := iNdEx + intStringLen
  5485  			if postIndex < 0 {
  5486  				return ErrInvalidLengthGenerated
  5487  			}
  5488  			if postIndex > l {
  5489  				return io.ErrUnexpectedEOF
  5490  			}
  5491  			m.Namespace = string(dAtA[iNdEx:postIndex])
  5492  			iNdEx = postIndex
  5493  		case 2:
  5494  			if wireType != 2 {
  5495  				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
  5496  			}
  5497  			var stringLen uint64
  5498  			for shift := uint(0); ; shift += 7 {
  5499  				if shift >= 64 {
  5500  					return ErrIntOverflowGenerated
  5501  				}
  5502  				if iNdEx >= l {
  5503  					return io.ErrUnexpectedEOF
  5504  				}
  5505  				b := dAtA[iNdEx]
  5506  				iNdEx++
  5507  				stringLen |= uint64(b&0x7F) << shift
  5508  				if b < 0x80 {
  5509  					break
  5510  				}
  5511  			}
  5512  			intStringLen := int(stringLen)
  5513  			if intStringLen < 0 {
  5514  				return ErrInvalidLengthGenerated
  5515  			}
  5516  			postIndex := iNdEx + intStringLen
  5517  			if postIndex < 0 {
  5518  				return ErrInvalidLengthGenerated
  5519  			}
  5520  			if postIndex > l {
  5521  				return io.ErrUnexpectedEOF
  5522  			}
  5523  			m.Name = string(dAtA[iNdEx:postIndex])
  5524  			iNdEx = postIndex
  5525  		case 3:
  5526  			if wireType != 2 {
  5527  				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
  5528  			}
  5529  			var stringLen uint64
  5530  			for shift := uint(0); ; shift += 7 {
  5531  				if shift >= 64 {
  5532  					return ErrIntOverflowGenerated
  5533  				}
  5534  				if iNdEx >= l {
  5535  					return io.ErrUnexpectedEOF
  5536  				}
  5537  				b := dAtA[iNdEx]
  5538  				iNdEx++
  5539  				stringLen |= uint64(b&0x7F) << shift
  5540  				if b < 0x80 {
  5541  					break
  5542  				}
  5543  			}
  5544  			intStringLen := int(stringLen)
  5545  			if intStringLen < 0 {
  5546  				return ErrInvalidLengthGenerated
  5547  			}
  5548  			postIndex := iNdEx + intStringLen
  5549  			if postIndex < 0 {
  5550  				return ErrInvalidLengthGenerated
  5551  			}
  5552  			if postIndex > l {
  5553  				return io.ErrUnexpectedEOF
  5554  			}
  5555  			s := string(dAtA[iNdEx:postIndex])
  5556  			m.Path = &s
  5557  			iNdEx = postIndex
  5558  		case 4:
  5559  			if wireType != 0 {
  5560  				return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
  5561  			}
  5562  			var v int32
  5563  			for shift := uint(0); ; shift += 7 {
  5564  				if shift >= 64 {
  5565  					return ErrIntOverflowGenerated
  5566  				}
  5567  				if iNdEx >= l {
  5568  					return io.ErrUnexpectedEOF
  5569  				}
  5570  				b := dAtA[iNdEx]
  5571  				iNdEx++
  5572  				v |= int32(b&0x7F) << shift
  5573  				if b < 0x80 {
  5574  					break
  5575  				}
  5576  			}
  5577  			m.Port = &v
  5578  		default:
  5579  			iNdEx = preIndex
  5580  			skippy, err := skipGenerated(dAtA[iNdEx:])
  5581  			if err != nil {
  5582  				return err
  5583  			}
  5584  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  5585  				return ErrInvalidLengthGenerated
  5586  			}
  5587  			if (iNdEx + skippy) > l {
  5588  				return io.ErrUnexpectedEOF
  5589  			}
  5590  			iNdEx += skippy
  5591  		}
  5592  	}
  5593  
  5594  	if iNdEx > l {
  5595  		return io.ErrUnexpectedEOF
  5596  	}
  5597  	return nil
  5598  }
  5599  func (m *TypeChecking) Unmarshal(dAtA []byte) error {
  5600  	l := len(dAtA)
  5601  	iNdEx := 0
  5602  	for iNdEx < l {
  5603  		preIndex := iNdEx
  5604  		var wire uint64
  5605  		for shift := uint(0); ; shift += 7 {
  5606  			if shift >= 64 {
  5607  				return ErrIntOverflowGenerated
  5608  			}
  5609  			if iNdEx >= l {
  5610  				return io.ErrUnexpectedEOF
  5611  			}
  5612  			b := dAtA[iNdEx]
  5613  			iNdEx++
  5614  			wire |= uint64(b&0x7F) << shift
  5615  			if b < 0x80 {
  5616  				break
  5617  			}
  5618  		}
  5619  		fieldNum := int32(wire >> 3)
  5620  		wireType := int(wire & 0x7)
  5621  		if wireType == 4 {
  5622  			return fmt.Errorf("proto: TypeChecking: wiretype end group for non-group")
  5623  		}
  5624  		if fieldNum <= 0 {
  5625  			return fmt.Errorf("proto: TypeChecking: illegal tag %d (wire type %d)", fieldNum, wire)
  5626  		}
  5627  		switch fieldNum {
  5628  		case 1:
  5629  			if wireType != 2 {
  5630  				return fmt.Errorf("proto: wrong wireType = %d for field ExpressionWarnings", wireType)
  5631  			}
  5632  			var msglen int
  5633  			for shift := uint(0); ; shift += 7 {
  5634  				if shift >= 64 {
  5635  					return ErrIntOverflowGenerated
  5636  				}
  5637  				if iNdEx >= l {
  5638  					return io.ErrUnexpectedEOF
  5639  				}
  5640  				b := dAtA[iNdEx]
  5641  				iNdEx++
  5642  				msglen |= int(b&0x7F) << shift
  5643  				if b < 0x80 {
  5644  					break
  5645  				}
  5646  			}
  5647  			if msglen < 0 {
  5648  				return ErrInvalidLengthGenerated
  5649  			}
  5650  			postIndex := iNdEx + msglen
  5651  			if postIndex < 0 {
  5652  				return ErrInvalidLengthGenerated
  5653  			}
  5654  			if postIndex > l {
  5655  				return io.ErrUnexpectedEOF
  5656  			}
  5657  			m.ExpressionWarnings = append(m.ExpressionWarnings, ExpressionWarning{})
  5658  			if err := m.ExpressionWarnings[len(m.ExpressionWarnings)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  5659  				return err
  5660  			}
  5661  			iNdEx = postIndex
  5662  		default:
  5663  			iNdEx = preIndex
  5664  			skippy, err := skipGenerated(dAtA[iNdEx:])
  5665  			if err != nil {
  5666  				return err
  5667  			}
  5668  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  5669  				return ErrInvalidLengthGenerated
  5670  			}
  5671  			if (iNdEx + skippy) > l {
  5672  				return io.ErrUnexpectedEOF
  5673  			}
  5674  			iNdEx += skippy
  5675  		}
  5676  	}
  5677  
  5678  	if iNdEx > l {
  5679  		return io.ErrUnexpectedEOF
  5680  	}
  5681  	return nil
  5682  }
  5683  func (m *ValidatingAdmissionPolicy) Unmarshal(dAtA []byte) error {
  5684  	l := len(dAtA)
  5685  	iNdEx := 0
  5686  	for iNdEx < l {
  5687  		preIndex := iNdEx
  5688  		var wire uint64
  5689  		for shift := uint(0); ; shift += 7 {
  5690  			if shift >= 64 {
  5691  				return ErrIntOverflowGenerated
  5692  			}
  5693  			if iNdEx >= l {
  5694  				return io.ErrUnexpectedEOF
  5695  			}
  5696  			b := dAtA[iNdEx]
  5697  			iNdEx++
  5698  			wire |= uint64(b&0x7F) << shift
  5699  			if b < 0x80 {
  5700  				break
  5701  			}
  5702  		}
  5703  		fieldNum := int32(wire >> 3)
  5704  		wireType := int(wire & 0x7)
  5705  		if wireType == 4 {
  5706  			return fmt.Errorf("proto: ValidatingAdmissionPolicy: wiretype end group for non-group")
  5707  		}
  5708  		if fieldNum <= 0 {
  5709  			return fmt.Errorf("proto: ValidatingAdmissionPolicy: illegal tag %d (wire type %d)", fieldNum, wire)
  5710  		}
  5711  		switch fieldNum {
  5712  		case 1:
  5713  			if wireType != 2 {
  5714  				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
  5715  			}
  5716  			var msglen int
  5717  			for shift := uint(0); ; shift += 7 {
  5718  				if shift >= 64 {
  5719  					return ErrIntOverflowGenerated
  5720  				}
  5721  				if iNdEx >= l {
  5722  					return io.ErrUnexpectedEOF
  5723  				}
  5724  				b := dAtA[iNdEx]
  5725  				iNdEx++
  5726  				msglen |= int(b&0x7F) << shift
  5727  				if b < 0x80 {
  5728  					break
  5729  				}
  5730  			}
  5731  			if msglen < 0 {
  5732  				return ErrInvalidLengthGenerated
  5733  			}
  5734  			postIndex := iNdEx + msglen
  5735  			if postIndex < 0 {
  5736  				return ErrInvalidLengthGenerated
  5737  			}
  5738  			if postIndex > l {
  5739  				return io.ErrUnexpectedEOF
  5740  			}
  5741  			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  5742  				return err
  5743  			}
  5744  			iNdEx = postIndex
  5745  		case 2:
  5746  			if wireType != 2 {
  5747  				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
  5748  			}
  5749  			var msglen int
  5750  			for shift := uint(0); ; shift += 7 {
  5751  				if shift >= 64 {
  5752  					return ErrIntOverflowGenerated
  5753  				}
  5754  				if iNdEx >= l {
  5755  					return io.ErrUnexpectedEOF
  5756  				}
  5757  				b := dAtA[iNdEx]
  5758  				iNdEx++
  5759  				msglen |= int(b&0x7F) << shift
  5760  				if b < 0x80 {
  5761  					break
  5762  				}
  5763  			}
  5764  			if msglen < 0 {
  5765  				return ErrInvalidLengthGenerated
  5766  			}
  5767  			postIndex := iNdEx + msglen
  5768  			if postIndex < 0 {
  5769  				return ErrInvalidLengthGenerated
  5770  			}
  5771  			if postIndex > l {
  5772  				return io.ErrUnexpectedEOF
  5773  			}
  5774  			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  5775  				return err
  5776  			}
  5777  			iNdEx = postIndex
  5778  		case 3:
  5779  			if wireType != 2 {
  5780  				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
  5781  			}
  5782  			var msglen int
  5783  			for shift := uint(0); ; shift += 7 {
  5784  				if shift >= 64 {
  5785  					return ErrIntOverflowGenerated
  5786  				}
  5787  				if iNdEx >= l {
  5788  					return io.ErrUnexpectedEOF
  5789  				}
  5790  				b := dAtA[iNdEx]
  5791  				iNdEx++
  5792  				msglen |= int(b&0x7F) << shift
  5793  				if b < 0x80 {
  5794  					break
  5795  				}
  5796  			}
  5797  			if msglen < 0 {
  5798  				return ErrInvalidLengthGenerated
  5799  			}
  5800  			postIndex := iNdEx + msglen
  5801  			if postIndex < 0 {
  5802  				return ErrInvalidLengthGenerated
  5803  			}
  5804  			if postIndex > l {
  5805  				return io.ErrUnexpectedEOF
  5806  			}
  5807  			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  5808  				return err
  5809  			}
  5810  			iNdEx = postIndex
  5811  		default:
  5812  			iNdEx = preIndex
  5813  			skippy, err := skipGenerated(dAtA[iNdEx:])
  5814  			if err != nil {
  5815  				return err
  5816  			}
  5817  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  5818  				return ErrInvalidLengthGenerated
  5819  			}
  5820  			if (iNdEx + skippy) > l {
  5821  				return io.ErrUnexpectedEOF
  5822  			}
  5823  			iNdEx += skippy
  5824  		}
  5825  	}
  5826  
  5827  	if iNdEx > l {
  5828  		return io.ErrUnexpectedEOF
  5829  	}
  5830  	return nil
  5831  }
  5832  func (m *ValidatingAdmissionPolicyBinding) Unmarshal(dAtA []byte) error {
  5833  	l := len(dAtA)
  5834  	iNdEx := 0
  5835  	for iNdEx < l {
  5836  		preIndex := iNdEx
  5837  		var wire uint64
  5838  		for shift := uint(0); ; shift += 7 {
  5839  			if shift >= 64 {
  5840  				return ErrIntOverflowGenerated
  5841  			}
  5842  			if iNdEx >= l {
  5843  				return io.ErrUnexpectedEOF
  5844  			}
  5845  			b := dAtA[iNdEx]
  5846  			iNdEx++
  5847  			wire |= uint64(b&0x7F) << shift
  5848  			if b < 0x80 {
  5849  				break
  5850  			}
  5851  		}
  5852  		fieldNum := int32(wire >> 3)
  5853  		wireType := int(wire & 0x7)
  5854  		if wireType == 4 {
  5855  			return fmt.Errorf("proto: ValidatingAdmissionPolicyBinding: wiretype end group for non-group")
  5856  		}
  5857  		if fieldNum <= 0 {
  5858  			return fmt.Errorf("proto: ValidatingAdmissionPolicyBinding: illegal tag %d (wire type %d)", fieldNum, wire)
  5859  		}
  5860  		switch fieldNum {
  5861  		case 1:
  5862  			if wireType != 2 {
  5863  				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
  5864  			}
  5865  			var msglen int
  5866  			for shift := uint(0); ; shift += 7 {
  5867  				if shift >= 64 {
  5868  					return ErrIntOverflowGenerated
  5869  				}
  5870  				if iNdEx >= l {
  5871  					return io.ErrUnexpectedEOF
  5872  				}
  5873  				b := dAtA[iNdEx]
  5874  				iNdEx++
  5875  				msglen |= int(b&0x7F) << shift
  5876  				if b < 0x80 {
  5877  					break
  5878  				}
  5879  			}
  5880  			if msglen < 0 {
  5881  				return ErrInvalidLengthGenerated
  5882  			}
  5883  			postIndex := iNdEx + msglen
  5884  			if postIndex < 0 {
  5885  				return ErrInvalidLengthGenerated
  5886  			}
  5887  			if postIndex > l {
  5888  				return io.ErrUnexpectedEOF
  5889  			}
  5890  			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  5891  				return err
  5892  			}
  5893  			iNdEx = postIndex
  5894  		case 2:
  5895  			if wireType != 2 {
  5896  				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
  5897  			}
  5898  			var msglen int
  5899  			for shift := uint(0); ; shift += 7 {
  5900  				if shift >= 64 {
  5901  					return ErrIntOverflowGenerated
  5902  				}
  5903  				if iNdEx >= l {
  5904  					return io.ErrUnexpectedEOF
  5905  				}
  5906  				b := dAtA[iNdEx]
  5907  				iNdEx++
  5908  				msglen |= int(b&0x7F) << shift
  5909  				if b < 0x80 {
  5910  					break
  5911  				}
  5912  			}
  5913  			if msglen < 0 {
  5914  				return ErrInvalidLengthGenerated
  5915  			}
  5916  			postIndex := iNdEx + msglen
  5917  			if postIndex < 0 {
  5918  				return ErrInvalidLengthGenerated
  5919  			}
  5920  			if postIndex > l {
  5921  				return io.ErrUnexpectedEOF
  5922  			}
  5923  			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  5924  				return err
  5925  			}
  5926  			iNdEx = postIndex
  5927  		default:
  5928  			iNdEx = preIndex
  5929  			skippy, err := skipGenerated(dAtA[iNdEx:])
  5930  			if err != nil {
  5931  				return err
  5932  			}
  5933  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  5934  				return ErrInvalidLengthGenerated
  5935  			}
  5936  			if (iNdEx + skippy) > l {
  5937  				return io.ErrUnexpectedEOF
  5938  			}
  5939  			iNdEx += skippy
  5940  		}
  5941  	}
  5942  
  5943  	if iNdEx > l {
  5944  		return io.ErrUnexpectedEOF
  5945  	}
  5946  	return nil
  5947  }
  5948  func (m *ValidatingAdmissionPolicyBindingList) Unmarshal(dAtA []byte) error {
  5949  	l := len(dAtA)
  5950  	iNdEx := 0
  5951  	for iNdEx < l {
  5952  		preIndex := iNdEx
  5953  		var wire uint64
  5954  		for shift := uint(0); ; shift += 7 {
  5955  			if shift >= 64 {
  5956  				return ErrIntOverflowGenerated
  5957  			}
  5958  			if iNdEx >= l {
  5959  				return io.ErrUnexpectedEOF
  5960  			}
  5961  			b := dAtA[iNdEx]
  5962  			iNdEx++
  5963  			wire |= uint64(b&0x7F) << shift
  5964  			if b < 0x80 {
  5965  				break
  5966  			}
  5967  		}
  5968  		fieldNum := int32(wire >> 3)
  5969  		wireType := int(wire & 0x7)
  5970  		if wireType == 4 {
  5971  			return fmt.Errorf("proto: ValidatingAdmissionPolicyBindingList: wiretype end group for non-group")
  5972  		}
  5973  		if fieldNum <= 0 {
  5974  			return fmt.Errorf("proto: ValidatingAdmissionPolicyBindingList: illegal tag %d (wire type %d)", fieldNum, wire)
  5975  		}
  5976  		switch fieldNum {
  5977  		case 1:
  5978  			if wireType != 2 {
  5979  				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
  5980  			}
  5981  			var msglen int
  5982  			for shift := uint(0); ; shift += 7 {
  5983  				if shift >= 64 {
  5984  					return ErrIntOverflowGenerated
  5985  				}
  5986  				if iNdEx >= l {
  5987  					return io.ErrUnexpectedEOF
  5988  				}
  5989  				b := dAtA[iNdEx]
  5990  				iNdEx++
  5991  				msglen |= int(b&0x7F) << shift
  5992  				if b < 0x80 {
  5993  					break
  5994  				}
  5995  			}
  5996  			if msglen < 0 {
  5997  				return ErrInvalidLengthGenerated
  5998  			}
  5999  			postIndex := iNdEx + msglen
  6000  			if postIndex < 0 {
  6001  				return ErrInvalidLengthGenerated
  6002  			}
  6003  			if postIndex > l {
  6004  				return io.ErrUnexpectedEOF
  6005  			}
  6006  			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  6007  				return err
  6008  			}
  6009  			iNdEx = postIndex
  6010  		case 2:
  6011  			if wireType != 2 {
  6012  				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
  6013  			}
  6014  			var msglen int
  6015  			for shift := uint(0); ; shift += 7 {
  6016  				if shift >= 64 {
  6017  					return ErrIntOverflowGenerated
  6018  				}
  6019  				if iNdEx >= l {
  6020  					return io.ErrUnexpectedEOF
  6021  				}
  6022  				b := dAtA[iNdEx]
  6023  				iNdEx++
  6024  				msglen |= int(b&0x7F) << shift
  6025  				if b < 0x80 {
  6026  					break
  6027  				}
  6028  			}
  6029  			if msglen < 0 {
  6030  				return ErrInvalidLengthGenerated
  6031  			}
  6032  			postIndex := iNdEx + msglen
  6033  			if postIndex < 0 {
  6034  				return ErrInvalidLengthGenerated
  6035  			}
  6036  			if postIndex > l {
  6037  				return io.ErrUnexpectedEOF
  6038  			}
  6039  			m.Items = append(m.Items, ValidatingAdmissionPolicyBinding{})
  6040  			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  6041  				return err
  6042  			}
  6043  			iNdEx = postIndex
  6044  		default:
  6045  			iNdEx = preIndex
  6046  			skippy, err := skipGenerated(dAtA[iNdEx:])
  6047  			if err != nil {
  6048  				return err
  6049  			}
  6050  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  6051  				return ErrInvalidLengthGenerated
  6052  			}
  6053  			if (iNdEx + skippy) > l {
  6054  				return io.ErrUnexpectedEOF
  6055  			}
  6056  			iNdEx += skippy
  6057  		}
  6058  	}
  6059  
  6060  	if iNdEx > l {
  6061  		return io.ErrUnexpectedEOF
  6062  	}
  6063  	return nil
  6064  }
  6065  func (m *ValidatingAdmissionPolicyBindingSpec) Unmarshal(dAtA []byte) error {
  6066  	l := len(dAtA)
  6067  	iNdEx := 0
  6068  	for iNdEx < l {
  6069  		preIndex := iNdEx
  6070  		var wire uint64
  6071  		for shift := uint(0); ; shift += 7 {
  6072  			if shift >= 64 {
  6073  				return ErrIntOverflowGenerated
  6074  			}
  6075  			if iNdEx >= l {
  6076  				return io.ErrUnexpectedEOF
  6077  			}
  6078  			b := dAtA[iNdEx]
  6079  			iNdEx++
  6080  			wire |= uint64(b&0x7F) << shift
  6081  			if b < 0x80 {
  6082  				break
  6083  			}
  6084  		}
  6085  		fieldNum := int32(wire >> 3)
  6086  		wireType := int(wire & 0x7)
  6087  		if wireType == 4 {
  6088  			return fmt.Errorf("proto: ValidatingAdmissionPolicyBindingSpec: wiretype end group for non-group")
  6089  		}
  6090  		if fieldNum <= 0 {
  6091  			return fmt.Errorf("proto: ValidatingAdmissionPolicyBindingSpec: illegal tag %d (wire type %d)", fieldNum, wire)
  6092  		}
  6093  		switch fieldNum {
  6094  		case 1:
  6095  			if wireType != 2 {
  6096  				return fmt.Errorf("proto: wrong wireType = %d for field PolicyName", wireType)
  6097  			}
  6098  			var stringLen uint64
  6099  			for shift := uint(0); ; shift += 7 {
  6100  				if shift >= 64 {
  6101  					return ErrIntOverflowGenerated
  6102  				}
  6103  				if iNdEx >= l {
  6104  					return io.ErrUnexpectedEOF
  6105  				}
  6106  				b := dAtA[iNdEx]
  6107  				iNdEx++
  6108  				stringLen |= uint64(b&0x7F) << shift
  6109  				if b < 0x80 {
  6110  					break
  6111  				}
  6112  			}
  6113  			intStringLen := int(stringLen)
  6114  			if intStringLen < 0 {
  6115  				return ErrInvalidLengthGenerated
  6116  			}
  6117  			postIndex := iNdEx + intStringLen
  6118  			if postIndex < 0 {
  6119  				return ErrInvalidLengthGenerated
  6120  			}
  6121  			if postIndex > l {
  6122  				return io.ErrUnexpectedEOF
  6123  			}
  6124  			m.PolicyName = string(dAtA[iNdEx:postIndex])
  6125  			iNdEx = postIndex
  6126  		case 2:
  6127  			if wireType != 2 {
  6128  				return fmt.Errorf("proto: wrong wireType = %d for field ParamRef", wireType)
  6129  			}
  6130  			var msglen int
  6131  			for shift := uint(0); ; shift += 7 {
  6132  				if shift >= 64 {
  6133  					return ErrIntOverflowGenerated
  6134  				}
  6135  				if iNdEx >= l {
  6136  					return io.ErrUnexpectedEOF
  6137  				}
  6138  				b := dAtA[iNdEx]
  6139  				iNdEx++
  6140  				msglen |= int(b&0x7F) << shift
  6141  				if b < 0x80 {
  6142  					break
  6143  				}
  6144  			}
  6145  			if msglen < 0 {
  6146  				return ErrInvalidLengthGenerated
  6147  			}
  6148  			postIndex := iNdEx + msglen
  6149  			if postIndex < 0 {
  6150  				return ErrInvalidLengthGenerated
  6151  			}
  6152  			if postIndex > l {
  6153  				return io.ErrUnexpectedEOF
  6154  			}
  6155  			if m.ParamRef == nil {
  6156  				m.ParamRef = &ParamRef{}
  6157  			}
  6158  			if err := m.ParamRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  6159  				return err
  6160  			}
  6161  			iNdEx = postIndex
  6162  		case 3:
  6163  			if wireType != 2 {
  6164  				return fmt.Errorf("proto: wrong wireType = %d for field MatchResources", wireType)
  6165  			}
  6166  			var msglen int
  6167  			for shift := uint(0); ; shift += 7 {
  6168  				if shift >= 64 {
  6169  					return ErrIntOverflowGenerated
  6170  				}
  6171  				if iNdEx >= l {
  6172  					return io.ErrUnexpectedEOF
  6173  				}
  6174  				b := dAtA[iNdEx]
  6175  				iNdEx++
  6176  				msglen |= int(b&0x7F) << shift
  6177  				if b < 0x80 {
  6178  					break
  6179  				}
  6180  			}
  6181  			if msglen < 0 {
  6182  				return ErrInvalidLengthGenerated
  6183  			}
  6184  			postIndex := iNdEx + msglen
  6185  			if postIndex < 0 {
  6186  				return ErrInvalidLengthGenerated
  6187  			}
  6188  			if postIndex > l {
  6189  				return io.ErrUnexpectedEOF
  6190  			}
  6191  			if m.MatchResources == nil {
  6192  				m.MatchResources = &MatchResources{}
  6193  			}
  6194  			if err := m.MatchResources.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  6195  				return err
  6196  			}
  6197  			iNdEx = postIndex
  6198  		case 4:
  6199  			if wireType != 2 {
  6200  				return fmt.Errorf("proto: wrong wireType = %d for field ValidationActions", wireType)
  6201  			}
  6202  			var stringLen uint64
  6203  			for shift := uint(0); ; shift += 7 {
  6204  				if shift >= 64 {
  6205  					return ErrIntOverflowGenerated
  6206  				}
  6207  				if iNdEx >= l {
  6208  					return io.ErrUnexpectedEOF
  6209  				}
  6210  				b := dAtA[iNdEx]
  6211  				iNdEx++
  6212  				stringLen |= uint64(b&0x7F) << shift
  6213  				if b < 0x80 {
  6214  					break
  6215  				}
  6216  			}
  6217  			intStringLen := int(stringLen)
  6218  			if intStringLen < 0 {
  6219  				return ErrInvalidLengthGenerated
  6220  			}
  6221  			postIndex := iNdEx + intStringLen
  6222  			if postIndex < 0 {
  6223  				return ErrInvalidLengthGenerated
  6224  			}
  6225  			if postIndex > l {
  6226  				return io.ErrUnexpectedEOF
  6227  			}
  6228  			m.ValidationActions = append(m.ValidationActions, ValidationAction(dAtA[iNdEx:postIndex]))
  6229  			iNdEx = postIndex
  6230  		default:
  6231  			iNdEx = preIndex
  6232  			skippy, err := skipGenerated(dAtA[iNdEx:])
  6233  			if err != nil {
  6234  				return err
  6235  			}
  6236  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  6237  				return ErrInvalidLengthGenerated
  6238  			}
  6239  			if (iNdEx + skippy) > l {
  6240  				return io.ErrUnexpectedEOF
  6241  			}
  6242  			iNdEx += skippy
  6243  		}
  6244  	}
  6245  
  6246  	if iNdEx > l {
  6247  		return io.ErrUnexpectedEOF
  6248  	}
  6249  	return nil
  6250  }
  6251  func (m *ValidatingAdmissionPolicyList) Unmarshal(dAtA []byte) error {
  6252  	l := len(dAtA)
  6253  	iNdEx := 0
  6254  	for iNdEx < l {
  6255  		preIndex := iNdEx
  6256  		var wire uint64
  6257  		for shift := uint(0); ; shift += 7 {
  6258  			if shift >= 64 {
  6259  				return ErrIntOverflowGenerated
  6260  			}
  6261  			if iNdEx >= l {
  6262  				return io.ErrUnexpectedEOF
  6263  			}
  6264  			b := dAtA[iNdEx]
  6265  			iNdEx++
  6266  			wire |= uint64(b&0x7F) << shift
  6267  			if b < 0x80 {
  6268  				break
  6269  			}
  6270  		}
  6271  		fieldNum := int32(wire >> 3)
  6272  		wireType := int(wire & 0x7)
  6273  		if wireType == 4 {
  6274  			return fmt.Errorf("proto: ValidatingAdmissionPolicyList: wiretype end group for non-group")
  6275  		}
  6276  		if fieldNum <= 0 {
  6277  			return fmt.Errorf("proto: ValidatingAdmissionPolicyList: illegal tag %d (wire type %d)", fieldNum, wire)
  6278  		}
  6279  		switch fieldNum {
  6280  		case 1:
  6281  			if wireType != 2 {
  6282  				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
  6283  			}
  6284  			var msglen int
  6285  			for shift := uint(0); ; shift += 7 {
  6286  				if shift >= 64 {
  6287  					return ErrIntOverflowGenerated
  6288  				}
  6289  				if iNdEx >= l {
  6290  					return io.ErrUnexpectedEOF
  6291  				}
  6292  				b := dAtA[iNdEx]
  6293  				iNdEx++
  6294  				msglen |= int(b&0x7F) << shift
  6295  				if b < 0x80 {
  6296  					break
  6297  				}
  6298  			}
  6299  			if msglen < 0 {
  6300  				return ErrInvalidLengthGenerated
  6301  			}
  6302  			postIndex := iNdEx + msglen
  6303  			if postIndex < 0 {
  6304  				return ErrInvalidLengthGenerated
  6305  			}
  6306  			if postIndex > l {
  6307  				return io.ErrUnexpectedEOF
  6308  			}
  6309  			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  6310  				return err
  6311  			}
  6312  			iNdEx = postIndex
  6313  		case 2:
  6314  			if wireType != 2 {
  6315  				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
  6316  			}
  6317  			var msglen int
  6318  			for shift := uint(0); ; shift += 7 {
  6319  				if shift >= 64 {
  6320  					return ErrIntOverflowGenerated
  6321  				}
  6322  				if iNdEx >= l {
  6323  					return io.ErrUnexpectedEOF
  6324  				}
  6325  				b := dAtA[iNdEx]
  6326  				iNdEx++
  6327  				msglen |= int(b&0x7F) << shift
  6328  				if b < 0x80 {
  6329  					break
  6330  				}
  6331  			}
  6332  			if msglen < 0 {
  6333  				return ErrInvalidLengthGenerated
  6334  			}
  6335  			postIndex := iNdEx + msglen
  6336  			if postIndex < 0 {
  6337  				return ErrInvalidLengthGenerated
  6338  			}
  6339  			if postIndex > l {
  6340  				return io.ErrUnexpectedEOF
  6341  			}
  6342  			m.Items = append(m.Items, ValidatingAdmissionPolicy{})
  6343  			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  6344  				return err
  6345  			}
  6346  			iNdEx = postIndex
  6347  		default:
  6348  			iNdEx = preIndex
  6349  			skippy, err := skipGenerated(dAtA[iNdEx:])
  6350  			if err != nil {
  6351  				return err
  6352  			}
  6353  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  6354  				return ErrInvalidLengthGenerated
  6355  			}
  6356  			if (iNdEx + skippy) > l {
  6357  				return io.ErrUnexpectedEOF
  6358  			}
  6359  			iNdEx += skippy
  6360  		}
  6361  	}
  6362  
  6363  	if iNdEx > l {
  6364  		return io.ErrUnexpectedEOF
  6365  	}
  6366  	return nil
  6367  }
  6368  func (m *ValidatingAdmissionPolicySpec) Unmarshal(dAtA []byte) error {
  6369  	l := len(dAtA)
  6370  	iNdEx := 0
  6371  	for iNdEx < l {
  6372  		preIndex := iNdEx
  6373  		var wire uint64
  6374  		for shift := uint(0); ; shift += 7 {
  6375  			if shift >= 64 {
  6376  				return ErrIntOverflowGenerated
  6377  			}
  6378  			if iNdEx >= l {
  6379  				return io.ErrUnexpectedEOF
  6380  			}
  6381  			b := dAtA[iNdEx]
  6382  			iNdEx++
  6383  			wire |= uint64(b&0x7F) << shift
  6384  			if b < 0x80 {
  6385  				break
  6386  			}
  6387  		}
  6388  		fieldNum := int32(wire >> 3)
  6389  		wireType := int(wire & 0x7)
  6390  		if wireType == 4 {
  6391  			return fmt.Errorf("proto: ValidatingAdmissionPolicySpec: wiretype end group for non-group")
  6392  		}
  6393  		if fieldNum <= 0 {
  6394  			return fmt.Errorf("proto: ValidatingAdmissionPolicySpec: illegal tag %d (wire type %d)", fieldNum, wire)
  6395  		}
  6396  		switch fieldNum {
  6397  		case 1:
  6398  			if wireType != 2 {
  6399  				return fmt.Errorf("proto: wrong wireType = %d for field ParamKind", wireType)
  6400  			}
  6401  			var msglen int
  6402  			for shift := uint(0); ; shift += 7 {
  6403  				if shift >= 64 {
  6404  					return ErrIntOverflowGenerated
  6405  				}
  6406  				if iNdEx >= l {
  6407  					return io.ErrUnexpectedEOF
  6408  				}
  6409  				b := dAtA[iNdEx]
  6410  				iNdEx++
  6411  				msglen |= int(b&0x7F) << shift
  6412  				if b < 0x80 {
  6413  					break
  6414  				}
  6415  			}
  6416  			if msglen < 0 {
  6417  				return ErrInvalidLengthGenerated
  6418  			}
  6419  			postIndex := iNdEx + msglen
  6420  			if postIndex < 0 {
  6421  				return ErrInvalidLengthGenerated
  6422  			}
  6423  			if postIndex > l {
  6424  				return io.ErrUnexpectedEOF
  6425  			}
  6426  			if m.ParamKind == nil {
  6427  				m.ParamKind = &ParamKind{}
  6428  			}
  6429  			if err := m.ParamKind.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  6430  				return err
  6431  			}
  6432  			iNdEx = postIndex
  6433  		case 2:
  6434  			if wireType != 2 {
  6435  				return fmt.Errorf("proto: wrong wireType = %d for field MatchConstraints", wireType)
  6436  			}
  6437  			var msglen int
  6438  			for shift := uint(0); ; shift += 7 {
  6439  				if shift >= 64 {
  6440  					return ErrIntOverflowGenerated
  6441  				}
  6442  				if iNdEx >= l {
  6443  					return io.ErrUnexpectedEOF
  6444  				}
  6445  				b := dAtA[iNdEx]
  6446  				iNdEx++
  6447  				msglen |= int(b&0x7F) << shift
  6448  				if b < 0x80 {
  6449  					break
  6450  				}
  6451  			}
  6452  			if msglen < 0 {
  6453  				return ErrInvalidLengthGenerated
  6454  			}
  6455  			postIndex := iNdEx + msglen
  6456  			if postIndex < 0 {
  6457  				return ErrInvalidLengthGenerated
  6458  			}
  6459  			if postIndex > l {
  6460  				return io.ErrUnexpectedEOF
  6461  			}
  6462  			if m.MatchConstraints == nil {
  6463  				m.MatchConstraints = &MatchResources{}
  6464  			}
  6465  			if err := m.MatchConstraints.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  6466  				return err
  6467  			}
  6468  			iNdEx = postIndex
  6469  		case 3:
  6470  			if wireType != 2 {
  6471  				return fmt.Errorf("proto: wrong wireType = %d for field Validations", wireType)
  6472  			}
  6473  			var msglen int
  6474  			for shift := uint(0); ; shift += 7 {
  6475  				if shift >= 64 {
  6476  					return ErrIntOverflowGenerated
  6477  				}
  6478  				if iNdEx >= l {
  6479  					return io.ErrUnexpectedEOF
  6480  				}
  6481  				b := dAtA[iNdEx]
  6482  				iNdEx++
  6483  				msglen |= int(b&0x7F) << shift
  6484  				if b < 0x80 {
  6485  					break
  6486  				}
  6487  			}
  6488  			if msglen < 0 {
  6489  				return ErrInvalidLengthGenerated
  6490  			}
  6491  			postIndex := iNdEx + msglen
  6492  			if postIndex < 0 {
  6493  				return ErrInvalidLengthGenerated
  6494  			}
  6495  			if postIndex > l {
  6496  				return io.ErrUnexpectedEOF
  6497  			}
  6498  			m.Validations = append(m.Validations, Validation{})
  6499  			if err := m.Validations[len(m.Validations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  6500  				return err
  6501  			}
  6502  			iNdEx = postIndex
  6503  		case 4:
  6504  			if wireType != 2 {
  6505  				return fmt.Errorf("proto: wrong wireType = %d for field FailurePolicy", wireType)
  6506  			}
  6507  			var stringLen uint64
  6508  			for shift := uint(0); ; shift += 7 {
  6509  				if shift >= 64 {
  6510  					return ErrIntOverflowGenerated
  6511  				}
  6512  				if iNdEx >= l {
  6513  					return io.ErrUnexpectedEOF
  6514  				}
  6515  				b := dAtA[iNdEx]
  6516  				iNdEx++
  6517  				stringLen |= uint64(b&0x7F) << shift
  6518  				if b < 0x80 {
  6519  					break
  6520  				}
  6521  			}
  6522  			intStringLen := int(stringLen)
  6523  			if intStringLen < 0 {
  6524  				return ErrInvalidLengthGenerated
  6525  			}
  6526  			postIndex := iNdEx + intStringLen
  6527  			if postIndex < 0 {
  6528  				return ErrInvalidLengthGenerated
  6529  			}
  6530  			if postIndex > l {
  6531  				return io.ErrUnexpectedEOF
  6532  			}
  6533  			s := FailurePolicyType(dAtA[iNdEx:postIndex])
  6534  			m.FailurePolicy = &s
  6535  			iNdEx = postIndex
  6536  		case 5:
  6537  			if wireType != 2 {
  6538  				return fmt.Errorf("proto: wrong wireType = %d for field AuditAnnotations", wireType)
  6539  			}
  6540  			var msglen int
  6541  			for shift := uint(0); ; shift += 7 {
  6542  				if shift >= 64 {
  6543  					return ErrIntOverflowGenerated
  6544  				}
  6545  				if iNdEx >= l {
  6546  					return io.ErrUnexpectedEOF
  6547  				}
  6548  				b := dAtA[iNdEx]
  6549  				iNdEx++
  6550  				msglen |= int(b&0x7F) << shift
  6551  				if b < 0x80 {
  6552  					break
  6553  				}
  6554  			}
  6555  			if msglen < 0 {
  6556  				return ErrInvalidLengthGenerated
  6557  			}
  6558  			postIndex := iNdEx + msglen
  6559  			if postIndex < 0 {
  6560  				return ErrInvalidLengthGenerated
  6561  			}
  6562  			if postIndex > l {
  6563  				return io.ErrUnexpectedEOF
  6564  			}
  6565  			m.AuditAnnotations = append(m.AuditAnnotations, AuditAnnotation{})
  6566  			if err := m.AuditAnnotations[len(m.AuditAnnotations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  6567  				return err
  6568  			}
  6569  			iNdEx = postIndex
  6570  		case 6:
  6571  			if wireType != 2 {
  6572  				return fmt.Errorf("proto: wrong wireType = %d for field MatchConditions", wireType)
  6573  			}
  6574  			var msglen int
  6575  			for shift := uint(0); ; shift += 7 {
  6576  				if shift >= 64 {
  6577  					return ErrIntOverflowGenerated
  6578  				}
  6579  				if iNdEx >= l {
  6580  					return io.ErrUnexpectedEOF
  6581  				}
  6582  				b := dAtA[iNdEx]
  6583  				iNdEx++
  6584  				msglen |= int(b&0x7F) << shift
  6585  				if b < 0x80 {
  6586  					break
  6587  				}
  6588  			}
  6589  			if msglen < 0 {
  6590  				return ErrInvalidLengthGenerated
  6591  			}
  6592  			postIndex := iNdEx + msglen
  6593  			if postIndex < 0 {
  6594  				return ErrInvalidLengthGenerated
  6595  			}
  6596  			if postIndex > l {
  6597  				return io.ErrUnexpectedEOF
  6598  			}
  6599  			m.MatchConditions = append(m.MatchConditions, MatchCondition{})
  6600  			if err := m.MatchConditions[len(m.MatchConditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  6601  				return err
  6602  			}
  6603  			iNdEx = postIndex
  6604  		case 7:
  6605  			if wireType != 2 {
  6606  				return fmt.Errorf("proto: wrong wireType = %d for field Variables", wireType)
  6607  			}
  6608  			var msglen int
  6609  			for shift := uint(0); ; shift += 7 {
  6610  				if shift >= 64 {
  6611  					return ErrIntOverflowGenerated
  6612  				}
  6613  				if iNdEx >= l {
  6614  					return io.ErrUnexpectedEOF
  6615  				}
  6616  				b := dAtA[iNdEx]
  6617  				iNdEx++
  6618  				msglen |= int(b&0x7F) << shift
  6619  				if b < 0x80 {
  6620  					break
  6621  				}
  6622  			}
  6623  			if msglen < 0 {
  6624  				return ErrInvalidLengthGenerated
  6625  			}
  6626  			postIndex := iNdEx + msglen
  6627  			if postIndex < 0 {
  6628  				return ErrInvalidLengthGenerated
  6629  			}
  6630  			if postIndex > l {
  6631  				return io.ErrUnexpectedEOF
  6632  			}
  6633  			m.Variables = append(m.Variables, Variable{})
  6634  			if err := m.Variables[len(m.Variables)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  6635  				return err
  6636  			}
  6637  			iNdEx = postIndex
  6638  		default:
  6639  			iNdEx = preIndex
  6640  			skippy, err := skipGenerated(dAtA[iNdEx:])
  6641  			if err != nil {
  6642  				return err
  6643  			}
  6644  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  6645  				return ErrInvalidLengthGenerated
  6646  			}
  6647  			if (iNdEx + skippy) > l {
  6648  				return io.ErrUnexpectedEOF
  6649  			}
  6650  			iNdEx += skippy
  6651  		}
  6652  	}
  6653  
  6654  	if iNdEx > l {
  6655  		return io.ErrUnexpectedEOF
  6656  	}
  6657  	return nil
  6658  }
  6659  func (m *ValidatingAdmissionPolicyStatus) Unmarshal(dAtA []byte) error {
  6660  	l := len(dAtA)
  6661  	iNdEx := 0
  6662  	for iNdEx < l {
  6663  		preIndex := iNdEx
  6664  		var wire uint64
  6665  		for shift := uint(0); ; shift += 7 {
  6666  			if shift >= 64 {
  6667  				return ErrIntOverflowGenerated
  6668  			}
  6669  			if iNdEx >= l {
  6670  				return io.ErrUnexpectedEOF
  6671  			}
  6672  			b := dAtA[iNdEx]
  6673  			iNdEx++
  6674  			wire |= uint64(b&0x7F) << shift
  6675  			if b < 0x80 {
  6676  				break
  6677  			}
  6678  		}
  6679  		fieldNum := int32(wire >> 3)
  6680  		wireType := int(wire & 0x7)
  6681  		if wireType == 4 {
  6682  			return fmt.Errorf("proto: ValidatingAdmissionPolicyStatus: wiretype end group for non-group")
  6683  		}
  6684  		if fieldNum <= 0 {
  6685  			return fmt.Errorf("proto: ValidatingAdmissionPolicyStatus: illegal tag %d (wire type %d)", fieldNum, wire)
  6686  		}
  6687  		switch fieldNum {
  6688  		case 1:
  6689  			if wireType != 0 {
  6690  				return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
  6691  			}
  6692  			m.ObservedGeneration = 0
  6693  			for shift := uint(0); ; shift += 7 {
  6694  				if shift >= 64 {
  6695  					return ErrIntOverflowGenerated
  6696  				}
  6697  				if iNdEx >= l {
  6698  					return io.ErrUnexpectedEOF
  6699  				}
  6700  				b := dAtA[iNdEx]
  6701  				iNdEx++
  6702  				m.ObservedGeneration |= int64(b&0x7F) << shift
  6703  				if b < 0x80 {
  6704  					break
  6705  				}
  6706  			}
  6707  		case 2:
  6708  			if wireType != 2 {
  6709  				return fmt.Errorf("proto: wrong wireType = %d for field TypeChecking", wireType)
  6710  			}
  6711  			var msglen int
  6712  			for shift := uint(0); ; shift += 7 {
  6713  				if shift >= 64 {
  6714  					return ErrIntOverflowGenerated
  6715  				}
  6716  				if iNdEx >= l {
  6717  					return io.ErrUnexpectedEOF
  6718  				}
  6719  				b := dAtA[iNdEx]
  6720  				iNdEx++
  6721  				msglen |= int(b&0x7F) << shift
  6722  				if b < 0x80 {
  6723  					break
  6724  				}
  6725  			}
  6726  			if msglen < 0 {
  6727  				return ErrInvalidLengthGenerated
  6728  			}
  6729  			postIndex := iNdEx + msglen
  6730  			if postIndex < 0 {
  6731  				return ErrInvalidLengthGenerated
  6732  			}
  6733  			if postIndex > l {
  6734  				return io.ErrUnexpectedEOF
  6735  			}
  6736  			if m.TypeChecking == nil {
  6737  				m.TypeChecking = &TypeChecking{}
  6738  			}
  6739  			if err := m.TypeChecking.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  6740  				return err
  6741  			}
  6742  			iNdEx = postIndex
  6743  		case 3:
  6744  			if wireType != 2 {
  6745  				return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
  6746  			}
  6747  			var msglen int
  6748  			for shift := uint(0); ; shift += 7 {
  6749  				if shift >= 64 {
  6750  					return ErrIntOverflowGenerated
  6751  				}
  6752  				if iNdEx >= l {
  6753  					return io.ErrUnexpectedEOF
  6754  				}
  6755  				b := dAtA[iNdEx]
  6756  				iNdEx++
  6757  				msglen |= int(b&0x7F) << shift
  6758  				if b < 0x80 {
  6759  					break
  6760  				}
  6761  			}
  6762  			if msglen < 0 {
  6763  				return ErrInvalidLengthGenerated
  6764  			}
  6765  			postIndex := iNdEx + msglen
  6766  			if postIndex < 0 {
  6767  				return ErrInvalidLengthGenerated
  6768  			}
  6769  			if postIndex > l {
  6770  				return io.ErrUnexpectedEOF
  6771  			}
  6772  			m.Conditions = append(m.Conditions, v1.Condition{})
  6773  			if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  6774  				return err
  6775  			}
  6776  			iNdEx = postIndex
  6777  		default:
  6778  			iNdEx = preIndex
  6779  			skippy, err := skipGenerated(dAtA[iNdEx:])
  6780  			if err != nil {
  6781  				return err
  6782  			}
  6783  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  6784  				return ErrInvalidLengthGenerated
  6785  			}
  6786  			if (iNdEx + skippy) > l {
  6787  				return io.ErrUnexpectedEOF
  6788  			}
  6789  			iNdEx += skippy
  6790  		}
  6791  	}
  6792  
  6793  	if iNdEx > l {
  6794  		return io.ErrUnexpectedEOF
  6795  	}
  6796  	return nil
  6797  }
  6798  func (m *ValidatingWebhook) Unmarshal(dAtA []byte) error {
  6799  	l := len(dAtA)
  6800  	iNdEx := 0
  6801  	for iNdEx < l {
  6802  		preIndex := iNdEx
  6803  		var wire uint64
  6804  		for shift := uint(0); ; shift += 7 {
  6805  			if shift >= 64 {
  6806  				return ErrIntOverflowGenerated
  6807  			}
  6808  			if iNdEx >= l {
  6809  				return io.ErrUnexpectedEOF
  6810  			}
  6811  			b := dAtA[iNdEx]
  6812  			iNdEx++
  6813  			wire |= uint64(b&0x7F) << shift
  6814  			if b < 0x80 {
  6815  				break
  6816  			}
  6817  		}
  6818  		fieldNum := int32(wire >> 3)
  6819  		wireType := int(wire & 0x7)
  6820  		if wireType == 4 {
  6821  			return fmt.Errorf("proto: ValidatingWebhook: wiretype end group for non-group")
  6822  		}
  6823  		if fieldNum <= 0 {
  6824  			return fmt.Errorf("proto: ValidatingWebhook: illegal tag %d (wire type %d)", fieldNum, wire)
  6825  		}
  6826  		switch fieldNum {
  6827  		case 1:
  6828  			if wireType != 2 {
  6829  				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
  6830  			}
  6831  			var stringLen uint64
  6832  			for shift := uint(0); ; shift += 7 {
  6833  				if shift >= 64 {
  6834  					return ErrIntOverflowGenerated
  6835  				}
  6836  				if iNdEx >= l {
  6837  					return io.ErrUnexpectedEOF
  6838  				}
  6839  				b := dAtA[iNdEx]
  6840  				iNdEx++
  6841  				stringLen |= uint64(b&0x7F) << shift
  6842  				if b < 0x80 {
  6843  					break
  6844  				}
  6845  			}
  6846  			intStringLen := int(stringLen)
  6847  			if intStringLen < 0 {
  6848  				return ErrInvalidLengthGenerated
  6849  			}
  6850  			postIndex := iNdEx + intStringLen
  6851  			if postIndex < 0 {
  6852  				return ErrInvalidLengthGenerated
  6853  			}
  6854  			if postIndex > l {
  6855  				return io.ErrUnexpectedEOF
  6856  			}
  6857  			m.Name = string(dAtA[iNdEx:postIndex])
  6858  			iNdEx = postIndex
  6859  		case 2:
  6860  			if wireType != 2 {
  6861  				return fmt.Errorf("proto: wrong wireType = %d for field ClientConfig", wireType)
  6862  			}
  6863  			var msglen int
  6864  			for shift := uint(0); ; shift += 7 {
  6865  				if shift >= 64 {
  6866  					return ErrIntOverflowGenerated
  6867  				}
  6868  				if iNdEx >= l {
  6869  					return io.ErrUnexpectedEOF
  6870  				}
  6871  				b := dAtA[iNdEx]
  6872  				iNdEx++
  6873  				msglen |= int(b&0x7F) << shift
  6874  				if b < 0x80 {
  6875  					break
  6876  				}
  6877  			}
  6878  			if msglen < 0 {
  6879  				return ErrInvalidLengthGenerated
  6880  			}
  6881  			postIndex := iNdEx + msglen
  6882  			if postIndex < 0 {
  6883  				return ErrInvalidLengthGenerated
  6884  			}
  6885  			if postIndex > l {
  6886  				return io.ErrUnexpectedEOF
  6887  			}
  6888  			if err := m.ClientConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  6889  				return err
  6890  			}
  6891  			iNdEx = postIndex
  6892  		case 3:
  6893  			if wireType != 2 {
  6894  				return fmt.Errorf("proto: wrong wireType = %d for field Rules", wireType)
  6895  			}
  6896  			var msglen int
  6897  			for shift := uint(0); ; shift += 7 {
  6898  				if shift >= 64 {
  6899  					return ErrIntOverflowGenerated
  6900  				}
  6901  				if iNdEx >= l {
  6902  					return io.ErrUnexpectedEOF
  6903  				}
  6904  				b := dAtA[iNdEx]
  6905  				iNdEx++
  6906  				msglen |= int(b&0x7F) << shift
  6907  				if b < 0x80 {
  6908  					break
  6909  				}
  6910  			}
  6911  			if msglen < 0 {
  6912  				return ErrInvalidLengthGenerated
  6913  			}
  6914  			postIndex := iNdEx + msglen
  6915  			if postIndex < 0 {
  6916  				return ErrInvalidLengthGenerated
  6917  			}
  6918  			if postIndex > l {
  6919  				return io.ErrUnexpectedEOF
  6920  			}
  6921  			m.Rules = append(m.Rules, RuleWithOperations{})
  6922  			if err := m.Rules[len(m.Rules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  6923  				return err
  6924  			}
  6925  			iNdEx = postIndex
  6926  		case 4:
  6927  			if wireType != 2 {
  6928  				return fmt.Errorf("proto: wrong wireType = %d for field FailurePolicy", wireType)
  6929  			}
  6930  			var stringLen uint64
  6931  			for shift := uint(0); ; shift += 7 {
  6932  				if shift >= 64 {
  6933  					return ErrIntOverflowGenerated
  6934  				}
  6935  				if iNdEx >= l {
  6936  					return io.ErrUnexpectedEOF
  6937  				}
  6938  				b := dAtA[iNdEx]
  6939  				iNdEx++
  6940  				stringLen |= uint64(b&0x7F) << shift
  6941  				if b < 0x80 {
  6942  					break
  6943  				}
  6944  			}
  6945  			intStringLen := int(stringLen)
  6946  			if intStringLen < 0 {
  6947  				return ErrInvalidLengthGenerated
  6948  			}
  6949  			postIndex := iNdEx + intStringLen
  6950  			if postIndex < 0 {
  6951  				return ErrInvalidLengthGenerated
  6952  			}
  6953  			if postIndex > l {
  6954  				return io.ErrUnexpectedEOF
  6955  			}
  6956  			s := FailurePolicyType(dAtA[iNdEx:postIndex])
  6957  			m.FailurePolicy = &s
  6958  			iNdEx = postIndex
  6959  		case 5:
  6960  			if wireType != 2 {
  6961  				return fmt.Errorf("proto: wrong wireType = %d for field NamespaceSelector", wireType)
  6962  			}
  6963  			var msglen int
  6964  			for shift := uint(0); ; shift += 7 {
  6965  				if shift >= 64 {
  6966  					return ErrIntOverflowGenerated
  6967  				}
  6968  				if iNdEx >= l {
  6969  					return io.ErrUnexpectedEOF
  6970  				}
  6971  				b := dAtA[iNdEx]
  6972  				iNdEx++
  6973  				msglen |= int(b&0x7F) << shift
  6974  				if b < 0x80 {
  6975  					break
  6976  				}
  6977  			}
  6978  			if msglen < 0 {
  6979  				return ErrInvalidLengthGenerated
  6980  			}
  6981  			postIndex := iNdEx + msglen
  6982  			if postIndex < 0 {
  6983  				return ErrInvalidLengthGenerated
  6984  			}
  6985  			if postIndex > l {
  6986  				return io.ErrUnexpectedEOF
  6987  			}
  6988  			if m.NamespaceSelector == nil {
  6989  				m.NamespaceSelector = &v1.LabelSelector{}
  6990  			}
  6991  			if err := m.NamespaceSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  6992  				return err
  6993  			}
  6994  			iNdEx = postIndex
  6995  		case 6:
  6996  			if wireType != 2 {
  6997  				return fmt.Errorf("proto: wrong wireType = %d for field SideEffects", wireType)
  6998  			}
  6999  			var stringLen uint64
  7000  			for shift := uint(0); ; shift += 7 {
  7001  				if shift >= 64 {
  7002  					return ErrIntOverflowGenerated
  7003  				}
  7004  				if iNdEx >= l {
  7005  					return io.ErrUnexpectedEOF
  7006  				}
  7007  				b := dAtA[iNdEx]
  7008  				iNdEx++
  7009  				stringLen |= uint64(b&0x7F) << shift
  7010  				if b < 0x80 {
  7011  					break
  7012  				}
  7013  			}
  7014  			intStringLen := int(stringLen)
  7015  			if intStringLen < 0 {
  7016  				return ErrInvalidLengthGenerated
  7017  			}
  7018  			postIndex := iNdEx + intStringLen
  7019  			if postIndex < 0 {
  7020  				return ErrInvalidLengthGenerated
  7021  			}
  7022  			if postIndex > l {
  7023  				return io.ErrUnexpectedEOF
  7024  			}
  7025  			s := SideEffectClass(dAtA[iNdEx:postIndex])
  7026  			m.SideEffects = &s
  7027  			iNdEx = postIndex
  7028  		case 7:
  7029  			if wireType != 0 {
  7030  				return fmt.Errorf("proto: wrong wireType = %d for field TimeoutSeconds", wireType)
  7031  			}
  7032  			var v int32
  7033  			for shift := uint(0); ; shift += 7 {
  7034  				if shift >= 64 {
  7035  					return ErrIntOverflowGenerated
  7036  				}
  7037  				if iNdEx >= l {
  7038  					return io.ErrUnexpectedEOF
  7039  				}
  7040  				b := dAtA[iNdEx]
  7041  				iNdEx++
  7042  				v |= int32(b&0x7F) << shift
  7043  				if b < 0x80 {
  7044  					break
  7045  				}
  7046  			}
  7047  			m.TimeoutSeconds = &v
  7048  		case 8:
  7049  			if wireType != 2 {
  7050  				return fmt.Errorf("proto: wrong wireType = %d for field AdmissionReviewVersions", wireType)
  7051  			}
  7052  			var stringLen uint64
  7053  			for shift := uint(0); ; shift += 7 {
  7054  				if shift >= 64 {
  7055  					return ErrIntOverflowGenerated
  7056  				}
  7057  				if iNdEx >= l {
  7058  					return io.ErrUnexpectedEOF
  7059  				}
  7060  				b := dAtA[iNdEx]
  7061  				iNdEx++
  7062  				stringLen |= uint64(b&0x7F) << shift
  7063  				if b < 0x80 {
  7064  					break
  7065  				}
  7066  			}
  7067  			intStringLen := int(stringLen)
  7068  			if intStringLen < 0 {
  7069  				return ErrInvalidLengthGenerated
  7070  			}
  7071  			postIndex := iNdEx + intStringLen
  7072  			if postIndex < 0 {
  7073  				return ErrInvalidLengthGenerated
  7074  			}
  7075  			if postIndex > l {
  7076  				return io.ErrUnexpectedEOF
  7077  			}
  7078  			m.AdmissionReviewVersions = append(m.AdmissionReviewVersions, string(dAtA[iNdEx:postIndex]))
  7079  			iNdEx = postIndex
  7080  		case 9:
  7081  			if wireType != 2 {
  7082  				return fmt.Errorf("proto: wrong wireType = %d for field MatchPolicy", wireType)
  7083  			}
  7084  			var stringLen uint64
  7085  			for shift := uint(0); ; shift += 7 {
  7086  				if shift >= 64 {
  7087  					return ErrIntOverflowGenerated
  7088  				}
  7089  				if iNdEx >= l {
  7090  					return io.ErrUnexpectedEOF
  7091  				}
  7092  				b := dAtA[iNdEx]
  7093  				iNdEx++
  7094  				stringLen |= uint64(b&0x7F) << shift
  7095  				if b < 0x80 {
  7096  					break
  7097  				}
  7098  			}
  7099  			intStringLen := int(stringLen)
  7100  			if intStringLen < 0 {
  7101  				return ErrInvalidLengthGenerated
  7102  			}
  7103  			postIndex := iNdEx + intStringLen
  7104  			if postIndex < 0 {
  7105  				return ErrInvalidLengthGenerated
  7106  			}
  7107  			if postIndex > l {
  7108  				return io.ErrUnexpectedEOF
  7109  			}
  7110  			s := MatchPolicyType(dAtA[iNdEx:postIndex])
  7111  			m.MatchPolicy = &s
  7112  			iNdEx = postIndex
  7113  		case 10:
  7114  			if wireType != 2 {
  7115  				return fmt.Errorf("proto: wrong wireType = %d for field ObjectSelector", wireType)
  7116  			}
  7117  			var msglen int
  7118  			for shift := uint(0); ; shift += 7 {
  7119  				if shift >= 64 {
  7120  					return ErrIntOverflowGenerated
  7121  				}
  7122  				if iNdEx >= l {
  7123  					return io.ErrUnexpectedEOF
  7124  				}
  7125  				b := dAtA[iNdEx]
  7126  				iNdEx++
  7127  				msglen |= int(b&0x7F) << shift
  7128  				if b < 0x80 {
  7129  					break
  7130  				}
  7131  			}
  7132  			if msglen < 0 {
  7133  				return ErrInvalidLengthGenerated
  7134  			}
  7135  			postIndex := iNdEx + msglen
  7136  			if postIndex < 0 {
  7137  				return ErrInvalidLengthGenerated
  7138  			}
  7139  			if postIndex > l {
  7140  				return io.ErrUnexpectedEOF
  7141  			}
  7142  			if m.ObjectSelector == nil {
  7143  				m.ObjectSelector = &v1.LabelSelector{}
  7144  			}
  7145  			if err := m.ObjectSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  7146  				return err
  7147  			}
  7148  			iNdEx = postIndex
  7149  		case 11:
  7150  			if wireType != 2 {
  7151  				return fmt.Errorf("proto: wrong wireType = %d for field MatchConditions", wireType)
  7152  			}
  7153  			var msglen int
  7154  			for shift := uint(0); ; shift += 7 {
  7155  				if shift >= 64 {
  7156  					return ErrIntOverflowGenerated
  7157  				}
  7158  				if iNdEx >= l {
  7159  					return io.ErrUnexpectedEOF
  7160  				}
  7161  				b := dAtA[iNdEx]
  7162  				iNdEx++
  7163  				msglen |= int(b&0x7F) << shift
  7164  				if b < 0x80 {
  7165  					break
  7166  				}
  7167  			}
  7168  			if msglen < 0 {
  7169  				return ErrInvalidLengthGenerated
  7170  			}
  7171  			postIndex := iNdEx + msglen
  7172  			if postIndex < 0 {
  7173  				return ErrInvalidLengthGenerated
  7174  			}
  7175  			if postIndex > l {
  7176  				return io.ErrUnexpectedEOF
  7177  			}
  7178  			m.MatchConditions = append(m.MatchConditions, MatchCondition{})
  7179  			if err := m.MatchConditions[len(m.MatchConditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  7180  				return err
  7181  			}
  7182  			iNdEx = postIndex
  7183  		default:
  7184  			iNdEx = preIndex
  7185  			skippy, err := skipGenerated(dAtA[iNdEx:])
  7186  			if err != nil {
  7187  				return err
  7188  			}
  7189  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7190  				return ErrInvalidLengthGenerated
  7191  			}
  7192  			if (iNdEx + skippy) > l {
  7193  				return io.ErrUnexpectedEOF
  7194  			}
  7195  			iNdEx += skippy
  7196  		}
  7197  	}
  7198  
  7199  	if iNdEx > l {
  7200  		return io.ErrUnexpectedEOF
  7201  	}
  7202  	return nil
  7203  }
  7204  func (m *ValidatingWebhookConfiguration) Unmarshal(dAtA []byte) error {
  7205  	l := len(dAtA)
  7206  	iNdEx := 0
  7207  	for iNdEx < l {
  7208  		preIndex := iNdEx
  7209  		var wire uint64
  7210  		for shift := uint(0); ; shift += 7 {
  7211  			if shift >= 64 {
  7212  				return ErrIntOverflowGenerated
  7213  			}
  7214  			if iNdEx >= l {
  7215  				return io.ErrUnexpectedEOF
  7216  			}
  7217  			b := dAtA[iNdEx]
  7218  			iNdEx++
  7219  			wire |= uint64(b&0x7F) << shift
  7220  			if b < 0x80 {
  7221  				break
  7222  			}
  7223  		}
  7224  		fieldNum := int32(wire >> 3)
  7225  		wireType := int(wire & 0x7)
  7226  		if wireType == 4 {
  7227  			return fmt.Errorf("proto: ValidatingWebhookConfiguration: wiretype end group for non-group")
  7228  		}
  7229  		if fieldNum <= 0 {
  7230  			return fmt.Errorf("proto: ValidatingWebhookConfiguration: illegal tag %d (wire type %d)", fieldNum, wire)
  7231  		}
  7232  		switch fieldNum {
  7233  		case 1:
  7234  			if wireType != 2 {
  7235  				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
  7236  			}
  7237  			var msglen int
  7238  			for shift := uint(0); ; shift += 7 {
  7239  				if shift >= 64 {
  7240  					return ErrIntOverflowGenerated
  7241  				}
  7242  				if iNdEx >= l {
  7243  					return io.ErrUnexpectedEOF
  7244  				}
  7245  				b := dAtA[iNdEx]
  7246  				iNdEx++
  7247  				msglen |= int(b&0x7F) << shift
  7248  				if b < 0x80 {
  7249  					break
  7250  				}
  7251  			}
  7252  			if msglen < 0 {
  7253  				return ErrInvalidLengthGenerated
  7254  			}
  7255  			postIndex := iNdEx + msglen
  7256  			if postIndex < 0 {
  7257  				return ErrInvalidLengthGenerated
  7258  			}
  7259  			if postIndex > l {
  7260  				return io.ErrUnexpectedEOF
  7261  			}
  7262  			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  7263  				return err
  7264  			}
  7265  			iNdEx = postIndex
  7266  		case 2:
  7267  			if wireType != 2 {
  7268  				return fmt.Errorf("proto: wrong wireType = %d for field Webhooks", wireType)
  7269  			}
  7270  			var msglen int
  7271  			for shift := uint(0); ; shift += 7 {
  7272  				if shift >= 64 {
  7273  					return ErrIntOverflowGenerated
  7274  				}
  7275  				if iNdEx >= l {
  7276  					return io.ErrUnexpectedEOF
  7277  				}
  7278  				b := dAtA[iNdEx]
  7279  				iNdEx++
  7280  				msglen |= int(b&0x7F) << shift
  7281  				if b < 0x80 {
  7282  					break
  7283  				}
  7284  			}
  7285  			if msglen < 0 {
  7286  				return ErrInvalidLengthGenerated
  7287  			}
  7288  			postIndex := iNdEx + msglen
  7289  			if postIndex < 0 {
  7290  				return ErrInvalidLengthGenerated
  7291  			}
  7292  			if postIndex > l {
  7293  				return io.ErrUnexpectedEOF
  7294  			}
  7295  			m.Webhooks = append(m.Webhooks, ValidatingWebhook{})
  7296  			if err := m.Webhooks[len(m.Webhooks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  7297  				return err
  7298  			}
  7299  			iNdEx = postIndex
  7300  		default:
  7301  			iNdEx = preIndex
  7302  			skippy, err := skipGenerated(dAtA[iNdEx:])
  7303  			if err != nil {
  7304  				return err
  7305  			}
  7306  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7307  				return ErrInvalidLengthGenerated
  7308  			}
  7309  			if (iNdEx + skippy) > l {
  7310  				return io.ErrUnexpectedEOF
  7311  			}
  7312  			iNdEx += skippy
  7313  		}
  7314  	}
  7315  
  7316  	if iNdEx > l {
  7317  		return io.ErrUnexpectedEOF
  7318  	}
  7319  	return nil
  7320  }
  7321  func (m *ValidatingWebhookConfigurationList) Unmarshal(dAtA []byte) error {
  7322  	l := len(dAtA)
  7323  	iNdEx := 0
  7324  	for iNdEx < l {
  7325  		preIndex := iNdEx
  7326  		var wire uint64
  7327  		for shift := uint(0); ; shift += 7 {
  7328  			if shift >= 64 {
  7329  				return ErrIntOverflowGenerated
  7330  			}
  7331  			if iNdEx >= l {
  7332  				return io.ErrUnexpectedEOF
  7333  			}
  7334  			b := dAtA[iNdEx]
  7335  			iNdEx++
  7336  			wire |= uint64(b&0x7F) << shift
  7337  			if b < 0x80 {
  7338  				break
  7339  			}
  7340  		}
  7341  		fieldNum := int32(wire >> 3)
  7342  		wireType := int(wire & 0x7)
  7343  		if wireType == 4 {
  7344  			return fmt.Errorf("proto: ValidatingWebhookConfigurationList: wiretype end group for non-group")
  7345  		}
  7346  		if fieldNum <= 0 {
  7347  			return fmt.Errorf("proto: ValidatingWebhookConfigurationList: illegal tag %d (wire type %d)", fieldNum, wire)
  7348  		}
  7349  		switch fieldNum {
  7350  		case 1:
  7351  			if wireType != 2 {
  7352  				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
  7353  			}
  7354  			var msglen int
  7355  			for shift := uint(0); ; shift += 7 {
  7356  				if shift >= 64 {
  7357  					return ErrIntOverflowGenerated
  7358  				}
  7359  				if iNdEx >= l {
  7360  					return io.ErrUnexpectedEOF
  7361  				}
  7362  				b := dAtA[iNdEx]
  7363  				iNdEx++
  7364  				msglen |= int(b&0x7F) << shift
  7365  				if b < 0x80 {
  7366  					break
  7367  				}
  7368  			}
  7369  			if msglen < 0 {
  7370  				return ErrInvalidLengthGenerated
  7371  			}
  7372  			postIndex := iNdEx + msglen
  7373  			if postIndex < 0 {
  7374  				return ErrInvalidLengthGenerated
  7375  			}
  7376  			if postIndex > l {
  7377  				return io.ErrUnexpectedEOF
  7378  			}
  7379  			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  7380  				return err
  7381  			}
  7382  			iNdEx = postIndex
  7383  		case 2:
  7384  			if wireType != 2 {
  7385  				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
  7386  			}
  7387  			var msglen int
  7388  			for shift := uint(0); ; shift += 7 {
  7389  				if shift >= 64 {
  7390  					return ErrIntOverflowGenerated
  7391  				}
  7392  				if iNdEx >= l {
  7393  					return io.ErrUnexpectedEOF
  7394  				}
  7395  				b := dAtA[iNdEx]
  7396  				iNdEx++
  7397  				msglen |= int(b&0x7F) << shift
  7398  				if b < 0x80 {
  7399  					break
  7400  				}
  7401  			}
  7402  			if msglen < 0 {
  7403  				return ErrInvalidLengthGenerated
  7404  			}
  7405  			postIndex := iNdEx + msglen
  7406  			if postIndex < 0 {
  7407  				return ErrInvalidLengthGenerated
  7408  			}
  7409  			if postIndex > l {
  7410  				return io.ErrUnexpectedEOF
  7411  			}
  7412  			m.Items = append(m.Items, ValidatingWebhookConfiguration{})
  7413  			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  7414  				return err
  7415  			}
  7416  			iNdEx = postIndex
  7417  		default:
  7418  			iNdEx = preIndex
  7419  			skippy, err := skipGenerated(dAtA[iNdEx:])
  7420  			if err != nil {
  7421  				return err
  7422  			}
  7423  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7424  				return ErrInvalidLengthGenerated
  7425  			}
  7426  			if (iNdEx + skippy) > l {
  7427  				return io.ErrUnexpectedEOF
  7428  			}
  7429  			iNdEx += skippy
  7430  		}
  7431  	}
  7432  
  7433  	if iNdEx > l {
  7434  		return io.ErrUnexpectedEOF
  7435  	}
  7436  	return nil
  7437  }
  7438  func (m *Validation) Unmarshal(dAtA []byte) error {
  7439  	l := len(dAtA)
  7440  	iNdEx := 0
  7441  	for iNdEx < l {
  7442  		preIndex := iNdEx
  7443  		var wire uint64
  7444  		for shift := uint(0); ; shift += 7 {
  7445  			if shift >= 64 {
  7446  				return ErrIntOverflowGenerated
  7447  			}
  7448  			if iNdEx >= l {
  7449  				return io.ErrUnexpectedEOF
  7450  			}
  7451  			b := dAtA[iNdEx]
  7452  			iNdEx++
  7453  			wire |= uint64(b&0x7F) << shift
  7454  			if b < 0x80 {
  7455  				break
  7456  			}
  7457  		}
  7458  		fieldNum := int32(wire >> 3)
  7459  		wireType := int(wire & 0x7)
  7460  		if wireType == 4 {
  7461  			return fmt.Errorf("proto: Validation: wiretype end group for non-group")
  7462  		}
  7463  		if fieldNum <= 0 {
  7464  			return fmt.Errorf("proto: Validation: illegal tag %d (wire type %d)", fieldNum, wire)
  7465  		}
  7466  		switch fieldNum {
  7467  		case 1:
  7468  			if wireType != 2 {
  7469  				return fmt.Errorf("proto: wrong wireType = %d for field Expression", wireType)
  7470  			}
  7471  			var stringLen uint64
  7472  			for shift := uint(0); ; shift += 7 {
  7473  				if shift >= 64 {
  7474  					return ErrIntOverflowGenerated
  7475  				}
  7476  				if iNdEx >= l {
  7477  					return io.ErrUnexpectedEOF
  7478  				}
  7479  				b := dAtA[iNdEx]
  7480  				iNdEx++
  7481  				stringLen |= uint64(b&0x7F) << shift
  7482  				if b < 0x80 {
  7483  					break
  7484  				}
  7485  			}
  7486  			intStringLen := int(stringLen)
  7487  			if intStringLen < 0 {
  7488  				return ErrInvalidLengthGenerated
  7489  			}
  7490  			postIndex := iNdEx + intStringLen
  7491  			if postIndex < 0 {
  7492  				return ErrInvalidLengthGenerated
  7493  			}
  7494  			if postIndex > l {
  7495  				return io.ErrUnexpectedEOF
  7496  			}
  7497  			m.Expression = string(dAtA[iNdEx:postIndex])
  7498  			iNdEx = postIndex
  7499  		case 2:
  7500  			if wireType != 2 {
  7501  				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
  7502  			}
  7503  			var stringLen uint64
  7504  			for shift := uint(0); ; shift += 7 {
  7505  				if shift >= 64 {
  7506  					return ErrIntOverflowGenerated
  7507  				}
  7508  				if iNdEx >= l {
  7509  					return io.ErrUnexpectedEOF
  7510  				}
  7511  				b := dAtA[iNdEx]
  7512  				iNdEx++
  7513  				stringLen |= uint64(b&0x7F) << shift
  7514  				if b < 0x80 {
  7515  					break
  7516  				}
  7517  			}
  7518  			intStringLen := int(stringLen)
  7519  			if intStringLen < 0 {
  7520  				return ErrInvalidLengthGenerated
  7521  			}
  7522  			postIndex := iNdEx + intStringLen
  7523  			if postIndex < 0 {
  7524  				return ErrInvalidLengthGenerated
  7525  			}
  7526  			if postIndex > l {
  7527  				return io.ErrUnexpectedEOF
  7528  			}
  7529  			m.Message = string(dAtA[iNdEx:postIndex])
  7530  			iNdEx = postIndex
  7531  		case 3:
  7532  			if wireType != 2 {
  7533  				return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
  7534  			}
  7535  			var stringLen uint64
  7536  			for shift := uint(0); ; shift += 7 {
  7537  				if shift >= 64 {
  7538  					return ErrIntOverflowGenerated
  7539  				}
  7540  				if iNdEx >= l {
  7541  					return io.ErrUnexpectedEOF
  7542  				}
  7543  				b := dAtA[iNdEx]
  7544  				iNdEx++
  7545  				stringLen |= uint64(b&0x7F) << shift
  7546  				if b < 0x80 {
  7547  					break
  7548  				}
  7549  			}
  7550  			intStringLen := int(stringLen)
  7551  			if intStringLen < 0 {
  7552  				return ErrInvalidLengthGenerated
  7553  			}
  7554  			postIndex := iNdEx + intStringLen
  7555  			if postIndex < 0 {
  7556  				return ErrInvalidLengthGenerated
  7557  			}
  7558  			if postIndex > l {
  7559  				return io.ErrUnexpectedEOF
  7560  			}
  7561  			s := k8s_io_apimachinery_pkg_apis_meta_v1.StatusReason(dAtA[iNdEx:postIndex])
  7562  			m.Reason = &s
  7563  			iNdEx = postIndex
  7564  		case 4:
  7565  			if wireType != 2 {
  7566  				return fmt.Errorf("proto: wrong wireType = %d for field MessageExpression", wireType)
  7567  			}
  7568  			var stringLen uint64
  7569  			for shift := uint(0); ; shift += 7 {
  7570  				if shift >= 64 {
  7571  					return ErrIntOverflowGenerated
  7572  				}
  7573  				if iNdEx >= l {
  7574  					return io.ErrUnexpectedEOF
  7575  				}
  7576  				b := dAtA[iNdEx]
  7577  				iNdEx++
  7578  				stringLen |= uint64(b&0x7F) << shift
  7579  				if b < 0x80 {
  7580  					break
  7581  				}
  7582  			}
  7583  			intStringLen := int(stringLen)
  7584  			if intStringLen < 0 {
  7585  				return ErrInvalidLengthGenerated
  7586  			}
  7587  			postIndex := iNdEx + intStringLen
  7588  			if postIndex < 0 {
  7589  				return ErrInvalidLengthGenerated
  7590  			}
  7591  			if postIndex > l {
  7592  				return io.ErrUnexpectedEOF
  7593  			}
  7594  			m.MessageExpression = string(dAtA[iNdEx:postIndex])
  7595  			iNdEx = postIndex
  7596  		default:
  7597  			iNdEx = preIndex
  7598  			skippy, err := skipGenerated(dAtA[iNdEx:])
  7599  			if err != nil {
  7600  				return err
  7601  			}
  7602  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7603  				return ErrInvalidLengthGenerated
  7604  			}
  7605  			if (iNdEx + skippy) > l {
  7606  				return io.ErrUnexpectedEOF
  7607  			}
  7608  			iNdEx += skippy
  7609  		}
  7610  	}
  7611  
  7612  	if iNdEx > l {
  7613  		return io.ErrUnexpectedEOF
  7614  	}
  7615  	return nil
  7616  }
  7617  func (m *Variable) Unmarshal(dAtA []byte) error {
  7618  	l := len(dAtA)
  7619  	iNdEx := 0
  7620  	for iNdEx < l {
  7621  		preIndex := iNdEx
  7622  		var wire uint64
  7623  		for shift := uint(0); ; shift += 7 {
  7624  			if shift >= 64 {
  7625  				return ErrIntOverflowGenerated
  7626  			}
  7627  			if iNdEx >= l {
  7628  				return io.ErrUnexpectedEOF
  7629  			}
  7630  			b := dAtA[iNdEx]
  7631  			iNdEx++
  7632  			wire |= uint64(b&0x7F) << shift
  7633  			if b < 0x80 {
  7634  				break
  7635  			}
  7636  		}
  7637  		fieldNum := int32(wire >> 3)
  7638  		wireType := int(wire & 0x7)
  7639  		if wireType == 4 {
  7640  			return fmt.Errorf("proto: Variable: wiretype end group for non-group")
  7641  		}
  7642  		if fieldNum <= 0 {
  7643  			return fmt.Errorf("proto: Variable: illegal tag %d (wire type %d)", fieldNum, wire)
  7644  		}
  7645  		switch fieldNum {
  7646  		case 1:
  7647  			if wireType != 2 {
  7648  				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
  7649  			}
  7650  			var stringLen uint64
  7651  			for shift := uint(0); ; shift += 7 {
  7652  				if shift >= 64 {
  7653  					return ErrIntOverflowGenerated
  7654  				}
  7655  				if iNdEx >= l {
  7656  					return io.ErrUnexpectedEOF
  7657  				}
  7658  				b := dAtA[iNdEx]
  7659  				iNdEx++
  7660  				stringLen |= uint64(b&0x7F) << shift
  7661  				if b < 0x80 {
  7662  					break
  7663  				}
  7664  			}
  7665  			intStringLen := int(stringLen)
  7666  			if intStringLen < 0 {
  7667  				return ErrInvalidLengthGenerated
  7668  			}
  7669  			postIndex := iNdEx + intStringLen
  7670  			if postIndex < 0 {
  7671  				return ErrInvalidLengthGenerated
  7672  			}
  7673  			if postIndex > l {
  7674  				return io.ErrUnexpectedEOF
  7675  			}
  7676  			m.Name = string(dAtA[iNdEx:postIndex])
  7677  			iNdEx = postIndex
  7678  		case 2:
  7679  			if wireType != 2 {
  7680  				return fmt.Errorf("proto: wrong wireType = %d for field Expression", wireType)
  7681  			}
  7682  			var stringLen uint64
  7683  			for shift := uint(0); ; shift += 7 {
  7684  				if shift >= 64 {
  7685  					return ErrIntOverflowGenerated
  7686  				}
  7687  				if iNdEx >= l {
  7688  					return io.ErrUnexpectedEOF
  7689  				}
  7690  				b := dAtA[iNdEx]
  7691  				iNdEx++
  7692  				stringLen |= uint64(b&0x7F) << shift
  7693  				if b < 0x80 {
  7694  					break
  7695  				}
  7696  			}
  7697  			intStringLen := int(stringLen)
  7698  			if intStringLen < 0 {
  7699  				return ErrInvalidLengthGenerated
  7700  			}
  7701  			postIndex := iNdEx + intStringLen
  7702  			if postIndex < 0 {
  7703  				return ErrInvalidLengthGenerated
  7704  			}
  7705  			if postIndex > l {
  7706  				return io.ErrUnexpectedEOF
  7707  			}
  7708  			m.Expression = string(dAtA[iNdEx:postIndex])
  7709  			iNdEx = postIndex
  7710  		default:
  7711  			iNdEx = preIndex
  7712  			skippy, err := skipGenerated(dAtA[iNdEx:])
  7713  			if err != nil {
  7714  				return err
  7715  			}
  7716  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7717  				return ErrInvalidLengthGenerated
  7718  			}
  7719  			if (iNdEx + skippy) > l {
  7720  				return io.ErrUnexpectedEOF
  7721  			}
  7722  			iNdEx += skippy
  7723  		}
  7724  	}
  7725  
  7726  	if iNdEx > l {
  7727  		return io.ErrUnexpectedEOF
  7728  	}
  7729  	return nil
  7730  }
  7731  func (m *WebhookClientConfig) Unmarshal(dAtA []byte) error {
  7732  	l := len(dAtA)
  7733  	iNdEx := 0
  7734  	for iNdEx < l {
  7735  		preIndex := iNdEx
  7736  		var wire uint64
  7737  		for shift := uint(0); ; shift += 7 {
  7738  			if shift >= 64 {
  7739  				return ErrIntOverflowGenerated
  7740  			}
  7741  			if iNdEx >= l {
  7742  				return io.ErrUnexpectedEOF
  7743  			}
  7744  			b := dAtA[iNdEx]
  7745  			iNdEx++
  7746  			wire |= uint64(b&0x7F) << shift
  7747  			if b < 0x80 {
  7748  				break
  7749  			}
  7750  		}
  7751  		fieldNum := int32(wire >> 3)
  7752  		wireType := int(wire & 0x7)
  7753  		if wireType == 4 {
  7754  			return fmt.Errorf("proto: WebhookClientConfig: wiretype end group for non-group")
  7755  		}
  7756  		if fieldNum <= 0 {
  7757  			return fmt.Errorf("proto: WebhookClientConfig: illegal tag %d (wire type %d)", fieldNum, wire)
  7758  		}
  7759  		switch fieldNum {
  7760  		case 1:
  7761  			if wireType != 2 {
  7762  				return fmt.Errorf("proto: wrong wireType = %d for field Service", wireType)
  7763  			}
  7764  			var msglen int
  7765  			for shift := uint(0); ; shift += 7 {
  7766  				if shift >= 64 {
  7767  					return ErrIntOverflowGenerated
  7768  				}
  7769  				if iNdEx >= l {
  7770  					return io.ErrUnexpectedEOF
  7771  				}
  7772  				b := dAtA[iNdEx]
  7773  				iNdEx++
  7774  				msglen |= int(b&0x7F) << shift
  7775  				if b < 0x80 {
  7776  					break
  7777  				}
  7778  			}
  7779  			if msglen < 0 {
  7780  				return ErrInvalidLengthGenerated
  7781  			}
  7782  			postIndex := iNdEx + msglen
  7783  			if postIndex < 0 {
  7784  				return ErrInvalidLengthGenerated
  7785  			}
  7786  			if postIndex > l {
  7787  				return io.ErrUnexpectedEOF
  7788  			}
  7789  			if m.Service == nil {
  7790  				m.Service = &ServiceReference{}
  7791  			}
  7792  			if err := m.Service.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  7793  				return err
  7794  			}
  7795  			iNdEx = postIndex
  7796  		case 2:
  7797  			if wireType != 2 {
  7798  				return fmt.Errorf("proto: wrong wireType = %d for field CABundle", wireType)
  7799  			}
  7800  			var byteLen int
  7801  			for shift := uint(0); ; shift += 7 {
  7802  				if shift >= 64 {
  7803  					return ErrIntOverflowGenerated
  7804  				}
  7805  				if iNdEx >= l {
  7806  					return io.ErrUnexpectedEOF
  7807  				}
  7808  				b := dAtA[iNdEx]
  7809  				iNdEx++
  7810  				byteLen |= int(b&0x7F) << shift
  7811  				if b < 0x80 {
  7812  					break
  7813  				}
  7814  			}
  7815  			if byteLen < 0 {
  7816  				return ErrInvalidLengthGenerated
  7817  			}
  7818  			postIndex := iNdEx + byteLen
  7819  			if postIndex < 0 {
  7820  				return ErrInvalidLengthGenerated
  7821  			}
  7822  			if postIndex > l {
  7823  				return io.ErrUnexpectedEOF
  7824  			}
  7825  			m.CABundle = append(m.CABundle[:0], dAtA[iNdEx:postIndex]...)
  7826  			if m.CABundle == nil {
  7827  				m.CABundle = []byte{}
  7828  			}
  7829  			iNdEx = postIndex
  7830  		case 3:
  7831  			if wireType != 2 {
  7832  				return fmt.Errorf("proto: wrong wireType = %d for field URL", wireType)
  7833  			}
  7834  			var stringLen uint64
  7835  			for shift := uint(0); ; shift += 7 {
  7836  				if shift >= 64 {
  7837  					return ErrIntOverflowGenerated
  7838  				}
  7839  				if iNdEx >= l {
  7840  					return io.ErrUnexpectedEOF
  7841  				}
  7842  				b := dAtA[iNdEx]
  7843  				iNdEx++
  7844  				stringLen |= uint64(b&0x7F) << shift
  7845  				if b < 0x80 {
  7846  					break
  7847  				}
  7848  			}
  7849  			intStringLen := int(stringLen)
  7850  			if intStringLen < 0 {
  7851  				return ErrInvalidLengthGenerated
  7852  			}
  7853  			postIndex := iNdEx + intStringLen
  7854  			if postIndex < 0 {
  7855  				return ErrInvalidLengthGenerated
  7856  			}
  7857  			if postIndex > l {
  7858  				return io.ErrUnexpectedEOF
  7859  			}
  7860  			s := string(dAtA[iNdEx:postIndex])
  7861  			m.URL = &s
  7862  			iNdEx = postIndex
  7863  		default:
  7864  			iNdEx = preIndex
  7865  			skippy, err := skipGenerated(dAtA[iNdEx:])
  7866  			if err != nil {
  7867  				return err
  7868  			}
  7869  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7870  				return ErrInvalidLengthGenerated
  7871  			}
  7872  			if (iNdEx + skippy) > l {
  7873  				return io.ErrUnexpectedEOF
  7874  			}
  7875  			iNdEx += skippy
  7876  		}
  7877  	}
  7878  
  7879  	if iNdEx > l {
  7880  		return io.ErrUnexpectedEOF
  7881  	}
  7882  	return nil
  7883  }
  7884  func skipGenerated(dAtA []byte) (n int, err error) {
  7885  	l := len(dAtA)
  7886  	iNdEx := 0
  7887  	depth := 0
  7888  	for iNdEx < l {
  7889  		var wire uint64
  7890  		for shift := uint(0); ; shift += 7 {
  7891  			if shift >= 64 {
  7892  				return 0, ErrIntOverflowGenerated
  7893  			}
  7894  			if iNdEx >= l {
  7895  				return 0, io.ErrUnexpectedEOF
  7896  			}
  7897  			b := dAtA[iNdEx]
  7898  			iNdEx++
  7899  			wire |= (uint64(b) & 0x7F) << shift
  7900  			if b < 0x80 {
  7901  				break
  7902  			}
  7903  		}
  7904  		wireType := int(wire & 0x7)
  7905  		switch wireType {
  7906  		case 0:
  7907  			for shift := uint(0); ; shift += 7 {
  7908  				if shift >= 64 {
  7909  					return 0, ErrIntOverflowGenerated
  7910  				}
  7911  				if iNdEx >= l {
  7912  					return 0, io.ErrUnexpectedEOF
  7913  				}
  7914  				iNdEx++
  7915  				if dAtA[iNdEx-1] < 0x80 {
  7916  					break
  7917  				}
  7918  			}
  7919  		case 1:
  7920  			iNdEx += 8
  7921  		case 2:
  7922  			var length int
  7923  			for shift := uint(0); ; shift += 7 {
  7924  				if shift >= 64 {
  7925  					return 0, ErrIntOverflowGenerated
  7926  				}
  7927  				if iNdEx >= l {
  7928  					return 0, io.ErrUnexpectedEOF
  7929  				}
  7930  				b := dAtA[iNdEx]
  7931  				iNdEx++
  7932  				length |= (int(b) & 0x7F) << shift
  7933  				if b < 0x80 {
  7934  					break
  7935  				}
  7936  			}
  7937  			if length < 0 {
  7938  				return 0, ErrInvalidLengthGenerated
  7939  			}
  7940  			iNdEx += length
  7941  		case 3:
  7942  			depth++
  7943  		case 4:
  7944  			if depth == 0 {
  7945  				return 0, ErrUnexpectedEndOfGroupGenerated
  7946  			}
  7947  			depth--
  7948  		case 5:
  7949  			iNdEx += 4
  7950  		default:
  7951  			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
  7952  		}
  7953  		if iNdEx < 0 {
  7954  			return 0, ErrInvalidLengthGenerated
  7955  		}
  7956  		if depth == 0 {
  7957  			return iNdEx, nil
  7958  		}
  7959  	}
  7960  	return 0, io.ErrUnexpectedEOF
  7961  }
  7962  
  7963  var (
  7964  	ErrInvalidLengthGenerated        = fmt.Errorf("proto: negative length found during unmarshaling")
  7965  	ErrIntOverflowGenerated          = fmt.Errorf("proto: integer overflow")
  7966  	ErrUnexpectedEndOfGroupGenerated = fmt.Errorf("proto: unexpected end of group")
  7967  )
  7968  

View as plain text