Source file src/k8s.io/api/rbac/v1alpha1/generated.pb.go

Documentation: k8s.io/api/rbac/v1alpha1

     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/rbac/v1alpha1/generated.proto
    19  
    20  package v1alpha1
    21  
    22  import (
    23  	fmt "fmt"
    24  
    25  	io "io"
    26  
    27  	proto "github.com/gogo/protobuf/proto"
    28  	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    29  
    30  	math "math"
    31  	math_bits "math/bits"
    32  	reflect "reflect"
    33  	strings "strings"
    34  )
    35  
    36  // Reference imports to suppress errors if they are not otherwise used.
    37  var _ = proto.Marshal
    38  var _ = fmt.Errorf
    39  var _ = math.Inf
    40  
    41  // This is a compile-time assertion to ensure that this generated file
    42  // is compatible with the proto package it is being compiled against.
    43  // A compilation error at this line likely means your copy of the
    44  // proto package needs to be updated.
    45  const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
    46  
    47  func (m *AggregationRule) Reset()      { *m = AggregationRule{} }
    48  func (*AggregationRule) ProtoMessage() {}
    49  func (*AggregationRule) Descriptor() ([]byte, []int) {
    50  	return fileDescriptor_758889dfd9a88fa6, []int{0}
    51  }
    52  func (m *AggregationRule) XXX_Unmarshal(b []byte) error {
    53  	return m.Unmarshal(b)
    54  }
    55  func (m *AggregationRule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    56  	b = b[:cap(b)]
    57  	n, err := m.MarshalToSizedBuffer(b)
    58  	if err != nil {
    59  		return nil, err
    60  	}
    61  	return b[:n], nil
    62  }
    63  func (m *AggregationRule) XXX_Merge(src proto.Message) {
    64  	xxx_messageInfo_AggregationRule.Merge(m, src)
    65  }
    66  func (m *AggregationRule) XXX_Size() int {
    67  	return m.Size()
    68  }
    69  func (m *AggregationRule) XXX_DiscardUnknown() {
    70  	xxx_messageInfo_AggregationRule.DiscardUnknown(m)
    71  }
    72  
    73  var xxx_messageInfo_AggregationRule proto.InternalMessageInfo
    74  
    75  func (m *ClusterRole) Reset()      { *m = ClusterRole{} }
    76  func (*ClusterRole) ProtoMessage() {}
    77  func (*ClusterRole) Descriptor() ([]byte, []int) {
    78  	return fileDescriptor_758889dfd9a88fa6, []int{1}
    79  }
    80  func (m *ClusterRole) XXX_Unmarshal(b []byte) error {
    81  	return m.Unmarshal(b)
    82  }
    83  func (m *ClusterRole) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    84  	b = b[:cap(b)]
    85  	n, err := m.MarshalToSizedBuffer(b)
    86  	if err != nil {
    87  		return nil, err
    88  	}
    89  	return b[:n], nil
    90  }
    91  func (m *ClusterRole) XXX_Merge(src proto.Message) {
    92  	xxx_messageInfo_ClusterRole.Merge(m, src)
    93  }
    94  func (m *ClusterRole) XXX_Size() int {
    95  	return m.Size()
    96  }
    97  func (m *ClusterRole) XXX_DiscardUnknown() {
    98  	xxx_messageInfo_ClusterRole.DiscardUnknown(m)
    99  }
   100  
   101  var xxx_messageInfo_ClusterRole proto.InternalMessageInfo
   102  
   103  func (m *ClusterRoleBinding) Reset()      { *m = ClusterRoleBinding{} }
   104  func (*ClusterRoleBinding) ProtoMessage() {}
   105  func (*ClusterRoleBinding) Descriptor() ([]byte, []int) {
   106  	return fileDescriptor_758889dfd9a88fa6, []int{2}
   107  }
   108  func (m *ClusterRoleBinding) XXX_Unmarshal(b []byte) error {
   109  	return m.Unmarshal(b)
   110  }
   111  func (m *ClusterRoleBinding) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   112  	b = b[:cap(b)]
   113  	n, err := m.MarshalToSizedBuffer(b)
   114  	if err != nil {
   115  		return nil, err
   116  	}
   117  	return b[:n], nil
   118  }
   119  func (m *ClusterRoleBinding) XXX_Merge(src proto.Message) {
   120  	xxx_messageInfo_ClusterRoleBinding.Merge(m, src)
   121  }
   122  func (m *ClusterRoleBinding) XXX_Size() int {
   123  	return m.Size()
   124  }
   125  func (m *ClusterRoleBinding) XXX_DiscardUnknown() {
   126  	xxx_messageInfo_ClusterRoleBinding.DiscardUnknown(m)
   127  }
   128  
   129  var xxx_messageInfo_ClusterRoleBinding proto.InternalMessageInfo
   130  
   131  func (m *ClusterRoleBindingList) Reset()      { *m = ClusterRoleBindingList{} }
   132  func (*ClusterRoleBindingList) ProtoMessage() {}
   133  func (*ClusterRoleBindingList) Descriptor() ([]byte, []int) {
   134  	return fileDescriptor_758889dfd9a88fa6, []int{3}
   135  }
   136  func (m *ClusterRoleBindingList) XXX_Unmarshal(b []byte) error {
   137  	return m.Unmarshal(b)
   138  }
   139  func (m *ClusterRoleBindingList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   140  	b = b[:cap(b)]
   141  	n, err := m.MarshalToSizedBuffer(b)
   142  	if err != nil {
   143  		return nil, err
   144  	}
   145  	return b[:n], nil
   146  }
   147  func (m *ClusterRoleBindingList) XXX_Merge(src proto.Message) {
   148  	xxx_messageInfo_ClusterRoleBindingList.Merge(m, src)
   149  }
   150  func (m *ClusterRoleBindingList) XXX_Size() int {
   151  	return m.Size()
   152  }
   153  func (m *ClusterRoleBindingList) XXX_DiscardUnknown() {
   154  	xxx_messageInfo_ClusterRoleBindingList.DiscardUnknown(m)
   155  }
   156  
   157  var xxx_messageInfo_ClusterRoleBindingList proto.InternalMessageInfo
   158  
   159  func (m *ClusterRoleList) Reset()      { *m = ClusterRoleList{} }
   160  func (*ClusterRoleList) ProtoMessage() {}
   161  func (*ClusterRoleList) Descriptor() ([]byte, []int) {
   162  	return fileDescriptor_758889dfd9a88fa6, []int{4}
   163  }
   164  func (m *ClusterRoleList) XXX_Unmarshal(b []byte) error {
   165  	return m.Unmarshal(b)
   166  }
   167  func (m *ClusterRoleList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   168  	b = b[:cap(b)]
   169  	n, err := m.MarshalToSizedBuffer(b)
   170  	if err != nil {
   171  		return nil, err
   172  	}
   173  	return b[:n], nil
   174  }
   175  func (m *ClusterRoleList) XXX_Merge(src proto.Message) {
   176  	xxx_messageInfo_ClusterRoleList.Merge(m, src)
   177  }
   178  func (m *ClusterRoleList) XXX_Size() int {
   179  	return m.Size()
   180  }
   181  func (m *ClusterRoleList) XXX_DiscardUnknown() {
   182  	xxx_messageInfo_ClusterRoleList.DiscardUnknown(m)
   183  }
   184  
   185  var xxx_messageInfo_ClusterRoleList proto.InternalMessageInfo
   186  
   187  func (m *PolicyRule) Reset()      { *m = PolicyRule{} }
   188  func (*PolicyRule) ProtoMessage() {}
   189  func (*PolicyRule) Descriptor() ([]byte, []int) {
   190  	return fileDescriptor_758889dfd9a88fa6, []int{5}
   191  }
   192  func (m *PolicyRule) XXX_Unmarshal(b []byte) error {
   193  	return m.Unmarshal(b)
   194  }
   195  func (m *PolicyRule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   196  	b = b[:cap(b)]
   197  	n, err := m.MarshalToSizedBuffer(b)
   198  	if err != nil {
   199  		return nil, err
   200  	}
   201  	return b[:n], nil
   202  }
   203  func (m *PolicyRule) XXX_Merge(src proto.Message) {
   204  	xxx_messageInfo_PolicyRule.Merge(m, src)
   205  }
   206  func (m *PolicyRule) XXX_Size() int {
   207  	return m.Size()
   208  }
   209  func (m *PolicyRule) XXX_DiscardUnknown() {
   210  	xxx_messageInfo_PolicyRule.DiscardUnknown(m)
   211  }
   212  
   213  var xxx_messageInfo_PolicyRule proto.InternalMessageInfo
   214  
   215  func (m *Role) Reset()      { *m = Role{} }
   216  func (*Role) ProtoMessage() {}
   217  func (*Role) Descriptor() ([]byte, []int) {
   218  	return fileDescriptor_758889dfd9a88fa6, []int{6}
   219  }
   220  func (m *Role) XXX_Unmarshal(b []byte) error {
   221  	return m.Unmarshal(b)
   222  }
   223  func (m *Role) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   224  	b = b[:cap(b)]
   225  	n, err := m.MarshalToSizedBuffer(b)
   226  	if err != nil {
   227  		return nil, err
   228  	}
   229  	return b[:n], nil
   230  }
   231  func (m *Role) XXX_Merge(src proto.Message) {
   232  	xxx_messageInfo_Role.Merge(m, src)
   233  }
   234  func (m *Role) XXX_Size() int {
   235  	return m.Size()
   236  }
   237  func (m *Role) XXX_DiscardUnknown() {
   238  	xxx_messageInfo_Role.DiscardUnknown(m)
   239  }
   240  
   241  var xxx_messageInfo_Role proto.InternalMessageInfo
   242  
   243  func (m *RoleBinding) Reset()      { *m = RoleBinding{} }
   244  func (*RoleBinding) ProtoMessage() {}
   245  func (*RoleBinding) Descriptor() ([]byte, []int) {
   246  	return fileDescriptor_758889dfd9a88fa6, []int{7}
   247  }
   248  func (m *RoleBinding) XXX_Unmarshal(b []byte) error {
   249  	return m.Unmarshal(b)
   250  }
   251  func (m *RoleBinding) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   252  	b = b[:cap(b)]
   253  	n, err := m.MarshalToSizedBuffer(b)
   254  	if err != nil {
   255  		return nil, err
   256  	}
   257  	return b[:n], nil
   258  }
   259  func (m *RoleBinding) XXX_Merge(src proto.Message) {
   260  	xxx_messageInfo_RoleBinding.Merge(m, src)
   261  }
   262  func (m *RoleBinding) XXX_Size() int {
   263  	return m.Size()
   264  }
   265  func (m *RoleBinding) XXX_DiscardUnknown() {
   266  	xxx_messageInfo_RoleBinding.DiscardUnknown(m)
   267  }
   268  
   269  var xxx_messageInfo_RoleBinding proto.InternalMessageInfo
   270  
   271  func (m *RoleBindingList) Reset()      { *m = RoleBindingList{} }
   272  func (*RoleBindingList) ProtoMessage() {}
   273  func (*RoleBindingList) Descriptor() ([]byte, []int) {
   274  	return fileDescriptor_758889dfd9a88fa6, []int{8}
   275  }
   276  func (m *RoleBindingList) XXX_Unmarshal(b []byte) error {
   277  	return m.Unmarshal(b)
   278  }
   279  func (m *RoleBindingList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   280  	b = b[:cap(b)]
   281  	n, err := m.MarshalToSizedBuffer(b)
   282  	if err != nil {
   283  		return nil, err
   284  	}
   285  	return b[:n], nil
   286  }
   287  func (m *RoleBindingList) XXX_Merge(src proto.Message) {
   288  	xxx_messageInfo_RoleBindingList.Merge(m, src)
   289  }
   290  func (m *RoleBindingList) XXX_Size() int {
   291  	return m.Size()
   292  }
   293  func (m *RoleBindingList) XXX_DiscardUnknown() {
   294  	xxx_messageInfo_RoleBindingList.DiscardUnknown(m)
   295  }
   296  
   297  var xxx_messageInfo_RoleBindingList proto.InternalMessageInfo
   298  
   299  func (m *RoleList) Reset()      { *m = RoleList{} }
   300  func (*RoleList) ProtoMessage() {}
   301  func (*RoleList) Descriptor() ([]byte, []int) {
   302  	return fileDescriptor_758889dfd9a88fa6, []int{9}
   303  }
   304  func (m *RoleList) XXX_Unmarshal(b []byte) error {
   305  	return m.Unmarshal(b)
   306  }
   307  func (m *RoleList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   308  	b = b[:cap(b)]
   309  	n, err := m.MarshalToSizedBuffer(b)
   310  	if err != nil {
   311  		return nil, err
   312  	}
   313  	return b[:n], nil
   314  }
   315  func (m *RoleList) XXX_Merge(src proto.Message) {
   316  	xxx_messageInfo_RoleList.Merge(m, src)
   317  }
   318  func (m *RoleList) XXX_Size() int {
   319  	return m.Size()
   320  }
   321  func (m *RoleList) XXX_DiscardUnknown() {
   322  	xxx_messageInfo_RoleList.DiscardUnknown(m)
   323  }
   324  
   325  var xxx_messageInfo_RoleList proto.InternalMessageInfo
   326  
   327  func (m *RoleRef) Reset()      { *m = RoleRef{} }
   328  func (*RoleRef) ProtoMessage() {}
   329  func (*RoleRef) Descriptor() ([]byte, []int) {
   330  	return fileDescriptor_758889dfd9a88fa6, []int{10}
   331  }
   332  func (m *RoleRef) XXX_Unmarshal(b []byte) error {
   333  	return m.Unmarshal(b)
   334  }
   335  func (m *RoleRef) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   336  	b = b[:cap(b)]
   337  	n, err := m.MarshalToSizedBuffer(b)
   338  	if err != nil {
   339  		return nil, err
   340  	}
   341  	return b[:n], nil
   342  }
   343  func (m *RoleRef) XXX_Merge(src proto.Message) {
   344  	xxx_messageInfo_RoleRef.Merge(m, src)
   345  }
   346  func (m *RoleRef) XXX_Size() int {
   347  	return m.Size()
   348  }
   349  func (m *RoleRef) XXX_DiscardUnknown() {
   350  	xxx_messageInfo_RoleRef.DiscardUnknown(m)
   351  }
   352  
   353  var xxx_messageInfo_RoleRef proto.InternalMessageInfo
   354  
   355  func (m *Subject) Reset()      { *m = Subject{} }
   356  func (*Subject) ProtoMessage() {}
   357  func (*Subject) Descriptor() ([]byte, []int) {
   358  	return fileDescriptor_758889dfd9a88fa6, []int{11}
   359  }
   360  func (m *Subject) XXX_Unmarshal(b []byte) error {
   361  	return m.Unmarshal(b)
   362  }
   363  func (m *Subject) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   364  	b = b[:cap(b)]
   365  	n, err := m.MarshalToSizedBuffer(b)
   366  	if err != nil {
   367  		return nil, err
   368  	}
   369  	return b[:n], nil
   370  }
   371  func (m *Subject) XXX_Merge(src proto.Message) {
   372  	xxx_messageInfo_Subject.Merge(m, src)
   373  }
   374  func (m *Subject) XXX_Size() int {
   375  	return m.Size()
   376  }
   377  func (m *Subject) XXX_DiscardUnknown() {
   378  	xxx_messageInfo_Subject.DiscardUnknown(m)
   379  }
   380  
   381  var xxx_messageInfo_Subject proto.InternalMessageInfo
   382  
   383  func init() {
   384  	proto.RegisterType((*AggregationRule)(nil), "k8s.io.api.rbac.v1alpha1.AggregationRule")
   385  	proto.RegisterType((*ClusterRole)(nil), "k8s.io.api.rbac.v1alpha1.ClusterRole")
   386  	proto.RegisterType((*ClusterRoleBinding)(nil), "k8s.io.api.rbac.v1alpha1.ClusterRoleBinding")
   387  	proto.RegisterType((*ClusterRoleBindingList)(nil), "k8s.io.api.rbac.v1alpha1.ClusterRoleBindingList")
   388  	proto.RegisterType((*ClusterRoleList)(nil), "k8s.io.api.rbac.v1alpha1.ClusterRoleList")
   389  	proto.RegisterType((*PolicyRule)(nil), "k8s.io.api.rbac.v1alpha1.PolicyRule")
   390  	proto.RegisterType((*Role)(nil), "k8s.io.api.rbac.v1alpha1.Role")
   391  	proto.RegisterType((*RoleBinding)(nil), "k8s.io.api.rbac.v1alpha1.RoleBinding")
   392  	proto.RegisterType((*RoleBindingList)(nil), "k8s.io.api.rbac.v1alpha1.RoleBindingList")
   393  	proto.RegisterType((*RoleList)(nil), "k8s.io.api.rbac.v1alpha1.RoleList")
   394  	proto.RegisterType((*RoleRef)(nil), "k8s.io.api.rbac.v1alpha1.RoleRef")
   395  	proto.RegisterType((*Subject)(nil), "k8s.io.api.rbac.v1alpha1.Subject")
   396  }
   397  
   398  func init() {
   399  	proto.RegisterFile("k8s.io/api/rbac/v1alpha1/generated.proto", fileDescriptor_758889dfd9a88fa6)
   400  }
   401  
   402  var fileDescriptor_758889dfd9a88fa6 = []byte{
   403  	// 819 bytes of a gzipped FileDescriptorProto
   404  	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x56, 0xcf, 0x6f, 0xe3, 0x44,
   405  	0x14, 0xce, 0xa4, 0x09, 0x4d, 0x26, 0x44, 0xa1, 0x43, 0x85, 0xac, 0x0a, 0x39, 0xc5, 0x02, 0xa9,
   406  	0x88, 0x62, 0xd3, 0x82, 0x80, 0x0b, 0x48, 0x75, 0x0f, 0x28, 0x10, 0xda, 0x32, 0x15, 0x3d, 0x20,
   407  	0x0e, 0x4c, 0x9c, 0xa9, 0x33, 0xc4, 0xbf, 0xe4, 0xb1, 0x23, 0x55, 0x5c, 0xb8, 0x70, 0x45, 0x5c,
   408  	0x38, 0x70, 0xe7, 0xca, 0x85, 0x3d, 0xee, 0x3f, 0xd0, 0xbd, 0xf5, 0xd8, 0x53, 0xb4, 0xf5, 0xfe,
   409  	0x21, 0xbb, 0xf2, 0xd8, 0x8e, 0x9d, 0x5f, 0x9b, 0x9c, 0x22, 0xad, 0xb4, 0xa7, 0x64, 0xde, 0xfb,
   410  	0xde, 0xf7, 0xde, 0xfb, 0x66, 0xde, 0x4b, 0xe0, 0xc1, 0xf0, 0x4b, 0xae, 0x32, 0x57, 0x23, 0x1e,
   411  	0xd3, 0xfc, 0x1e, 0x31, 0xb4, 0xd1, 0x11, 0xb1, 0xbc, 0x01, 0x39, 0xd2, 0x4c, 0xea, 0x50, 0x9f,
   412  	0x04, 0xb4, 0xaf, 0x7a, 0xbe, 0x1b, 0xb8, 0x48, 0x4a, 0x90, 0x2a, 0xf1, 0x98, 0x1a, 0x23, 0xd5,
   413  	0x0c, 0xb9, 0xf7, 0xb1, 0xc9, 0x82, 0x41, 0xd8, 0x53, 0x0d, 0xd7, 0xd6, 0x4c, 0xd7, 0x74, 0x35,
   414  	0x11, 0xd0, 0x0b, 0xaf, 0xc5, 0x49, 0x1c, 0xc4, 0xb7, 0x84, 0x68, 0xef, 0xb3, 0x3c, 0xa5, 0x4d,
   415  	0x8c, 0x01, 0x73, 0xa8, 0x7f, 0xa3, 0x79, 0x43, 0x33, 0x36, 0x70, 0xcd, 0xa6, 0x01, 0xd1, 0x46,
   416  	0x73, 0xe9, 0xf7, 0xb4, 0x65, 0x51, 0x7e, 0xe8, 0x04, 0xcc, 0xa6, 0x73, 0x01, 0x9f, 0xaf, 0x0a,
   417  	0xe0, 0xc6, 0x80, 0xda, 0x64, 0x36, 0x4e, 0xf9, 0x07, 0xc0, 0xd6, 0x89, 0x69, 0xfa, 0xd4, 0x24,
   418  	0x01, 0x73, 0x1d, 0x1c, 0x5a, 0x14, 0xfd, 0x01, 0xe0, 0xae, 0x61, 0x85, 0x3c, 0xa0, 0x3e, 0x76,
   419  	0x2d, 0x7a, 0x49, 0x2d, 0x6a, 0x04, 0xae, 0xcf, 0x25, 0xb0, 0xbf, 0x75, 0xd0, 0x38, 0xfe, 0x54,
   420  	0xcd, 0xb5, 0x99, 0xe4, 0x52, 0xbd, 0xa1, 0x19, 0x1b, 0xb8, 0x1a, 0xb7, 0xa4, 0x8e, 0x8e, 0xd4,
   421  	0x2e, 0xe9, 0x51, 0x2b, 0x8b, 0xd5, 0xdf, 0xbd, 0x1d, 0xb7, 0x4b, 0xd1, 0xb8, 0xbd, 0x7b, 0xba,
   422  	0x80, 0x18, 0x2f, 0x4c, 0xa7, 0xfc, 0x5b, 0x86, 0x8d, 0x02, 0x1c, 0xfd, 0x02, 0x6b, 0x31, 0x79,
   423  	0x9f, 0x04, 0x44, 0x02, 0xfb, 0xe0, 0xa0, 0x71, 0xfc, 0xc9, 0x7a, 0xa5, 0x9c, 0xf7, 0x7e, 0xa5,
   424  	0x46, 0xf0, 0x3d, 0x0d, 0x88, 0x8e, 0xd2, 0x3a, 0x60, 0x6e, 0xc3, 0x13, 0x56, 0xd4, 0x81, 0x55,
   425  	0x3f, 0xb4, 0x28, 0x97, 0xca, 0xa2, 0xd3, 0xf7, 0xd5, 0x65, 0xaf, 0x40, 0xbd, 0x70, 0x2d, 0x66,
   426  	0xdc, 0xc4, 0x72, 0xe9, 0xcd, 0x94, 0xb2, 0x1a, 0x9f, 0x38, 0x4e, 0x18, 0xd0, 0x00, 0xb6, 0xc8,
   427  	0xb4, 0xae, 0xd2, 0x96, 0xa8, 0xf9, 0xc3, 0xe5, 0xa4, 0x33, 0x17, 0xa1, 0xbf, 0x1d, 0x8d, 0xdb,
   428  	0xb3, 0xb7, 0x83, 0x67, 0x69, 0x95, 0xbf, 0xcb, 0x10, 0x15, 0x64, 0xd2, 0x99, 0xd3, 0x67, 0x8e,
   429  	0xb9, 0x01, 0xb5, 0xce, 0x61, 0x8d, 0x87, 0xc2, 0x91, 0x09, 0xf6, 0xde, 0xf2, 0xde, 0x2e, 0x13,
   430  	0xa4, 0xfe, 0x56, 0x4a, 0x59, 0x4b, 0x0d, 0x1c, 0x4f, 0x48, 0x50, 0x17, 0x6e, 0xfb, 0xae, 0x45,
   431  	0x31, 0xbd, 0x4e, 0xb5, 0x7a, 0x09, 0x1f, 0x4e, 0x80, 0x7a, 0x2b, 0xe5, 0xdb, 0x4e, 0x0d, 0x38,
   432  	0xa3, 0x50, 0x9e, 0x00, 0xf8, 0xce, 0xbc, 0x2e, 0x5d, 0xc6, 0x03, 0xf4, 0xf3, 0x9c, 0x36, 0xea,
   433  	0x9a, 0x8f, 0x9a, 0xf1, 0x44, 0x99, 0x49, 0x1b, 0x99, 0xa5, 0xa0, 0xcb, 0x0f, 0xb0, 0xca, 0x02,
   434  	0x6a, 0x67, 0xa2, 0x1c, 0x2e, 0x6f, 0x62, 0xbe, 0xbc, 0xfc, 0x35, 0x75, 0x62, 0x0a, 0x9c, 0x30,
   435  	0x29, 0x8f, 0x01, 0x6c, 0x15, 0xc0, 0x1b, 0x68, 0xe2, 0xdb, 0xe9, 0x26, 0x3e, 0x58, 0xaf, 0x89,
   436  	0xc5, 0xd5, 0x3f, 0x07, 0x10, 0xe6, 0x03, 0x83, 0xda, 0xb0, 0x3a, 0xa2, 0x7e, 0x2f, 0xd9, 0x27,
   437  	0x75, 0xbd, 0x1e, 0xe3, 0xaf, 0x62, 0x03, 0x4e, 0xec, 0xe8, 0x23, 0x58, 0x27, 0x1e, 0xfb, 0xc6,
   438  	0x77, 0x43, 0x8f, 0x4b, 0x5b, 0x02, 0xd4, 0x8c, 0xc6, 0xed, 0xfa, 0xc9, 0x45, 0x27, 0x31, 0xe2,
   439  	0xdc, 0x1f, 0x83, 0x7d, 0xca, 0xdd, 0xd0, 0x37, 0x28, 0x97, 0x2a, 0x39, 0x18, 0x67, 0x46, 0x9c,
   440  	0xfb, 0xd1, 0x17, 0xb0, 0x99, 0x1d, 0xce, 0x88, 0x4d, 0xb9, 0x54, 0x15, 0x01, 0x3b, 0xd1, 0xb8,
   441  	0xdd, 0xc4, 0x45, 0x07, 0x9e, 0xc6, 0xa1, 0xaf, 0x60, 0xcb, 0x71, 0x9d, 0x0c, 0xf2, 0x23, 0xee,
   442  	0x72, 0xe9, 0x0d, 0x11, 0x2a, 0x66, 0xf4, 0x6c, 0xda, 0x85, 0x67, 0xb1, 0xca, 0x23, 0x00, 0x2b,
   443  	0xaf, 0xdc, 0x0e, 0x53, 0xfe, 0x2c, 0xc3, 0xc6, 0xeb, 0x95, 0x52, 0x58, 0x29, 0xf1, 0x18, 0x6e,
   444  	0x76, 0x97, 0xac, 0x3f, 0x86, 0xab, 0x97, 0xc8, 0x7f, 0x00, 0xd6, 0x36, 0xb4, 0x3d, 0x4e, 0xa7,
   445  	0xcb, 0x96, 0x57, 0x94, 0xbd, 0xb8, 0xde, 0xdf, 0x60, 0x76, 0x03, 0xe8, 0x10, 0xd6, 0xb2, 0x89,
   446  	0x17, 0xd5, 0xd6, 0xf3, 0xec, 0xd9, 0x52, 0xc0, 0x13, 0x04, 0xda, 0x87, 0x95, 0x21, 0x73, 0xfa,
   447  	0x52, 0x59, 0x20, 0xdf, 0x4c, 0x91, 0x95, 0xef, 0x98, 0xd3, 0xc7, 0xc2, 0x13, 0x23, 0x1c, 0x62,
   448  	0x27, 0x3f, 0xc9, 0x05, 0x44, 0x3c, 0xeb, 0x58, 0x78, 0x94, 0xff, 0x01, 0xdc, 0x4e, 0xdf, 0xd3,
   449  	0x84, 0x0f, 0x2c, 0xe5, 0x3b, 0x86, 0x90, 0x78, 0xec, 0x8a, 0xfa, 0x9c, 0xb9, 0x4e, 0x9a, 0x77,
   450  	0xf2, 0xd2, 0x4f, 0x2e, 0x3a, 0xa9, 0x07, 0x17, 0x50, 0xab, 0x6b, 0x40, 0x1a, 0xac, 0xc7, 0x9f,
   451  	0xdc, 0x23, 0x06, 0x95, 0x2a, 0x02, 0xb6, 0x93, 0xc2, 0xea, 0x67, 0x99, 0x03, 0xe7, 0x18, 0xfd,
   452  	0xeb, 0xdb, 0x07, 0xb9, 0x74, 0xf7, 0x20, 0x97, 0xee, 0x1f, 0xe4, 0xd2, 0xef, 0x91, 0x0c, 0x6e,
   453  	0x23, 0x19, 0xdc, 0x45, 0x32, 0xb8, 0x8f, 0x64, 0xf0, 0x34, 0x92, 0xc1, 0x5f, 0xcf, 0xe4, 0xd2,
   454  	0x4f, 0xd2, 0xb2, 0x7f, 0xc1, 0x2f, 0x02, 0x00, 0x00, 0xff, 0xff, 0xf1, 0x02, 0x55, 0xe5, 0x20,
   455  	0x0b, 0x00, 0x00,
   456  }
   457  
   458  func (m *AggregationRule) Marshal() (dAtA []byte, err error) {
   459  	size := m.Size()
   460  	dAtA = make([]byte, size)
   461  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   462  	if err != nil {
   463  		return nil, err
   464  	}
   465  	return dAtA[:n], nil
   466  }
   467  
   468  func (m *AggregationRule) MarshalTo(dAtA []byte) (int, error) {
   469  	size := m.Size()
   470  	return m.MarshalToSizedBuffer(dAtA[:size])
   471  }
   472  
   473  func (m *AggregationRule) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   474  	i := len(dAtA)
   475  	_ = i
   476  	var l int
   477  	_ = l
   478  	if len(m.ClusterRoleSelectors) > 0 {
   479  		for iNdEx := len(m.ClusterRoleSelectors) - 1; iNdEx >= 0; iNdEx-- {
   480  			{
   481  				size, err := m.ClusterRoleSelectors[iNdEx].MarshalToSizedBuffer(dAtA[:i])
   482  				if err != nil {
   483  					return 0, err
   484  				}
   485  				i -= size
   486  				i = encodeVarintGenerated(dAtA, i, uint64(size))
   487  			}
   488  			i--
   489  			dAtA[i] = 0xa
   490  		}
   491  	}
   492  	return len(dAtA) - i, nil
   493  }
   494  
   495  func (m *ClusterRole) Marshal() (dAtA []byte, err error) {
   496  	size := m.Size()
   497  	dAtA = make([]byte, size)
   498  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   499  	if err != nil {
   500  		return nil, err
   501  	}
   502  	return dAtA[:n], nil
   503  }
   504  
   505  func (m *ClusterRole) MarshalTo(dAtA []byte) (int, error) {
   506  	size := m.Size()
   507  	return m.MarshalToSizedBuffer(dAtA[:size])
   508  }
   509  
   510  func (m *ClusterRole) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   511  	i := len(dAtA)
   512  	_ = i
   513  	var l int
   514  	_ = l
   515  	if m.AggregationRule != nil {
   516  		{
   517  			size, err := m.AggregationRule.MarshalToSizedBuffer(dAtA[:i])
   518  			if err != nil {
   519  				return 0, err
   520  			}
   521  			i -= size
   522  			i = encodeVarintGenerated(dAtA, i, uint64(size))
   523  		}
   524  		i--
   525  		dAtA[i] = 0x1a
   526  	}
   527  	if len(m.Rules) > 0 {
   528  		for iNdEx := len(m.Rules) - 1; iNdEx >= 0; iNdEx-- {
   529  			{
   530  				size, err := m.Rules[iNdEx].MarshalToSizedBuffer(dAtA[:i])
   531  				if err != nil {
   532  					return 0, err
   533  				}
   534  				i -= size
   535  				i = encodeVarintGenerated(dAtA, i, uint64(size))
   536  			}
   537  			i--
   538  			dAtA[i] = 0x12
   539  		}
   540  	}
   541  	{
   542  		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
   543  		if err != nil {
   544  			return 0, err
   545  		}
   546  		i -= size
   547  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   548  	}
   549  	i--
   550  	dAtA[i] = 0xa
   551  	return len(dAtA) - i, nil
   552  }
   553  
   554  func (m *ClusterRoleBinding) Marshal() (dAtA []byte, err error) {
   555  	size := m.Size()
   556  	dAtA = make([]byte, size)
   557  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   558  	if err != nil {
   559  		return nil, err
   560  	}
   561  	return dAtA[:n], nil
   562  }
   563  
   564  func (m *ClusterRoleBinding) MarshalTo(dAtA []byte) (int, error) {
   565  	size := m.Size()
   566  	return m.MarshalToSizedBuffer(dAtA[:size])
   567  }
   568  
   569  func (m *ClusterRoleBinding) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   570  	i := len(dAtA)
   571  	_ = i
   572  	var l int
   573  	_ = l
   574  	{
   575  		size, err := m.RoleRef.MarshalToSizedBuffer(dAtA[:i])
   576  		if err != nil {
   577  			return 0, err
   578  		}
   579  		i -= size
   580  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   581  	}
   582  	i--
   583  	dAtA[i] = 0x1a
   584  	if len(m.Subjects) > 0 {
   585  		for iNdEx := len(m.Subjects) - 1; iNdEx >= 0; iNdEx-- {
   586  			{
   587  				size, err := m.Subjects[iNdEx].MarshalToSizedBuffer(dAtA[:i])
   588  				if err != nil {
   589  					return 0, err
   590  				}
   591  				i -= size
   592  				i = encodeVarintGenerated(dAtA, i, uint64(size))
   593  			}
   594  			i--
   595  			dAtA[i] = 0x12
   596  		}
   597  	}
   598  	{
   599  		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
   600  		if err != nil {
   601  			return 0, err
   602  		}
   603  		i -= size
   604  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   605  	}
   606  	i--
   607  	dAtA[i] = 0xa
   608  	return len(dAtA) - i, nil
   609  }
   610  
   611  func (m *ClusterRoleBindingList) Marshal() (dAtA []byte, err error) {
   612  	size := m.Size()
   613  	dAtA = make([]byte, size)
   614  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   615  	if err != nil {
   616  		return nil, err
   617  	}
   618  	return dAtA[:n], nil
   619  }
   620  
   621  func (m *ClusterRoleBindingList) MarshalTo(dAtA []byte) (int, error) {
   622  	size := m.Size()
   623  	return m.MarshalToSizedBuffer(dAtA[:size])
   624  }
   625  
   626  func (m *ClusterRoleBindingList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   627  	i := len(dAtA)
   628  	_ = i
   629  	var l int
   630  	_ = l
   631  	if len(m.Items) > 0 {
   632  		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
   633  			{
   634  				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
   635  				if err != nil {
   636  					return 0, err
   637  				}
   638  				i -= size
   639  				i = encodeVarintGenerated(dAtA, i, uint64(size))
   640  			}
   641  			i--
   642  			dAtA[i] = 0x12
   643  		}
   644  	}
   645  	{
   646  		size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
   647  		if err != nil {
   648  			return 0, err
   649  		}
   650  		i -= size
   651  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   652  	}
   653  	i--
   654  	dAtA[i] = 0xa
   655  	return len(dAtA) - i, nil
   656  }
   657  
   658  func (m *ClusterRoleList) Marshal() (dAtA []byte, err error) {
   659  	size := m.Size()
   660  	dAtA = make([]byte, size)
   661  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   662  	if err != nil {
   663  		return nil, err
   664  	}
   665  	return dAtA[:n], nil
   666  }
   667  
   668  func (m *ClusterRoleList) MarshalTo(dAtA []byte) (int, error) {
   669  	size := m.Size()
   670  	return m.MarshalToSizedBuffer(dAtA[:size])
   671  }
   672  
   673  func (m *ClusterRoleList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   674  	i := len(dAtA)
   675  	_ = i
   676  	var l int
   677  	_ = l
   678  	if len(m.Items) > 0 {
   679  		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
   680  			{
   681  				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
   682  				if err != nil {
   683  					return 0, err
   684  				}
   685  				i -= size
   686  				i = encodeVarintGenerated(dAtA, i, uint64(size))
   687  			}
   688  			i--
   689  			dAtA[i] = 0x12
   690  		}
   691  	}
   692  	{
   693  		size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
   694  		if err != nil {
   695  			return 0, err
   696  		}
   697  		i -= size
   698  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   699  	}
   700  	i--
   701  	dAtA[i] = 0xa
   702  	return len(dAtA) - i, nil
   703  }
   704  
   705  func (m *PolicyRule) Marshal() (dAtA []byte, err error) {
   706  	size := m.Size()
   707  	dAtA = make([]byte, size)
   708  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   709  	if err != nil {
   710  		return nil, err
   711  	}
   712  	return dAtA[:n], nil
   713  }
   714  
   715  func (m *PolicyRule) MarshalTo(dAtA []byte) (int, error) {
   716  	size := m.Size()
   717  	return m.MarshalToSizedBuffer(dAtA[:size])
   718  }
   719  
   720  func (m *PolicyRule) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   721  	i := len(dAtA)
   722  	_ = i
   723  	var l int
   724  	_ = l
   725  	if len(m.NonResourceURLs) > 0 {
   726  		for iNdEx := len(m.NonResourceURLs) - 1; iNdEx >= 0; iNdEx-- {
   727  			i -= len(m.NonResourceURLs[iNdEx])
   728  			copy(dAtA[i:], m.NonResourceURLs[iNdEx])
   729  			i = encodeVarintGenerated(dAtA, i, uint64(len(m.NonResourceURLs[iNdEx])))
   730  			i--
   731  			dAtA[i] = 0x32
   732  		}
   733  	}
   734  	if len(m.ResourceNames) > 0 {
   735  		for iNdEx := len(m.ResourceNames) - 1; iNdEx >= 0; iNdEx-- {
   736  			i -= len(m.ResourceNames[iNdEx])
   737  			copy(dAtA[i:], m.ResourceNames[iNdEx])
   738  			i = encodeVarintGenerated(dAtA, i, uint64(len(m.ResourceNames[iNdEx])))
   739  			i--
   740  			dAtA[i] = 0x2a
   741  		}
   742  	}
   743  	if len(m.Resources) > 0 {
   744  		for iNdEx := len(m.Resources) - 1; iNdEx >= 0; iNdEx-- {
   745  			i -= len(m.Resources[iNdEx])
   746  			copy(dAtA[i:], m.Resources[iNdEx])
   747  			i = encodeVarintGenerated(dAtA, i, uint64(len(m.Resources[iNdEx])))
   748  			i--
   749  			dAtA[i] = 0x22
   750  		}
   751  	}
   752  	if len(m.APIGroups) > 0 {
   753  		for iNdEx := len(m.APIGroups) - 1; iNdEx >= 0; iNdEx-- {
   754  			i -= len(m.APIGroups[iNdEx])
   755  			copy(dAtA[i:], m.APIGroups[iNdEx])
   756  			i = encodeVarintGenerated(dAtA, i, uint64(len(m.APIGroups[iNdEx])))
   757  			i--
   758  			dAtA[i] = 0x1a
   759  		}
   760  	}
   761  	if len(m.Verbs) > 0 {
   762  		for iNdEx := len(m.Verbs) - 1; iNdEx >= 0; iNdEx-- {
   763  			i -= len(m.Verbs[iNdEx])
   764  			copy(dAtA[i:], m.Verbs[iNdEx])
   765  			i = encodeVarintGenerated(dAtA, i, uint64(len(m.Verbs[iNdEx])))
   766  			i--
   767  			dAtA[i] = 0xa
   768  		}
   769  	}
   770  	return len(dAtA) - i, nil
   771  }
   772  
   773  func (m *Role) Marshal() (dAtA []byte, err error) {
   774  	size := m.Size()
   775  	dAtA = make([]byte, size)
   776  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   777  	if err != nil {
   778  		return nil, err
   779  	}
   780  	return dAtA[:n], nil
   781  }
   782  
   783  func (m *Role) MarshalTo(dAtA []byte) (int, error) {
   784  	size := m.Size()
   785  	return m.MarshalToSizedBuffer(dAtA[:size])
   786  }
   787  
   788  func (m *Role) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   789  	i := len(dAtA)
   790  	_ = i
   791  	var l int
   792  	_ = l
   793  	if len(m.Rules) > 0 {
   794  		for iNdEx := len(m.Rules) - 1; iNdEx >= 0; iNdEx-- {
   795  			{
   796  				size, err := m.Rules[iNdEx].MarshalToSizedBuffer(dAtA[:i])
   797  				if err != nil {
   798  					return 0, err
   799  				}
   800  				i -= size
   801  				i = encodeVarintGenerated(dAtA, i, uint64(size))
   802  			}
   803  			i--
   804  			dAtA[i] = 0x12
   805  		}
   806  	}
   807  	{
   808  		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
   809  		if err != nil {
   810  			return 0, err
   811  		}
   812  		i -= size
   813  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   814  	}
   815  	i--
   816  	dAtA[i] = 0xa
   817  	return len(dAtA) - i, nil
   818  }
   819  
   820  func (m *RoleBinding) Marshal() (dAtA []byte, err error) {
   821  	size := m.Size()
   822  	dAtA = make([]byte, size)
   823  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   824  	if err != nil {
   825  		return nil, err
   826  	}
   827  	return dAtA[:n], nil
   828  }
   829  
   830  func (m *RoleBinding) MarshalTo(dAtA []byte) (int, error) {
   831  	size := m.Size()
   832  	return m.MarshalToSizedBuffer(dAtA[:size])
   833  }
   834  
   835  func (m *RoleBinding) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   836  	i := len(dAtA)
   837  	_ = i
   838  	var l int
   839  	_ = l
   840  	{
   841  		size, err := m.RoleRef.MarshalToSizedBuffer(dAtA[:i])
   842  		if err != nil {
   843  			return 0, err
   844  		}
   845  		i -= size
   846  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   847  	}
   848  	i--
   849  	dAtA[i] = 0x1a
   850  	if len(m.Subjects) > 0 {
   851  		for iNdEx := len(m.Subjects) - 1; iNdEx >= 0; iNdEx-- {
   852  			{
   853  				size, err := m.Subjects[iNdEx].MarshalToSizedBuffer(dAtA[:i])
   854  				if err != nil {
   855  					return 0, err
   856  				}
   857  				i -= size
   858  				i = encodeVarintGenerated(dAtA, i, uint64(size))
   859  			}
   860  			i--
   861  			dAtA[i] = 0x12
   862  		}
   863  	}
   864  	{
   865  		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
   866  		if err != nil {
   867  			return 0, err
   868  		}
   869  		i -= size
   870  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   871  	}
   872  	i--
   873  	dAtA[i] = 0xa
   874  	return len(dAtA) - i, nil
   875  }
   876  
   877  func (m *RoleBindingList) Marshal() (dAtA []byte, err error) {
   878  	size := m.Size()
   879  	dAtA = make([]byte, size)
   880  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   881  	if err != nil {
   882  		return nil, err
   883  	}
   884  	return dAtA[:n], nil
   885  }
   886  
   887  func (m *RoleBindingList) MarshalTo(dAtA []byte) (int, error) {
   888  	size := m.Size()
   889  	return m.MarshalToSizedBuffer(dAtA[:size])
   890  }
   891  
   892  func (m *RoleBindingList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   893  	i := len(dAtA)
   894  	_ = i
   895  	var l int
   896  	_ = l
   897  	if len(m.Items) > 0 {
   898  		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
   899  			{
   900  				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
   901  				if err != nil {
   902  					return 0, err
   903  				}
   904  				i -= size
   905  				i = encodeVarintGenerated(dAtA, i, uint64(size))
   906  			}
   907  			i--
   908  			dAtA[i] = 0x12
   909  		}
   910  	}
   911  	{
   912  		size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
   913  		if err != nil {
   914  			return 0, err
   915  		}
   916  		i -= size
   917  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   918  	}
   919  	i--
   920  	dAtA[i] = 0xa
   921  	return len(dAtA) - i, nil
   922  }
   923  
   924  func (m *RoleList) Marshal() (dAtA []byte, err error) {
   925  	size := m.Size()
   926  	dAtA = make([]byte, size)
   927  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   928  	if err != nil {
   929  		return nil, err
   930  	}
   931  	return dAtA[:n], nil
   932  }
   933  
   934  func (m *RoleList) MarshalTo(dAtA []byte) (int, error) {
   935  	size := m.Size()
   936  	return m.MarshalToSizedBuffer(dAtA[:size])
   937  }
   938  
   939  func (m *RoleList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   940  	i := len(dAtA)
   941  	_ = i
   942  	var l int
   943  	_ = l
   944  	if len(m.Items) > 0 {
   945  		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
   946  			{
   947  				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
   948  				if err != nil {
   949  					return 0, err
   950  				}
   951  				i -= size
   952  				i = encodeVarintGenerated(dAtA, i, uint64(size))
   953  			}
   954  			i--
   955  			dAtA[i] = 0x12
   956  		}
   957  	}
   958  	{
   959  		size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
   960  		if err != nil {
   961  			return 0, err
   962  		}
   963  		i -= size
   964  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   965  	}
   966  	i--
   967  	dAtA[i] = 0xa
   968  	return len(dAtA) - i, nil
   969  }
   970  
   971  func (m *RoleRef) Marshal() (dAtA []byte, err error) {
   972  	size := m.Size()
   973  	dAtA = make([]byte, size)
   974  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   975  	if err != nil {
   976  		return nil, err
   977  	}
   978  	return dAtA[:n], nil
   979  }
   980  
   981  func (m *RoleRef) MarshalTo(dAtA []byte) (int, error) {
   982  	size := m.Size()
   983  	return m.MarshalToSizedBuffer(dAtA[:size])
   984  }
   985  
   986  func (m *RoleRef) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   987  	i := len(dAtA)
   988  	_ = i
   989  	var l int
   990  	_ = l
   991  	i -= len(m.Name)
   992  	copy(dAtA[i:], m.Name)
   993  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
   994  	i--
   995  	dAtA[i] = 0x1a
   996  	i -= len(m.Kind)
   997  	copy(dAtA[i:], m.Kind)
   998  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
   999  	i--
  1000  	dAtA[i] = 0x12
  1001  	i -= len(m.APIGroup)
  1002  	copy(dAtA[i:], m.APIGroup)
  1003  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.APIGroup)))
  1004  	i--
  1005  	dAtA[i] = 0xa
  1006  	return len(dAtA) - i, nil
  1007  }
  1008  
  1009  func (m *Subject) Marshal() (dAtA []byte, err error) {
  1010  	size := m.Size()
  1011  	dAtA = make([]byte, size)
  1012  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1013  	if err != nil {
  1014  		return nil, err
  1015  	}
  1016  	return dAtA[:n], nil
  1017  }
  1018  
  1019  func (m *Subject) MarshalTo(dAtA []byte) (int, error) {
  1020  	size := m.Size()
  1021  	return m.MarshalToSizedBuffer(dAtA[:size])
  1022  }
  1023  
  1024  func (m *Subject) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1025  	i := len(dAtA)
  1026  	_ = i
  1027  	var l int
  1028  	_ = l
  1029  	i -= len(m.Namespace)
  1030  	copy(dAtA[i:], m.Namespace)
  1031  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Namespace)))
  1032  	i--
  1033  	dAtA[i] = 0x22
  1034  	i -= len(m.Name)
  1035  	copy(dAtA[i:], m.Name)
  1036  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
  1037  	i--
  1038  	dAtA[i] = 0x1a
  1039  	i -= len(m.APIVersion)
  1040  	copy(dAtA[i:], m.APIVersion)
  1041  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.APIVersion)))
  1042  	i--
  1043  	dAtA[i] = 0x12
  1044  	i -= len(m.Kind)
  1045  	copy(dAtA[i:], m.Kind)
  1046  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
  1047  	i--
  1048  	dAtA[i] = 0xa
  1049  	return len(dAtA) - i, nil
  1050  }
  1051  
  1052  func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
  1053  	offset -= sovGenerated(v)
  1054  	base := offset
  1055  	for v >= 1<<7 {
  1056  		dAtA[offset] = uint8(v&0x7f | 0x80)
  1057  		v >>= 7
  1058  		offset++
  1059  	}
  1060  	dAtA[offset] = uint8(v)
  1061  	return base
  1062  }
  1063  func (m *AggregationRule) Size() (n int) {
  1064  	if m == nil {
  1065  		return 0
  1066  	}
  1067  	var l int
  1068  	_ = l
  1069  	if len(m.ClusterRoleSelectors) > 0 {
  1070  		for _, e := range m.ClusterRoleSelectors {
  1071  			l = e.Size()
  1072  			n += 1 + l + sovGenerated(uint64(l))
  1073  		}
  1074  	}
  1075  	return n
  1076  }
  1077  
  1078  func (m *ClusterRole) Size() (n int) {
  1079  	if m == nil {
  1080  		return 0
  1081  	}
  1082  	var l int
  1083  	_ = l
  1084  	l = m.ObjectMeta.Size()
  1085  	n += 1 + l + sovGenerated(uint64(l))
  1086  	if len(m.Rules) > 0 {
  1087  		for _, e := range m.Rules {
  1088  			l = e.Size()
  1089  			n += 1 + l + sovGenerated(uint64(l))
  1090  		}
  1091  	}
  1092  	if m.AggregationRule != nil {
  1093  		l = m.AggregationRule.Size()
  1094  		n += 1 + l + sovGenerated(uint64(l))
  1095  	}
  1096  	return n
  1097  }
  1098  
  1099  func (m *ClusterRoleBinding) Size() (n int) {
  1100  	if m == nil {
  1101  		return 0
  1102  	}
  1103  	var l int
  1104  	_ = l
  1105  	l = m.ObjectMeta.Size()
  1106  	n += 1 + l + sovGenerated(uint64(l))
  1107  	if len(m.Subjects) > 0 {
  1108  		for _, e := range m.Subjects {
  1109  			l = e.Size()
  1110  			n += 1 + l + sovGenerated(uint64(l))
  1111  		}
  1112  	}
  1113  	l = m.RoleRef.Size()
  1114  	n += 1 + l + sovGenerated(uint64(l))
  1115  	return n
  1116  }
  1117  
  1118  func (m *ClusterRoleBindingList) Size() (n int) {
  1119  	if m == nil {
  1120  		return 0
  1121  	}
  1122  	var l int
  1123  	_ = l
  1124  	l = m.ListMeta.Size()
  1125  	n += 1 + l + sovGenerated(uint64(l))
  1126  	if len(m.Items) > 0 {
  1127  		for _, e := range m.Items {
  1128  			l = e.Size()
  1129  			n += 1 + l + sovGenerated(uint64(l))
  1130  		}
  1131  	}
  1132  	return n
  1133  }
  1134  
  1135  func (m *ClusterRoleList) Size() (n int) {
  1136  	if m == nil {
  1137  		return 0
  1138  	}
  1139  	var l int
  1140  	_ = l
  1141  	l = m.ListMeta.Size()
  1142  	n += 1 + l + sovGenerated(uint64(l))
  1143  	if len(m.Items) > 0 {
  1144  		for _, e := range m.Items {
  1145  			l = e.Size()
  1146  			n += 1 + l + sovGenerated(uint64(l))
  1147  		}
  1148  	}
  1149  	return n
  1150  }
  1151  
  1152  func (m *PolicyRule) Size() (n int) {
  1153  	if m == nil {
  1154  		return 0
  1155  	}
  1156  	var l int
  1157  	_ = l
  1158  	if len(m.Verbs) > 0 {
  1159  		for _, s := range m.Verbs {
  1160  			l = len(s)
  1161  			n += 1 + l + sovGenerated(uint64(l))
  1162  		}
  1163  	}
  1164  	if len(m.APIGroups) > 0 {
  1165  		for _, s := range m.APIGroups {
  1166  			l = len(s)
  1167  			n += 1 + l + sovGenerated(uint64(l))
  1168  		}
  1169  	}
  1170  	if len(m.Resources) > 0 {
  1171  		for _, s := range m.Resources {
  1172  			l = len(s)
  1173  			n += 1 + l + sovGenerated(uint64(l))
  1174  		}
  1175  	}
  1176  	if len(m.ResourceNames) > 0 {
  1177  		for _, s := range m.ResourceNames {
  1178  			l = len(s)
  1179  			n += 1 + l + sovGenerated(uint64(l))
  1180  		}
  1181  	}
  1182  	if len(m.NonResourceURLs) > 0 {
  1183  		for _, s := range m.NonResourceURLs {
  1184  			l = len(s)
  1185  			n += 1 + l + sovGenerated(uint64(l))
  1186  		}
  1187  	}
  1188  	return n
  1189  }
  1190  
  1191  func (m *Role) Size() (n int) {
  1192  	if m == nil {
  1193  		return 0
  1194  	}
  1195  	var l int
  1196  	_ = l
  1197  	l = m.ObjectMeta.Size()
  1198  	n += 1 + l + sovGenerated(uint64(l))
  1199  	if len(m.Rules) > 0 {
  1200  		for _, e := range m.Rules {
  1201  			l = e.Size()
  1202  			n += 1 + l + sovGenerated(uint64(l))
  1203  		}
  1204  	}
  1205  	return n
  1206  }
  1207  
  1208  func (m *RoleBinding) Size() (n int) {
  1209  	if m == nil {
  1210  		return 0
  1211  	}
  1212  	var l int
  1213  	_ = l
  1214  	l = m.ObjectMeta.Size()
  1215  	n += 1 + l + sovGenerated(uint64(l))
  1216  	if len(m.Subjects) > 0 {
  1217  		for _, e := range m.Subjects {
  1218  			l = e.Size()
  1219  			n += 1 + l + sovGenerated(uint64(l))
  1220  		}
  1221  	}
  1222  	l = m.RoleRef.Size()
  1223  	n += 1 + l + sovGenerated(uint64(l))
  1224  	return n
  1225  }
  1226  
  1227  func (m *RoleBindingList) Size() (n int) {
  1228  	if m == nil {
  1229  		return 0
  1230  	}
  1231  	var l int
  1232  	_ = l
  1233  	l = m.ListMeta.Size()
  1234  	n += 1 + l + sovGenerated(uint64(l))
  1235  	if len(m.Items) > 0 {
  1236  		for _, e := range m.Items {
  1237  			l = e.Size()
  1238  			n += 1 + l + sovGenerated(uint64(l))
  1239  		}
  1240  	}
  1241  	return n
  1242  }
  1243  
  1244  func (m *RoleList) Size() (n int) {
  1245  	if m == nil {
  1246  		return 0
  1247  	}
  1248  	var l int
  1249  	_ = l
  1250  	l = m.ListMeta.Size()
  1251  	n += 1 + l + sovGenerated(uint64(l))
  1252  	if len(m.Items) > 0 {
  1253  		for _, e := range m.Items {
  1254  			l = e.Size()
  1255  			n += 1 + l + sovGenerated(uint64(l))
  1256  		}
  1257  	}
  1258  	return n
  1259  }
  1260  
  1261  func (m *RoleRef) Size() (n int) {
  1262  	if m == nil {
  1263  		return 0
  1264  	}
  1265  	var l int
  1266  	_ = l
  1267  	l = len(m.APIGroup)
  1268  	n += 1 + l + sovGenerated(uint64(l))
  1269  	l = len(m.Kind)
  1270  	n += 1 + l + sovGenerated(uint64(l))
  1271  	l = len(m.Name)
  1272  	n += 1 + l + sovGenerated(uint64(l))
  1273  	return n
  1274  }
  1275  
  1276  func (m *Subject) Size() (n int) {
  1277  	if m == nil {
  1278  		return 0
  1279  	}
  1280  	var l int
  1281  	_ = l
  1282  	l = len(m.Kind)
  1283  	n += 1 + l + sovGenerated(uint64(l))
  1284  	l = len(m.APIVersion)
  1285  	n += 1 + l + sovGenerated(uint64(l))
  1286  	l = len(m.Name)
  1287  	n += 1 + l + sovGenerated(uint64(l))
  1288  	l = len(m.Namespace)
  1289  	n += 1 + l + sovGenerated(uint64(l))
  1290  	return n
  1291  }
  1292  
  1293  func sovGenerated(x uint64) (n int) {
  1294  	return (math_bits.Len64(x|1) + 6) / 7
  1295  }
  1296  func sozGenerated(x uint64) (n int) {
  1297  	return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
  1298  }
  1299  func (this *AggregationRule) String() string {
  1300  	if this == nil {
  1301  		return "nil"
  1302  	}
  1303  	repeatedStringForClusterRoleSelectors := "[]LabelSelector{"
  1304  	for _, f := range this.ClusterRoleSelectors {
  1305  		repeatedStringForClusterRoleSelectors += fmt.Sprintf("%v", f) + ","
  1306  	}
  1307  	repeatedStringForClusterRoleSelectors += "}"
  1308  	s := strings.Join([]string{`&AggregationRule{`,
  1309  		`ClusterRoleSelectors:` + repeatedStringForClusterRoleSelectors + `,`,
  1310  		`}`,
  1311  	}, "")
  1312  	return s
  1313  }
  1314  func (this *ClusterRole) String() string {
  1315  	if this == nil {
  1316  		return "nil"
  1317  	}
  1318  	repeatedStringForRules := "[]PolicyRule{"
  1319  	for _, f := range this.Rules {
  1320  		repeatedStringForRules += strings.Replace(strings.Replace(f.String(), "PolicyRule", "PolicyRule", 1), `&`, ``, 1) + ","
  1321  	}
  1322  	repeatedStringForRules += "}"
  1323  	s := strings.Join([]string{`&ClusterRole{`,
  1324  		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
  1325  		`Rules:` + repeatedStringForRules + `,`,
  1326  		`AggregationRule:` + strings.Replace(this.AggregationRule.String(), "AggregationRule", "AggregationRule", 1) + `,`,
  1327  		`}`,
  1328  	}, "")
  1329  	return s
  1330  }
  1331  func (this *ClusterRoleBinding) String() string {
  1332  	if this == nil {
  1333  		return "nil"
  1334  	}
  1335  	repeatedStringForSubjects := "[]Subject{"
  1336  	for _, f := range this.Subjects {
  1337  		repeatedStringForSubjects += strings.Replace(strings.Replace(f.String(), "Subject", "Subject", 1), `&`, ``, 1) + ","
  1338  	}
  1339  	repeatedStringForSubjects += "}"
  1340  	s := strings.Join([]string{`&ClusterRoleBinding{`,
  1341  		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
  1342  		`Subjects:` + repeatedStringForSubjects + `,`,
  1343  		`RoleRef:` + strings.Replace(strings.Replace(this.RoleRef.String(), "RoleRef", "RoleRef", 1), `&`, ``, 1) + `,`,
  1344  		`}`,
  1345  	}, "")
  1346  	return s
  1347  }
  1348  func (this *ClusterRoleBindingList) String() string {
  1349  	if this == nil {
  1350  		return "nil"
  1351  	}
  1352  	repeatedStringForItems := "[]ClusterRoleBinding{"
  1353  	for _, f := range this.Items {
  1354  		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "ClusterRoleBinding", "ClusterRoleBinding", 1), `&`, ``, 1) + ","
  1355  	}
  1356  	repeatedStringForItems += "}"
  1357  	s := strings.Join([]string{`&ClusterRoleBindingList{`,
  1358  		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
  1359  		`Items:` + repeatedStringForItems + `,`,
  1360  		`}`,
  1361  	}, "")
  1362  	return s
  1363  }
  1364  func (this *ClusterRoleList) String() string {
  1365  	if this == nil {
  1366  		return "nil"
  1367  	}
  1368  	repeatedStringForItems := "[]ClusterRole{"
  1369  	for _, f := range this.Items {
  1370  		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "ClusterRole", "ClusterRole", 1), `&`, ``, 1) + ","
  1371  	}
  1372  	repeatedStringForItems += "}"
  1373  	s := strings.Join([]string{`&ClusterRoleList{`,
  1374  		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
  1375  		`Items:` + repeatedStringForItems + `,`,
  1376  		`}`,
  1377  	}, "")
  1378  	return s
  1379  }
  1380  func (this *PolicyRule) String() string {
  1381  	if this == nil {
  1382  		return "nil"
  1383  	}
  1384  	s := strings.Join([]string{`&PolicyRule{`,
  1385  		`Verbs:` + fmt.Sprintf("%v", this.Verbs) + `,`,
  1386  		`APIGroups:` + fmt.Sprintf("%v", this.APIGroups) + `,`,
  1387  		`Resources:` + fmt.Sprintf("%v", this.Resources) + `,`,
  1388  		`ResourceNames:` + fmt.Sprintf("%v", this.ResourceNames) + `,`,
  1389  		`NonResourceURLs:` + fmt.Sprintf("%v", this.NonResourceURLs) + `,`,
  1390  		`}`,
  1391  	}, "")
  1392  	return s
  1393  }
  1394  func (this *Role) String() string {
  1395  	if this == nil {
  1396  		return "nil"
  1397  	}
  1398  	repeatedStringForRules := "[]PolicyRule{"
  1399  	for _, f := range this.Rules {
  1400  		repeatedStringForRules += strings.Replace(strings.Replace(f.String(), "PolicyRule", "PolicyRule", 1), `&`, ``, 1) + ","
  1401  	}
  1402  	repeatedStringForRules += "}"
  1403  	s := strings.Join([]string{`&Role{`,
  1404  		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
  1405  		`Rules:` + repeatedStringForRules + `,`,
  1406  		`}`,
  1407  	}, "")
  1408  	return s
  1409  }
  1410  func (this *RoleBinding) String() string {
  1411  	if this == nil {
  1412  		return "nil"
  1413  	}
  1414  	repeatedStringForSubjects := "[]Subject{"
  1415  	for _, f := range this.Subjects {
  1416  		repeatedStringForSubjects += strings.Replace(strings.Replace(f.String(), "Subject", "Subject", 1), `&`, ``, 1) + ","
  1417  	}
  1418  	repeatedStringForSubjects += "}"
  1419  	s := strings.Join([]string{`&RoleBinding{`,
  1420  		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
  1421  		`Subjects:` + repeatedStringForSubjects + `,`,
  1422  		`RoleRef:` + strings.Replace(strings.Replace(this.RoleRef.String(), "RoleRef", "RoleRef", 1), `&`, ``, 1) + `,`,
  1423  		`}`,
  1424  	}, "")
  1425  	return s
  1426  }
  1427  func (this *RoleBindingList) String() string {
  1428  	if this == nil {
  1429  		return "nil"
  1430  	}
  1431  	repeatedStringForItems := "[]RoleBinding{"
  1432  	for _, f := range this.Items {
  1433  		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "RoleBinding", "RoleBinding", 1), `&`, ``, 1) + ","
  1434  	}
  1435  	repeatedStringForItems += "}"
  1436  	s := strings.Join([]string{`&RoleBindingList{`,
  1437  		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
  1438  		`Items:` + repeatedStringForItems + `,`,
  1439  		`}`,
  1440  	}, "")
  1441  	return s
  1442  }
  1443  func (this *RoleList) String() string {
  1444  	if this == nil {
  1445  		return "nil"
  1446  	}
  1447  	repeatedStringForItems := "[]Role{"
  1448  	for _, f := range this.Items {
  1449  		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "Role", "Role", 1), `&`, ``, 1) + ","
  1450  	}
  1451  	repeatedStringForItems += "}"
  1452  	s := strings.Join([]string{`&RoleList{`,
  1453  		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
  1454  		`Items:` + repeatedStringForItems + `,`,
  1455  		`}`,
  1456  	}, "")
  1457  	return s
  1458  }
  1459  func (this *RoleRef) String() string {
  1460  	if this == nil {
  1461  		return "nil"
  1462  	}
  1463  	s := strings.Join([]string{`&RoleRef{`,
  1464  		`APIGroup:` + fmt.Sprintf("%v", this.APIGroup) + `,`,
  1465  		`Kind:` + fmt.Sprintf("%v", this.Kind) + `,`,
  1466  		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
  1467  		`}`,
  1468  	}, "")
  1469  	return s
  1470  }
  1471  func (this *Subject) String() string {
  1472  	if this == nil {
  1473  		return "nil"
  1474  	}
  1475  	s := strings.Join([]string{`&Subject{`,
  1476  		`Kind:` + fmt.Sprintf("%v", this.Kind) + `,`,
  1477  		`APIVersion:` + fmt.Sprintf("%v", this.APIVersion) + `,`,
  1478  		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
  1479  		`Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`,
  1480  		`}`,
  1481  	}, "")
  1482  	return s
  1483  }
  1484  func valueToStringGenerated(v interface{}) string {
  1485  	rv := reflect.ValueOf(v)
  1486  	if rv.IsNil() {
  1487  		return "nil"
  1488  	}
  1489  	pv := reflect.Indirect(rv).Interface()
  1490  	return fmt.Sprintf("*%v", pv)
  1491  }
  1492  func (m *AggregationRule) Unmarshal(dAtA []byte) error {
  1493  	l := len(dAtA)
  1494  	iNdEx := 0
  1495  	for iNdEx < l {
  1496  		preIndex := iNdEx
  1497  		var wire uint64
  1498  		for shift := uint(0); ; shift += 7 {
  1499  			if shift >= 64 {
  1500  				return ErrIntOverflowGenerated
  1501  			}
  1502  			if iNdEx >= l {
  1503  				return io.ErrUnexpectedEOF
  1504  			}
  1505  			b := dAtA[iNdEx]
  1506  			iNdEx++
  1507  			wire |= uint64(b&0x7F) << shift
  1508  			if b < 0x80 {
  1509  				break
  1510  			}
  1511  		}
  1512  		fieldNum := int32(wire >> 3)
  1513  		wireType := int(wire & 0x7)
  1514  		if wireType == 4 {
  1515  			return fmt.Errorf("proto: AggregationRule: wiretype end group for non-group")
  1516  		}
  1517  		if fieldNum <= 0 {
  1518  			return fmt.Errorf("proto: AggregationRule: illegal tag %d (wire type %d)", fieldNum, wire)
  1519  		}
  1520  		switch fieldNum {
  1521  		case 1:
  1522  			if wireType != 2 {
  1523  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterRoleSelectors", wireType)
  1524  			}
  1525  			var msglen int
  1526  			for shift := uint(0); ; shift += 7 {
  1527  				if shift >= 64 {
  1528  					return ErrIntOverflowGenerated
  1529  				}
  1530  				if iNdEx >= l {
  1531  					return io.ErrUnexpectedEOF
  1532  				}
  1533  				b := dAtA[iNdEx]
  1534  				iNdEx++
  1535  				msglen |= int(b&0x7F) << shift
  1536  				if b < 0x80 {
  1537  					break
  1538  				}
  1539  			}
  1540  			if msglen < 0 {
  1541  				return ErrInvalidLengthGenerated
  1542  			}
  1543  			postIndex := iNdEx + msglen
  1544  			if postIndex < 0 {
  1545  				return ErrInvalidLengthGenerated
  1546  			}
  1547  			if postIndex > l {
  1548  				return io.ErrUnexpectedEOF
  1549  			}
  1550  			m.ClusterRoleSelectors = append(m.ClusterRoleSelectors, v1.LabelSelector{})
  1551  			if err := m.ClusterRoleSelectors[len(m.ClusterRoleSelectors)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1552  				return err
  1553  			}
  1554  			iNdEx = postIndex
  1555  		default:
  1556  			iNdEx = preIndex
  1557  			skippy, err := skipGenerated(dAtA[iNdEx:])
  1558  			if err != nil {
  1559  				return err
  1560  			}
  1561  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1562  				return ErrInvalidLengthGenerated
  1563  			}
  1564  			if (iNdEx + skippy) > l {
  1565  				return io.ErrUnexpectedEOF
  1566  			}
  1567  			iNdEx += skippy
  1568  		}
  1569  	}
  1570  
  1571  	if iNdEx > l {
  1572  		return io.ErrUnexpectedEOF
  1573  	}
  1574  	return nil
  1575  }
  1576  func (m *ClusterRole) Unmarshal(dAtA []byte) error {
  1577  	l := len(dAtA)
  1578  	iNdEx := 0
  1579  	for iNdEx < l {
  1580  		preIndex := iNdEx
  1581  		var wire uint64
  1582  		for shift := uint(0); ; shift += 7 {
  1583  			if shift >= 64 {
  1584  				return ErrIntOverflowGenerated
  1585  			}
  1586  			if iNdEx >= l {
  1587  				return io.ErrUnexpectedEOF
  1588  			}
  1589  			b := dAtA[iNdEx]
  1590  			iNdEx++
  1591  			wire |= uint64(b&0x7F) << shift
  1592  			if b < 0x80 {
  1593  				break
  1594  			}
  1595  		}
  1596  		fieldNum := int32(wire >> 3)
  1597  		wireType := int(wire & 0x7)
  1598  		if wireType == 4 {
  1599  			return fmt.Errorf("proto: ClusterRole: wiretype end group for non-group")
  1600  		}
  1601  		if fieldNum <= 0 {
  1602  			return fmt.Errorf("proto: ClusterRole: illegal tag %d (wire type %d)", fieldNum, wire)
  1603  		}
  1604  		switch fieldNum {
  1605  		case 1:
  1606  			if wireType != 2 {
  1607  				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
  1608  			}
  1609  			var msglen int
  1610  			for shift := uint(0); ; shift += 7 {
  1611  				if shift >= 64 {
  1612  					return ErrIntOverflowGenerated
  1613  				}
  1614  				if iNdEx >= l {
  1615  					return io.ErrUnexpectedEOF
  1616  				}
  1617  				b := dAtA[iNdEx]
  1618  				iNdEx++
  1619  				msglen |= int(b&0x7F) << shift
  1620  				if b < 0x80 {
  1621  					break
  1622  				}
  1623  			}
  1624  			if msglen < 0 {
  1625  				return ErrInvalidLengthGenerated
  1626  			}
  1627  			postIndex := iNdEx + msglen
  1628  			if postIndex < 0 {
  1629  				return ErrInvalidLengthGenerated
  1630  			}
  1631  			if postIndex > l {
  1632  				return io.ErrUnexpectedEOF
  1633  			}
  1634  			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1635  				return err
  1636  			}
  1637  			iNdEx = postIndex
  1638  		case 2:
  1639  			if wireType != 2 {
  1640  				return fmt.Errorf("proto: wrong wireType = %d for field Rules", wireType)
  1641  			}
  1642  			var msglen int
  1643  			for shift := uint(0); ; shift += 7 {
  1644  				if shift >= 64 {
  1645  					return ErrIntOverflowGenerated
  1646  				}
  1647  				if iNdEx >= l {
  1648  					return io.ErrUnexpectedEOF
  1649  				}
  1650  				b := dAtA[iNdEx]
  1651  				iNdEx++
  1652  				msglen |= int(b&0x7F) << shift
  1653  				if b < 0x80 {
  1654  					break
  1655  				}
  1656  			}
  1657  			if msglen < 0 {
  1658  				return ErrInvalidLengthGenerated
  1659  			}
  1660  			postIndex := iNdEx + msglen
  1661  			if postIndex < 0 {
  1662  				return ErrInvalidLengthGenerated
  1663  			}
  1664  			if postIndex > l {
  1665  				return io.ErrUnexpectedEOF
  1666  			}
  1667  			m.Rules = append(m.Rules, PolicyRule{})
  1668  			if err := m.Rules[len(m.Rules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1669  				return err
  1670  			}
  1671  			iNdEx = postIndex
  1672  		case 3:
  1673  			if wireType != 2 {
  1674  				return fmt.Errorf("proto: wrong wireType = %d for field AggregationRule", wireType)
  1675  			}
  1676  			var msglen int
  1677  			for shift := uint(0); ; shift += 7 {
  1678  				if shift >= 64 {
  1679  					return ErrIntOverflowGenerated
  1680  				}
  1681  				if iNdEx >= l {
  1682  					return io.ErrUnexpectedEOF
  1683  				}
  1684  				b := dAtA[iNdEx]
  1685  				iNdEx++
  1686  				msglen |= int(b&0x7F) << shift
  1687  				if b < 0x80 {
  1688  					break
  1689  				}
  1690  			}
  1691  			if msglen < 0 {
  1692  				return ErrInvalidLengthGenerated
  1693  			}
  1694  			postIndex := iNdEx + msglen
  1695  			if postIndex < 0 {
  1696  				return ErrInvalidLengthGenerated
  1697  			}
  1698  			if postIndex > l {
  1699  				return io.ErrUnexpectedEOF
  1700  			}
  1701  			if m.AggregationRule == nil {
  1702  				m.AggregationRule = &AggregationRule{}
  1703  			}
  1704  			if err := m.AggregationRule.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1705  				return err
  1706  			}
  1707  			iNdEx = postIndex
  1708  		default:
  1709  			iNdEx = preIndex
  1710  			skippy, err := skipGenerated(dAtA[iNdEx:])
  1711  			if err != nil {
  1712  				return err
  1713  			}
  1714  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1715  				return ErrInvalidLengthGenerated
  1716  			}
  1717  			if (iNdEx + skippy) > l {
  1718  				return io.ErrUnexpectedEOF
  1719  			}
  1720  			iNdEx += skippy
  1721  		}
  1722  	}
  1723  
  1724  	if iNdEx > l {
  1725  		return io.ErrUnexpectedEOF
  1726  	}
  1727  	return nil
  1728  }
  1729  func (m *ClusterRoleBinding) Unmarshal(dAtA []byte) error {
  1730  	l := len(dAtA)
  1731  	iNdEx := 0
  1732  	for iNdEx < l {
  1733  		preIndex := iNdEx
  1734  		var wire uint64
  1735  		for shift := uint(0); ; shift += 7 {
  1736  			if shift >= 64 {
  1737  				return ErrIntOverflowGenerated
  1738  			}
  1739  			if iNdEx >= l {
  1740  				return io.ErrUnexpectedEOF
  1741  			}
  1742  			b := dAtA[iNdEx]
  1743  			iNdEx++
  1744  			wire |= uint64(b&0x7F) << shift
  1745  			if b < 0x80 {
  1746  				break
  1747  			}
  1748  		}
  1749  		fieldNum := int32(wire >> 3)
  1750  		wireType := int(wire & 0x7)
  1751  		if wireType == 4 {
  1752  			return fmt.Errorf("proto: ClusterRoleBinding: wiretype end group for non-group")
  1753  		}
  1754  		if fieldNum <= 0 {
  1755  			return fmt.Errorf("proto: ClusterRoleBinding: illegal tag %d (wire type %d)", fieldNum, wire)
  1756  		}
  1757  		switch fieldNum {
  1758  		case 1:
  1759  			if wireType != 2 {
  1760  				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
  1761  			}
  1762  			var msglen int
  1763  			for shift := uint(0); ; shift += 7 {
  1764  				if shift >= 64 {
  1765  					return ErrIntOverflowGenerated
  1766  				}
  1767  				if iNdEx >= l {
  1768  					return io.ErrUnexpectedEOF
  1769  				}
  1770  				b := dAtA[iNdEx]
  1771  				iNdEx++
  1772  				msglen |= int(b&0x7F) << shift
  1773  				if b < 0x80 {
  1774  					break
  1775  				}
  1776  			}
  1777  			if msglen < 0 {
  1778  				return ErrInvalidLengthGenerated
  1779  			}
  1780  			postIndex := iNdEx + msglen
  1781  			if postIndex < 0 {
  1782  				return ErrInvalidLengthGenerated
  1783  			}
  1784  			if postIndex > l {
  1785  				return io.ErrUnexpectedEOF
  1786  			}
  1787  			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1788  				return err
  1789  			}
  1790  			iNdEx = postIndex
  1791  		case 2:
  1792  			if wireType != 2 {
  1793  				return fmt.Errorf("proto: wrong wireType = %d for field Subjects", wireType)
  1794  			}
  1795  			var msglen int
  1796  			for shift := uint(0); ; shift += 7 {
  1797  				if shift >= 64 {
  1798  					return ErrIntOverflowGenerated
  1799  				}
  1800  				if iNdEx >= l {
  1801  					return io.ErrUnexpectedEOF
  1802  				}
  1803  				b := dAtA[iNdEx]
  1804  				iNdEx++
  1805  				msglen |= int(b&0x7F) << shift
  1806  				if b < 0x80 {
  1807  					break
  1808  				}
  1809  			}
  1810  			if msglen < 0 {
  1811  				return ErrInvalidLengthGenerated
  1812  			}
  1813  			postIndex := iNdEx + msglen
  1814  			if postIndex < 0 {
  1815  				return ErrInvalidLengthGenerated
  1816  			}
  1817  			if postIndex > l {
  1818  				return io.ErrUnexpectedEOF
  1819  			}
  1820  			m.Subjects = append(m.Subjects, Subject{})
  1821  			if err := m.Subjects[len(m.Subjects)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1822  				return err
  1823  			}
  1824  			iNdEx = postIndex
  1825  		case 3:
  1826  			if wireType != 2 {
  1827  				return fmt.Errorf("proto: wrong wireType = %d for field RoleRef", wireType)
  1828  			}
  1829  			var msglen int
  1830  			for shift := uint(0); ; shift += 7 {
  1831  				if shift >= 64 {
  1832  					return ErrIntOverflowGenerated
  1833  				}
  1834  				if iNdEx >= l {
  1835  					return io.ErrUnexpectedEOF
  1836  				}
  1837  				b := dAtA[iNdEx]
  1838  				iNdEx++
  1839  				msglen |= int(b&0x7F) << shift
  1840  				if b < 0x80 {
  1841  					break
  1842  				}
  1843  			}
  1844  			if msglen < 0 {
  1845  				return ErrInvalidLengthGenerated
  1846  			}
  1847  			postIndex := iNdEx + msglen
  1848  			if postIndex < 0 {
  1849  				return ErrInvalidLengthGenerated
  1850  			}
  1851  			if postIndex > l {
  1852  				return io.ErrUnexpectedEOF
  1853  			}
  1854  			if err := m.RoleRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1855  				return err
  1856  			}
  1857  			iNdEx = postIndex
  1858  		default:
  1859  			iNdEx = preIndex
  1860  			skippy, err := skipGenerated(dAtA[iNdEx:])
  1861  			if err != nil {
  1862  				return err
  1863  			}
  1864  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1865  				return ErrInvalidLengthGenerated
  1866  			}
  1867  			if (iNdEx + skippy) > l {
  1868  				return io.ErrUnexpectedEOF
  1869  			}
  1870  			iNdEx += skippy
  1871  		}
  1872  	}
  1873  
  1874  	if iNdEx > l {
  1875  		return io.ErrUnexpectedEOF
  1876  	}
  1877  	return nil
  1878  }
  1879  func (m *ClusterRoleBindingList) Unmarshal(dAtA []byte) error {
  1880  	l := len(dAtA)
  1881  	iNdEx := 0
  1882  	for iNdEx < l {
  1883  		preIndex := iNdEx
  1884  		var wire uint64
  1885  		for shift := uint(0); ; shift += 7 {
  1886  			if shift >= 64 {
  1887  				return ErrIntOverflowGenerated
  1888  			}
  1889  			if iNdEx >= l {
  1890  				return io.ErrUnexpectedEOF
  1891  			}
  1892  			b := dAtA[iNdEx]
  1893  			iNdEx++
  1894  			wire |= uint64(b&0x7F) << shift
  1895  			if b < 0x80 {
  1896  				break
  1897  			}
  1898  		}
  1899  		fieldNum := int32(wire >> 3)
  1900  		wireType := int(wire & 0x7)
  1901  		if wireType == 4 {
  1902  			return fmt.Errorf("proto: ClusterRoleBindingList: wiretype end group for non-group")
  1903  		}
  1904  		if fieldNum <= 0 {
  1905  			return fmt.Errorf("proto: ClusterRoleBindingList: illegal tag %d (wire type %d)", fieldNum, wire)
  1906  		}
  1907  		switch fieldNum {
  1908  		case 1:
  1909  			if wireType != 2 {
  1910  				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
  1911  			}
  1912  			var msglen int
  1913  			for shift := uint(0); ; shift += 7 {
  1914  				if shift >= 64 {
  1915  					return ErrIntOverflowGenerated
  1916  				}
  1917  				if iNdEx >= l {
  1918  					return io.ErrUnexpectedEOF
  1919  				}
  1920  				b := dAtA[iNdEx]
  1921  				iNdEx++
  1922  				msglen |= int(b&0x7F) << shift
  1923  				if b < 0x80 {
  1924  					break
  1925  				}
  1926  			}
  1927  			if msglen < 0 {
  1928  				return ErrInvalidLengthGenerated
  1929  			}
  1930  			postIndex := iNdEx + msglen
  1931  			if postIndex < 0 {
  1932  				return ErrInvalidLengthGenerated
  1933  			}
  1934  			if postIndex > l {
  1935  				return io.ErrUnexpectedEOF
  1936  			}
  1937  			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1938  				return err
  1939  			}
  1940  			iNdEx = postIndex
  1941  		case 2:
  1942  			if wireType != 2 {
  1943  				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
  1944  			}
  1945  			var msglen int
  1946  			for shift := uint(0); ; shift += 7 {
  1947  				if shift >= 64 {
  1948  					return ErrIntOverflowGenerated
  1949  				}
  1950  				if iNdEx >= l {
  1951  					return io.ErrUnexpectedEOF
  1952  				}
  1953  				b := dAtA[iNdEx]
  1954  				iNdEx++
  1955  				msglen |= int(b&0x7F) << shift
  1956  				if b < 0x80 {
  1957  					break
  1958  				}
  1959  			}
  1960  			if msglen < 0 {
  1961  				return ErrInvalidLengthGenerated
  1962  			}
  1963  			postIndex := iNdEx + msglen
  1964  			if postIndex < 0 {
  1965  				return ErrInvalidLengthGenerated
  1966  			}
  1967  			if postIndex > l {
  1968  				return io.ErrUnexpectedEOF
  1969  			}
  1970  			m.Items = append(m.Items, ClusterRoleBinding{})
  1971  			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1972  				return err
  1973  			}
  1974  			iNdEx = postIndex
  1975  		default:
  1976  			iNdEx = preIndex
  1977  			skippy, err := skipGenerated(dAtA[iNdEx:])
  1978  			if err != nil {
  1979  				return err
  1980  			}
  1981  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1982  				return ErrInvalidLengthGenerated
  1983  			}
  1984  			if (iNdEx + skippy) > l {
  1985  				return io.ErrUnexpectedEOF
  1986  			}
  1987  			iNdEx += skippy
  1988  		}
  1989  	}
  1990  
  1991  	if iNdEx > l {
  1992  		return io.ErrUnexpectedEOF
  1993  	}
  1994  	return nil
  1995  }
  1996  func (m *ClusterRoleList) Unmarshal(dAtA []byte) error {
  1997  	l := len(dAtA)
  1998  	iNdEx := 0
  1999  	for iNdEx < l {
  2000  		preIndex := iNdEx
  2001  		var wire uint64
  2002  		for shift := uint(0); ; shift += 7 {
  2003  			if shift >= 64 {
  2004  				return ErrIntOverflowGenerated
  2005  			}
  2006  			if iNdEx >= l {
  2007  				return io.ErrUnexpectedEOF
  2008  			}
  2009  			b := dAtA[iNdEx]
  2010  			iNdEx++
  2011  			wire |= uint64(b&0x7F) << shift
  2012  			if b < 0x80 {
  2013  				break
  2014  			}
  2015  		}
  2016  		fieldNum := int32(wire >> 3)
  2017  		wireType := int(wire & 0x7)
  2018  		if wireType == 4 {
  2019  			return fmt.Errorf("proto: ClusterRoleList: wiretype end group for non-group")
  2020  		}
  2021  		if fieldNum <= 0 {
  2022  			return fmt.Errorf("proto: ClusterRoleList: illegal tag %d (wire type %d)", fieldNum, wire)
  2023  		}
  2024  		switch fieldNum {
  2025  		case 1:
  2026  			if wireType != 2 {
  2027  				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
  2028  			}
  2029  			var msglen int
  2030  			for shift := uint(0); ; shift += 7 {
  2031  				if shift >= 64 {
  2032  					return ErrIntOverflowGenerated
  2033  				}
  2034  				if iNdEx >= l {
  2035  					return io.ErrUnexpectedEOF
  2036  				}
  2037  				b := dAtA[iNdEx]
  2038  				iNdEx++
  2039  				msglen |= int(b&0x7F) << shift
  2040  				if b < 0x80 {
  2041  					break
  2042  				}
  2043  			}
  2044  			if msglen < 0 {
  2045  				return ErrInvalidLengthGenerated
  2046  			}
  2047  			postIndex := iNdEx + msglen
  2048  			if postIndex < 0 {
  2049  				return ErrInvalidLengthGenerated
  2050  			}
  2051  			if postIndex > l {
  2052  				return io.ErrUnexpectedEOF
  2053  			}
  2054  			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2055  				return err
  2056  			}
  2057  			iNdEx = postIndex
  2058  		case 2:
  2059  			if wireType != 2 {
  2060  				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
  2061  			}
  2062  			var msglen int
  2063  			for shift := uint(0); ; shift += 7 {
  2064  				if shift >= 64 {
  2065  					return ErrIntOverflowGenerated
  2066  				}
  2067  				if iNdEx >= l {
  2068  					return io.ErrUnexpectedEOF
  2069  				}
  2070  				b := dAtA[iNdEx]
  2071  				iNdEx++
  2072  				msglen |= int(b&0x7F) << shift
  2073  				if b < 0x80 {
  2074  					break
  2075  				}
  2076  			}
  2077  			if msglen < 0 {
  2078  				return ErrInvalidLengthGenerated
  2079  			}
  2080  			postIndex := iNdEx + msglen
  2081  			if postIndex < 0 {
  2082  				return ErrInvalidLengthGenerated
  2083  			}
  2084  			if postIndex > l {
  2085  				return io.ErrUnexpectedEOF
  2086  			}
  2087  			m.Items = append(m.Items, ClusterRole{})
  2088  			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2089  				return err
  2090  			}
  2091  			iNdEx = postIndex
  2092  		default:
  2093  			iNdEx = preIndex
  2094  			skippy, err := skipGenerated(dAtA[iNdEx:])
  2095  			if err != nil {
  2096  				return err
  2097  			}
  2098  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2099  				return ErrInvalidLengthGenerated
  2100  			}
  2101  			if (iNdEx + skippy) > l {
  2102  				return io.ErrUnexpectedEOF
  2103  			}
  2104  			iNdEx += skippy
  2105  		}
  2106  	}
  2107  
  2108  	if iNdEx > l {
  2109  		return io.ErrUnexpectedEOF
  2110  	}
  2111  	return nil
  2112  }
  2113  func (m *PolicyRule) Unmarshal(dAtA []byte) error {
  2114  	l := len(dAtA)
  2115  	iNdEx := 0
  2116  	for iNdEx < l {
  2117  		preIndex := iNdEx
  2118  		var wire uint64
  2119  		for shift := uint(0); ; shift += 7 {
  2120  			if shift >= 64 {
  2121  				return ErrIntOverflowGenerated
  2122  			}
  2123  			if iNdEx >= l {
  2124  				return io.ErrUnexpectedEOF
  2125  			}
  2126  			b := dAtA[iNdEx]
  2127  			iNdEx++
  2128  			wire |= uint64(b&0x7F) << shift
  2129  			if b < 0x80 {
  2130  				break
  2131  			}
  2132  		}
  2133  		fieldNum := int32(wire >> 3)
  2134  		wireType := int(wire & 0x7)
  2135  		if wireType == 4 {
  2136  			return fmt.Errorf("proto: PolicyRule: wiretype end group for non-group")
  2137  		}
  2138  		if fieldNum <= 0 {
  2139  			return fmt.Errorf("proto: PolicyRule: illegal tag %d (wire type %d)", fieldNum, wire)
  2140  		}
  2141  		switch fieldNum {
  2142  		case 1:
  2143  			if wireType != 2 {
  2144  				return fmt.Errorf("proto: wrong wireType = %d for field Verbs", wireType)
  2145  			}
  2146  			var stringLen uint64
  2147  			for shift := uint(0); ; shift += 7 {
  2148  				if shift >= 64 {
  2149  					return ErrIntOverflowGenerated
  2150  				}
  2151  				if iNdEx >= l {
  2152  					return io.ErrUnexpectedEOF
  2153  				}
  2154  				b := dAtA[iNdEx]
  2155  				iNdEx++
  2156  				stringLen |= uint64(b&0x7F) << shift
  2157  				if b < 0x80 {
  2158  					break
  2159  				}
  2160  			}
  2161  			intStringLen := int(stringLen)
  2162  			if intStringLen < 0 {
  2163  				return ErrInvalidLengthGenerated
  2164  			}
  2165  			postIndex := iNdEx + intStringLen
  2166  			if postIndex < 0 {
  2167  				return ErrInvalidLengthGenerated
  2168  			}
  2169  			if postIndex > l {
  2170  				return io.ErrUnexpectedEOF
  2171  			}
  2172  			m.Verbs = append(m.Verbs, string(dAtA[iNdEx:postIndex]))
  2173  			iNdEx = postIndex
  2174  		case 3:
  2175  			if wireType != 2 {
  2176  				return fmt.Errorf("proto: wrong wireType = %d for field APIGroups", wireType)
  2177  			}
  2178  			var stringLen uint64
  2179  			for shift := uint(0); ; shift += 7 {
  2180  				if shift >= 64 {
  2181  					return ErrIntOverflowGenerated
  2182  				}
  2183  				if iNdEx >= l {
  2184  					return io.ErrUnexpectedEOF
  2185  				}
  2186  				b := dAtA[iNdEx]
  2187  				iNdEx++
  2188  				stringLen |= uint64(b&0x7F) << shift
  2189  				if b < 0x80 {
  2190  					break
  2191  				}
  2192  			}
  2193  			intStringLen := int(stringLen)
  2194  			if intStringLen < 0 {
  2195  				return ErrInvalidLengthGenerated
  2196  			}
  2197  			postIndex := iNdEx + intStringLen
  2198  			if postIndex < 0 {
  2199  				return ErrInvalidLengthGenerated
  2200  			}
  2201  			if postIndex > l {
  2202  				return io.ErrUnexpectedEOF
  2203  			}
  2204  			m.APIGroups = append(m.APIGroups, string(dAtA[iNdEx:postIndex]))
  2205  			iNdEx = postIndex
  2206  		case 4:
  2207  			if wireType != 2 {
  2208  				return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType)
  2209  			}
  2210  			var stringLen uint64
  2211  			for shift := uint(0); ; shift += 7 {
  2212  				if shift >= 64 {
  2213  					return ErrIntOverflowGenerated
  2214  				}
  2215  				if iNdEx >= l {
  2216  					return io.ErrUnexpectedEOF
  2217  				}
  2218  				b := dAtA[iNdEx]
  2219  				iNdEx++
  2220  				stringLen |= uint64(b&0x7F) << shift
  2221  				if b < 0x80 {
  2222  					break
  2223  				}
  2224  			}
  2225  			intStringLen := int(stringLen)
  2226  			if intStringLen < 0 {
  2227  				return ErrInvalidLengthGenerated
  2228  			}
  2229  			postIndex := iNdEx + intStringLen
  2230  			if postIndex < 0 {
  2231  				return ErrInvalidLengthGenerated
  2232  			}
  2233  			if postIndex > l {
  2234  				return io.ErrUnexpectedEOF
  2235  			}
  2236  			m.Resources = append(m.Resources, string(dAtA[iNdEx:postIndex]))
  2237  			iNdEx = postIndex
  2238  		case 5:
  2239  			if wireType != 2 {
  2240  				return fmt.Errorf("proto: wrong wireType = %d for field ResourceNames", wireType)
  2241  			}
  2242  			var stringLen uint64
  2243  			for shift := uint(0); ; shift += 7 {
  2244  				if shift >= 64 {
  2245  					return ErrIntOverflowGenerated
  2246  				}
  2247  				if iNdEx >= l {
  2248  					return io.ErrUnexpectedEOF
  2249  				}
  2250  				b := dAtA[iNdEx]
  2251  				iNdEx++
  2252  				stringLen |= uint64(b&0x7F) << shift
  2253  				if b < 0x80 {
  2254  					break
  2255  				}
  2256  			}
  2257  			intStringLen := int(stringLen)
  2258  			if intStringLen < 0 {
  2259  				return ErrInvalidLengthGenerated
  2260  			}
  2261  			postIndex := iNdEx + intStringLen
  2262  			if postIndex < 0 {
  2263  				return ErrInvalidLengthGenerated
  2264  			}
  2265  			if postIndex > l {
  2266  				return io.ErrUnexpectedEOF
  2267  			}
  2268  			m.ResourceNames = append(m.ResourceNames, string(dAtA[iNdEx:postIndex]))
  2269  			iNdEx = postIndex
  2270  		case 6:
  2271  			if wireType != 2 {
  2272  				return fmt.Errorf("proto: wrong wireType = %d for field NonResourceURLs", wireType)
  2273  			}
  2274  			var stringLen uint64
  2275  			for shift := uint(0); ; shift += 7 {
  2276  				if shift >= 64 {
  2277  					return ErrIntOverflowGenerated
  2278  				}
  2279  				if iNdEx >= l {
  2280  					return io.ErrUnexpectedEOF
  2281  				}
  2282  				b := dAtA[iNdEx]
  2283  				iNdEx++
  2284  				stringLen |= uint64(b&0x7F) << shift
  2285  				if b < 0x80 {
  2286  					break
  2287  				}
  2288  			}
  2289  			intStringLen := int(stringLen)
  2290  			if intStringLen < 0 {
  2291  				return ErrInvalidLengthGenerated
  2292  			}
  2293  			postIndex := iNdEx + intStringLen
  2294  			if postIndex < 0 {
  2295  				return ErrInvalidLengthGenerated
  2296  			}
  2297  			if postIndex > l {
  2298  				return io.ErrUnexpectedEOF
  2299  			}
  2300  			m.NonResourceURLs = append(m.NonResourceURLs, string(dAtA[iNdEx:postIndex]))
  2301  			iNdEx = postIndex
  2302  		default:
  2303  			iNdEx = preIndex
  2304  			skippy, err := skipGenerated(dAtA[iNdEx:])
  2305  			if err != nil {
  2306  				return err
  2307  			}
  2308  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2309  				return ErrInvalidLengthGenerated
  2310  			}
  2311  			if (iNdEx + skippy) > l {
  2312  				return io.ErrUnexpectedEOF
  2313  			}
  2314  			iNdEx += skippy
  2315  		}
  2316  	}
  2317  
  2318  	if iNdEx > l {
  2319  		return io.ErrUnexpectedEOF
  2320  	}
  2321  	return nil
  2322  }
  2323  func (m *Role) Unmarshal(dAtA []byte) error {
  2324  	l := len(dAtA)
  2325  	iNdEx := 0
  2326  	for iNdEx < l {
  2327  		preIndex := iNdEx
  2328  		var wire uint64
  2329  		for shift := uint(0); ; shift += 7 {
  2330  			if shift >= 64 {
  2331  				return ErrIntOverflowGenerated
  2332  			}
  2333  			if iNdEx >= l {
  2334  				return io.ErrUnexpectedEOF
  2335  			}
  2336  			b := dAtA[iNdEx]
  2337  			iNdEx++
  2338  			wire |= uint64(b&0x7F) << shift
  2339  			if b < 0x80 {
  2340  				break
  2341  			}
  2342  		}
  2343  		fieldNum := int32(wire >> 3)
  2344  		wireType := int(wire & 0x7)
  2345  		if wireType == 4 {
  2346  			return fmt.Errorf("proto: Role: wiretype end group for non-group")
  2347  		}
  2348  		if fieldNum <= 0 {
  2349  			return fmt.Errorf("proto: Role: illegal tag %d (wire type %d)", fieldNum, wire)
  2350  		}
  2351  		switch fieldNum {
  2352  		case 1:
  2353  			if wireType != 2 {
  2354  				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
  2355  			}
  2356  			var msglen int
  2357  			for shift := uint(0); ; shift += 7 {
  2358  				if shift >= 64 {
  2359  					return ErrIntOverflowGenerated
  2360  				}
  2361  				if iNdEx >= l {
  2362  					return io.ErrUnexpectedEOF
  2363  				}
  2364  				b := dAtA[iNdEx]
  2365  				iNdEx++
  2366  				msglen |= int(b&0x7F) << shift
  2367  				if b < 0x80 {
  2368  					break
  2369  				}
  2370  			}
  2371  			if msglen < 0 {
  2372  				return ErrInvalidLengthGenerated
  2373  			}
  2374  			postIndex := iNdEx + msglen
  2375  			if postIndex < 0 {
  2376  				return ErrInvalidLengthGenerated
  2377  			}
  2378  			if postIndex > l {
  2379  				return io.ErrUnexpectedEOF
  2380  			}
  2381  			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2382  				return err
  2383  			}
  2384  			iNdEx = postIndex
  2385  		case 2:
  2386  			if wireType != 2 {
  2387  				return fmt.Errorf("proto: wrong wireType = %d for field Rules", wireType)
  2388  			}
  2389  			var msglen int
  2390  			for shift := uint(0); ; shift += 7 {
  2391  				if shift >= 64 {
  2392  					return ErrIntOverflowGenerated
  2393  				}
  2394  				if iNdEx >= l {
  2395  					return io.ErrUnexpectedEOF
  2396  				}
  2397  				b := dAtA[iNdEx]
  2398  				iNdEx++
  2399  				msglen |= int(b&0x7F) << shift
  2400  				if b < 0x80 {
  2401  					break
  2402  				}
  2403  			}
  2404  			if msglen < 0 {
  2405  				return ErrInvalidLengthGenerated
  2406  			}
  2407  			postIndex := iNdEx + msglen
  2408  			if postIndex < 0 {
  2409  				return ErrInvalidLengthGenerated
  2410  			}
  2411  			if postIndex > l {
  2412  				return io.ErrUnexpectedEOF
  2413  			}
  2414  			m.Rules = append(m.Rules, PolicyRule{})
  2415  			if err := m.Rules[len(m.Rules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2416  				return err
  2417  			}
  2418  			iNdEx = postIndex
  2419  		default:
  2420  			iNdEx = preIndex
  2421  			skippy, err := skipGenerated(dAtA[iNdEx:])
  2422  			if err != nil {
  2423  				return err
  2424  			}
  2425  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2426  				return ErrInvalidLengthGenerated
  2427  			}
  2428  			if (iNdEx + skippy) > l {
  2429  				return io.ErrUnexpectedEOF
  2430  			}
  2431  			iNdEx += skippy
  2432  		}
  2433  	}
  2434  
  2435  	if iNdEx > l {
  2436  		return io.ErrUnexpectedEOF
  2437  	}
  2438  	return nil
  2439  }
  2440  func (m *RoleBinding) Unmarshal(dAtA []byte) error {
  2441  	l := len(dAtA)
  2442  	iNdEx := 0
  2443  	for iNdEx < l {
  2444  		preIndex := iNdEx
  2445  		var wire uint64
  2446  		for shift := uint(0); ; shift += 7 {
  2447  			if shift >= 64 {
  2448  				return ErrIntOverflowGenerated
  2449  			}
  2450  			if iNdEx >= l {
  2451  				return io.ErrUnexpectedEOF
  2452  			}
  2453  			b := dAtA[iNdEx]
  2454  			iNdEx++
  2455  			wire |= uint64(b&0x7F) << shift
  2456  			if b < 0x80 {
  2457  				break
  2458  			}
  2459  		}
  2460  		fieldNum := int32(wire >> 3)
  2461  		wireType := int(wire & 0x7)
  2462  		if wireType == 4 {
  2463  			return fmt.Errorf("proto: RoleBinding: wiretype end group for non-group")
  2464  		}
  2465  		if fieldNum <= 0 {
  2466  			return fmt.Errorf("proto: RoleBinding: illegal tag %d (wire type %d)", fieldNum, wire)
  2467  		}
  2468  		switch fieldNum {
  2469  		case 1:
  2470  			if wireType != 2 {
  2471  				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
  2472  			}
  2473  			var msglen int
  2474  			for shift := uint(0); ; shift += 7 {
  2475  				if shift >= 64 {
  2476  					return ErrIntOverflowGenerated
  2477  				}
  2478  				if iNdEx >= l {
  2479  					return io.ErrUnexpectedEOF
  2480  				}
  2481  				b := dAtA[iNdEx]
  2482  				iNdEx++
  2483  				msglen |= int(b&0x7F) << shift
  2484  				if b < 0x80 {
  2485  					break
  2486  				}
  2487  			}
  2488  			if msglen < 0 {
  2489  				return ErrInvalidLengthGenerated
  2490  			}
  2491  			postIndex := iNdEx + msglen
  2492  			if postIndex < 0 {
  2493  				return ErrInvalidLengthGenerated
  2494  			}
  2495  			if postIndex > l {
  2496  				return io.ErrUnexpectedEOF
  2497  			}
  2498  			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2499  				return err
  2500  			}
  2501  			iNdEx = postIndex
  2502  		case 2:
  2503  			if wireType != 2 {
  2504  				return fmt.Errorf("proto: wrong wireType = %d for field Subjects", wireType)
  2505  			}
  2506  			var msglen int
  2507  			for shift := uint(0); ; shift += 7 {
  2508  				if shift >= 64 {
  2509  					return ErrIntOverflowGenerated
  2510  				}
  2511  				if iNdEx >= l {
  2512  					return io.ErrUnexpectedEOF
  2513  				}
  2514  				b := dAtA[iNdEx]
  2515  				iNdEx++
  2516  				msglen |= int(b&0x7F) << shift
  2517  				if b < 0x80 {
  2518  					break
  2519  				}
  2520  			}
  2521  			if msglen < 0 {
  2522  				return ErrInvalidLengthGenerated
  2523  			}
  2524  			postIndex := iNdEx + msglen
  2525  			if postIndex < 0 {
  2526  				return ErrInvalidLengthGenerated
  2527  			}
  2528  			if postIndex > l {
  2529  				return io.ErrUnexpectedEOF
  2530  			}
  2531  			m.Subjects = append(m.Subjects, Subject{})
  2532  			if err := m.Subjects[len(m.Subjects)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2533  				return err
  2534  			}
  2535  			iNdEx = postIndex
  2536  		case 3:
  2537  			if wireType != 2 {
  2538  				return fmt.Errorf("proto: wrong wireType = %d for field RoleRef", wireType)
  2539  			}
  2540  			var msglen int
  2541  			for shift := uint(0); ; shift += 7 {
  2542  				if shift >= 64 {
  2543  					return ErrIntOverflowGenerated
  2544  				}
  2545  				if iNdEx >= l {
  2546  					return io.ErrUnexpectedEOF
  2547  				}
  2548  				b := dAtA[iNdEx]
  2549  				iNdEx++
  2550  				msglen |= int(b&0x7F) << shift
  2551  				if b < 0x80 {
  2552  					break
  2553  				}
  2554  			}
  2555  			if msglen < 0 {
  2556  				return ErrInvalidLengthGenerated
  2557  			}
  2558  			postIndex := iNdEx + msglen
  2559  			if postIndex < 0 {
  2560  				return ErrInvalidLengthGenerated
  2561  			}
  2562  			if postIndex > l {
  2563  				return io.ErrUnexpectedEOF
  2564  			}
  2565  			if err := m.RoleRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2566  				return err
  2567  			}
  2568  			iNdEx = postIndex
  2569  		default:
  2570  			iNdEx = preIndex
  2571  			skippy, err := skipGenerated(dAtA[iNdEx:])
  2572  			if err != nil {
  2573  				return err
  2574  			}
  2575  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2576  				return ErrInvalidLengthGenerated
  2577  			}
  2578  			if (iNdEx + skippy) > l {
  2579  				return io.ErrUnexpectedEOF
  2580  			}
  2581  			iNdEx += skippy
  2582  		}
  2583  	}
  2584  
  2585  	if iNdEx > l {
  2586  		return io.ErrUnexpectedEOF
  2587  	}
  2588  	return nil
  2589  }
  2590  func (m *RoleBindingList) Unmarshal(dAtA []byte) error {
  2591  	l := len(dAtA)
  2592  	iNdEx := 0
  2593  	for iNdEx < l {
  2594  		preIndex := iNdEx
  2595  		var wire uint64
  2596  		for shift := uint(0); ; shift += 7 {
  2597  			if shift >= 64 {
  2598  				return ErrIntOverflowGenerated
  2599  			}
  2600  			if iNdEx >= l {
  2601  				return io.ErrUnexpectedEOF
  2602  			}
  2603  			b := dAtA[iNdEx]
  2604  			iNdEx++
  2605  			wire |= uint64(b&0x7F) << shift
  2606  			if b < 0x80 {
  2607  				break
  2608  			}
  2609  		}
  2610  		fieldNum := int32(wire >> 3)
  2611  		wireType := int(wire & 0x7)
  2612  		if wireType == 4 {
  2613  			return fmt.Errorf("proto: RoleBindingList: wiretype end group for non-group")
  2614  		}
  2615  		if fieldNum <= 0 {
  2616  			return fmt.Errorf("proto: RoleBindingList: illegal tag %d (wire type %d)", fieldNum, wire)
  2617  		}
  2618  		switch fieldNum {
  2619  		case 1:
  2620  			if wireType != 2 {
  2621  				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
  2622  			}
  2623  			var msglen int
  2624  			for shift := uint(0); ; shift += 7 {
  2625  				if shift >= 64 {
  2626  					return ErrIntOverflowGenerated
  2627  				}
  2628  				if iNdEx >= l {
  2629  					return io.ErrUnexpectedEOF
  2630  				}
  2631  				b := dAtA[iNdEx]
  2632  				iNdEx++
  2633  				msglen |= int(b&0x7F) << shift
  2634  				if b < 0x80 {
  2635  					break
  2636  				}
  2637  			}
  2638  			if msglen < 0 {
  2639  				return ErrInvalidLengthGenerated
  2640  			}
  2641  			postIndex := iNdEx + msglen
  2642  			if postIndex < 0 {
  2643  				return ErrInvalidLengthGenerated
  2644  			}
  2645  			if postIndex > l {
  2646  				return io.ErrUnexpectedEOF
  2647  			}
  2648  			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2649  				return err
  2650  			}
  2651  			iNdEx = postIndex
  2652  		case 2:
  2653  			if wireType != 2 {
  2654  				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
  2655  			}
  2656  			var msglen int
  2657  			for shift := uint(0); ; shift += 7 {
  2658  				if shift >= 64 {
  2659  					return ErrIntOverflowGenerated
  2660  				}
  2661  				if iNdEx >= l {
  2662  					return io.ErrUnexpectedEOF
  2663  				}
  2664  				b := dAtA[iNdEx]
  2665  				iNdEx++
  2666  				msglen |= int(b&0x7F) << shift
  2667  				if b < 0x80 {
  2668  					break
  2669  				}
  2670  			}
  2671  			if msglen < 0 {
  2672  				return ErrInvalidLengthGenerated
  2673  			}
  2674  			postIndex := iNdEx + msglen
  2675  			if postIndex < 0 {
  2676  				return ErrInvalidLengthGenerated
  2677  			}
  2678  			if postIndex > l {
  2679  				return io.ErrUnexpectedEOF
  2680  			}
  2681  			m.Items = append(m.Items, RoleBinding{})
  2682  			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2683  				return err
  2684  			}
  2685  			iNdEx = postIndex
  2686  		default:
  2687  			iNdEx = preIndex
  2688  			skippy, err := skipGenerated(dAtA[iNdEx:])
  2689  			if err != nil {
  2690  				return err
  2691  			}
  2692  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2693  				return ErrInvalidLengthGenerated
  2694  			}
  2695  			if (iNdEx + skippy) > l {
  2696  				return io.ErrUnexpectedEOF
  2697  			}
  2698  			iNdEx += skippy
  2699  		}
  2700  	}
  2701  
  2702  	if iNdEx > l {
  2703  		return io.ErrUnexpectedEOF
  2704  	}
  2705  	return nil
  2706  }
  2707  func (m *RoleList) Unmarshal(dAtA []byte) error {
  2708  	l := len(dAtA)
  2709  	iNdEx := 0
  2710  	for iNdEx < l {
  2711  		preIndex := iNdEx
  2712  		var wire uint64
  2713  		for shift := uint(0); ; shift += 7 {
  2714  			if shift >= 64 {
  2715  				return ErrIntOverflowGenerated
  2716  			}
  2717  			if iNdEx >= l {
  2718  				return io.ErrUnexpectedEOF
  2719  			}
  2720  			b := dAtA[iNdEx]
  2721  			iNdEx++
  2722  			wire |= uint64(b&0x7F) << shift
  2723  			if b < 0x80 {
  2724  				break
  2725  			}
  2726  		}
  2727  		fieldNum := int32(wire >> 3)
  2728  		wireType := int(wire & 0x7)
  2729  		if wireType == 4 {
  2730  			return fmt.Errorf("proto: RoleList: wiretype end group for non-group")
  2731  		}
  2732  		if fieldNum <= 0 {
  2733  			return fmt.Errorf("proto: RoleList: illegal tag %d (wire type %d)", fieldNum, wire)
  2734  		}
  2735  		switch fieldNum {
  2736  		case 1:
  2737  			if wireType != 2 {
  2738  				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
  2739  			}
  2740  			var msglen int
  2741  			for shift := uint(0); ; shift += 7 {
  2742  				if shift >= 64 {
  2743  					return ErrIntOverflowGenerated
  2744  				}
  2745  				if iNdEx >= l {
  2746  					return io.ErrUnexpectedEOF
  2747  				}
  2748  				b := dAtA[iNdEx]
  2749  				iNdEx++
  2750  				msglen |= int(b&0x7F) << shift
  2751  				if b < 0x80 {
  2752  					break
  2753  				}
  2754  			}
  2755  			if msglen < 0 {
  2756  				return ErrInvalidLengthGenerated
  2757  			}
  2758  			postIndex := iNdEx + msglen
  2759  			if postIndex < 0 {
  2760  				return ErrInvalidLengthGenerated
  2761  			}
  2762  			if postIndex > l {
  2763  				return io.ErrUnexpectedEOF
  2764  			}
  2765  			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2766  				return err
  2767  			}
  2768  			iNdEx = postIndex
  2769  		case 2:
  2770  			if wireType != 2 {
  2771  				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
  2772  			}
  2773  			var msglen int
  2774  			for shift := uint(0); ; shift += 7 {
  2775  				if shift >= 64 {
  2776  					return ErrIntOverflowGenerated
  2777  				}
  2778  				if iNdEx >= l {
  2779  					return io.ErrUnexpectedEOF
  2780  				}
  2781  				b := dAtA[iNdEx]
  2782  				iNdEx++
  2783  				msglen |= int(b&0x7F) << shift
  2784  				if b < 0x80 {
  2785  					break
  2786  				}
  2787  			}
  2788  			if msglen < 0 {
  2789  				return ErrInvalidLengthGenerated
  2790  			}
  2791  			postIndex := iNdEx + msglen
  2792  			if postIndex < 0 {
  2793  				return ErrInvalidLengthGenerated
  2794  			}
  2795  			if postIndex > l {
  2796  				return io.ErrUnexpectedEOF
  2797  			}
  2798  			m.Items = append(m.Items, Role{})
  2799  			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2800  				return err
  2801  			}
  2802  			iNdEx = postIndex
  2803  		default:
  2804  			iNdEx = preIndex
  2805  			skippy, err := skipGenerated(dAtA[iNdEx:])
  2806  			if err != nil {
  2807  				return err
  2808  			}
  2809  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2810  				return ErrInvalidLengthGenerated
  2811  			}
  2812  			if (iNdEx + skippy) > l {
  2813  				return io.ErrUnexpectedEOF
  2814  			}
  2815  			iNdEx += skippy
  2816  		}
  2817  	}
  2818  
  2819  	if iNdEx > l {
  2820  		return io.ErrUnexpectedEOF
  2821  	}
  2822  	return nil
  2823  }
  2824  func (m *RoleRef) Unmarshal(dAtA []byte) error {
  2825  	l := len(dAtA)
  2826  	iNdEx := 0
  2827  	for iNdEx < l {
  2828  		preIndex := iNdEx
  2829  		var wire uint64
  2830  		for shift := uint(0); ; shift += 7 {
  2831  			if shift >= 64 {
  2832  				return ErrIntOverflowGenerated
  2833  			}
  2834  			if iNdEx >= l {
  2835  				return io.ErrUnexpectedEOF
  2836  			}
  2837  			b := dAtA[iNdEx]
  2838  			iNdEx++
  2839  			wire |= uint64(b&0x7F) << shift
  2840  			if b < 0x80 {
  2841  				break
  2842  			}
  2843  		}
  2844  		fieldNum := int32(wire >> 3)
  2845  		wireType := int(wire & 0x7)
  2846  		if wireType == 4 {
  2847  			return fmt.Errorf("proto: RoleRef: wiretype end group for non-group")
  2848  		}
  2849  		if fieldNum <= 0 {
  2850  			return fmt.Errorf("proto: RoleRef: illegal tag %d (wire type %d)", fieldNum, wire)
  2851  		}
  2852  		switch fieldNum {
  2853  		case 1:
  2854  			if wireType != 2 {
  2855  				return fmt.Errorf("proto: wrong wireType = %d for field APIGroup", wireType)
  2856  			}
  2857  			var stringLen uint64
  2858  			for shift := uint(0); ; shift += 7 {
  2859  				if shift >= 64 {
  2860  					return ErrIntOverflowGenerated
  2861  				}
  2862  				if iNdEx >= l {
  2863  					return io.ErrUnexpectedEOF
  2864  				}
  2865  				b := dAtA[iNdEx]
  2866  				iNdEx++
  2867  				stringLen |= uint64(b&0x7F) << shift
  2868  				if b < 0x80 {
  2869  					break
  2870  				}
  2871  			}
  2872  			intStringLen := int(stringLen)
  2873  			if intStringLen < 0 {
  2874  				return ErrInvalidLengthGenerated
  2875  			}
  2876  			postIndex := iNdEx + intStringLen
  2877  			if postIndex < 0 {
  2878  				return ErrInvalidLengthGenerated
  2879  			}
  2880  			if postIndex > l {
  2881  				return io.ErrUnexpectedEOF
  2882  			}
  2883  			m.APIGroup = string(dAtA[iNdEx:postIndex])
  2884  			iNdEx = postIndex
  2885  		case 2:
  2886  			if wireType != 2 {
  2887  				return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
  2888  			}
  2889  			var stringLen uint64
  2890  			for shift := uint(0); ; shift += 7 {
  2891  				if shift >= 64 {
  2892  					return ErrIntOverflowGenerated
  2893  				}
  2894  				if iNdEx >= l {
  2895  					return io.ErrUnexpectedEOF
  2896  				}
  2897  				b := dAtA[iNdEx]
  2898  				iNdEx++
  2899  				stringLen |= uint64(b&0x7F) << shift
  2900  				if b < 0x80 {
  2901  					break
  2902  				}
  2903  			}
  2904  			intStringLen := int(stringLen)
  2905  			if intStringLen < 0 {
  2906  				return ErrInvalidLengthGenerated
  2907  			}
  2908  			postIndex := iNdEx + intStringLen
  2909  			if postIndex < 0 {
  2910  				return ErrInvalidLengthGenerated
  2911  			}
  2912  			if postIndex > l {
  2913  				return io.ErrUnexpectedEOF
  2914  			}
  2915  			m.Kind = string(dAtA[iNdEx:postIndex])
  2916  			iNdEx = postIndex
  2917  		case 3:
  2918  			if wireType != 2 {
  2919  				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
  2920  			}
  2921  			var stringLen uint64
  2922  			for shift := uint(0); ; shift += 7 {
  2923  				if shift >= 64 {
  2924  					return ErrIntOverflowGenerated
  2925  				}
  2926  				if iNdEx >= l {
  2927  					return io.ErrUnexpectedEOF
  2928  				}
  2929  				b := dAtA[iNdEx]
  2930  				iNdEx++
  2931  				stringLen |= uint64(b&0x7F) << shift
  2932  				if b < 0x80 {
  2933  					break
  2934  				}
  2935  			}
  2936  			intStringLen := int(stringLen)
  2937  			if intStringLen < 0 {
  2938  				return ErrInvalidLengthGenerated
  2939  			}
  2940  			postIndex := iNdEx + intStringLen
  2941  			if postIndex < 0 {
  2942  				return ErrInvalidLengthGenerated
  2943  			}
  2944  			if postIndex > l {
  2945  				return io.ErrUnexpectedEOF
  2946  			}
  2947  			m.Name = string(dAtA[iNdEx:postIndex])
  2948  			iNdEx = postIndex
  2949  		default:
  2950  			iNdEx = preIndex
  2951  			skippy, err := skipGenerated(dAtA[iNdEx:])
  2952  			if err != nil {
  2953  				return err
  2954  			}
  2955  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2956  				return ErrInvalidLengthGenerated
  2957  			}
  2958  			if (iNdEx + skippy) > l {
  2959  				return io.ErrUnexpectedEOF
  2960  			}
  2961  			iNdEx += skippy
  2962  		}
  2963  	}
  2964  
  2965  	if iNdEx > l {
  2966  		return io.ErrUnexpectedEOF
  2967  	}
  2968  	return nil
  2969  }
  2970  func (m *Subject) Unmarshal(dAtA []byte) error {
  2971  	l := len(dAtA)
  2972  	iNdEx := 0
  2973  	for iNdEx < l {
  2974  		preIndex := iNdEx
  2975  		var wire uint64
  2976  		for shift := uint(0); ; shift += 7 {
  2977  			if shift >= 64 {
  2978  				return ErrIntOverflowGenerated
  2979  			}
  2980  			if iNdEx >= l {
  2981  				return io.ErrUnexpectedEOF
  2982  			}
  2983  			b := dAtA[iNdEx]
  2984  			iNdEx++
  2985  			wire |= uint64(b&0x7F) << shift
  2986  			if b < 0x80 {
  2987  				break
  2988  			}
  2989  		}
  2990  		fieldNum := int32(wire >> 3)
  2991  		wireType := int(wire & 0x7)
  2992  		if wireType == 4 {
  2993  			return fmt.Errorf("proto: Subject: wiretype end group for non-group")
  2994  		}
  2995  		if fieldNum <= 0 {
  2996  			return fmt.Errorf("proto: Subject: illegal tag %d (wire type %d)", fieldNum, wire)
  2997  		}
  2998  		switch fieldNum {
  2999  		case 1:
  3000  			if wireType != 2 {
  3001  				return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
  3002  			}
  3003  			var stringLen uint64
  3004  			for shift := uint(0); ; shift += 7 {
  3005  				if shift >= 64 {
  3006  					return ErrIntOverflowGenerated
  3007  				}
  3008  				if iNdEx >= l {
  3009  					return io.ErrUnexpectedEOF
  3010  				}
  3011  				b := dAtA[iNdEx]
  3012  				iNdEx++
  3013  				stringLen |= uint64(b&0x7F) << shift
  3014  				if b < 0x80 {
  3015  					break
  3016  				}
  3017  			}
  3018  			intStringLen := int(stringLen)
  3019  			if intStringLen < 0 {
  3020  				return ErrInvalidLengthGenerated
  3021  			}
  3022  			postIndex := iNdEx + intStringLen
  3023  			if postIndex < 0 {
  3024  				return ErrInvalidLengthGenerated
  3025  			}
  3026  			if postIndex > l {
  3027  				return io.ErrUnexpectedEOF
  3028  			}
  3029  			m.Kind = string(dAtA[iNdEx:postIndex])
  3030  			iNdEx = postIndex
  3031  		case 2:
  3032  			if wireType != 2 {
  3033  				return fmt.Errorf("proto: wrong wireType = %d for field APIVersion", wireType)
  3034  			}
  3035  			var stringLen uint64
  3036  			for shift := uint(0); ; shift += 7 {
  3037  				if shift >= 64 {
  3038  					return ErrIntOverflowGenerated
  3039  				}
  3040  				if iNdEx >= l {
  3041  					return io.ErrUnexpectedEOF
  3042  				}
  3043  				b := dAtA[iNdEx]
  3044  				iNdEx++
  3045  				stringLen |= uint64(b&0x7F) << shift
  3046  				if b < 0x80 {
  3047  					break
  3048  				}
  3049  			}
  3050  			intStringLen := int(stringLen)
  3051  			if intStringLen < 0 {
  3052  				return ErrInvalidLengthGenerated
  3053  			}
  3054  			postIndex := iNdEx + intStringLen
  3055  			if postIndex < 0 {
  3056  				return ErrInvalidLengthGenerated
  3057  			}
  3058  			if postIndex > l {
  3059  				return io.ErrUnexpectedEOF
  3060  			}
  3061  			m.APIVersion = string(dAtA[iNdEx:postIndex])
  3062  			iNdEx = postIndex
  3063  		case 3:
  3064  			if wireType != 2 {
  3065  				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
  3066  			}
  3067  			var stringLen uint64
  3068  			for shift := uint(0); ; shift += 7 {
  3069  				if shift >= 64 {
  3070  					return ErrIntOverflowGenerated
  3071  				}
  3072  				if iNdEx >= l {
  3073  					return io.ErrUnexpectedEOF
  3074  				}
  3075  				b := dAtA[iNdEx]
  3076  				iNdEx++
  3077  				stringLen |= uint64(b&0x7F) << shift
  3078  				if b < 0x80 {
  3079  					break
  3080  				}
  3081  			}
  3082  			intStringLen := int(stringLen)
  3083  			if intStringLen < 0 {
  3084  				return ErrInvalidLengthGenerated
  3085  			}
  3086  			postIndex := iNdEx + intStringLen
  3087  			if postIndex < 0 {
  3088  				return ErrInvalidLengthGenerated
  3089  			}
  3090  			if postIndex > l {
  3091  				return io.ErrUnexpectedEOF
  3092  			}
  3093  			m.Name = string(dAtA[iNdEx:postIndex])
  3094  			iNdEx = postIndex
  3095  		case 4:
  3096  			if wireType != 2 {
  3097  				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
  3098  			}
  3099  			var stringLen uint64
  3100  			for shift := uint(0); ; shift += 7 {
  3101  				if shift >= 64 {
  3102  					return ErrIntOverflowGenerated
  3103  				}
  3104  				if iNdEx >= l {
  3105  					return io.ErrUnexpectedEOF
  3106  				}
  3107  				b := dAtA[iNdEx]
  3108  				iNdEx++
  3109  				stringLen |= uint64(b&0x7F) << shift
  3110  				if b < 0x80 {
  3111  					break
  3112  				}
  3113  			}
  3114  			intStringLen := int(stringLen)
  3115  			if intStringLen < 0 {
  3116  				return ErrInvalidLengthGenerated
  3117  			}
  3118  			postIndex := iNdEx + intStringLen
  3119  			if postIndex < 0 {
  3120  				return ErrInvalidLengthGenerated
  3121  			}
  3122  			if postIndex > l {
  3123  				return io.ErrUnexpectedEOF
  3124  			}
  3125  			m.Namespace = string(dAtA[iNdEx:postIndex])
  3126  			iNdEx = postIndex
  3127  		default:
  3128  			iNdEx = preIndex
  3129  			skippy, err := skipGenerated(dAtA[iNdEx:])
  3130  			if err != nil {
  3131  				return err
  3132  			}
  3133  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  3134  				return ErrInvalidLengthGenerated
  3135  			}
  3136  			if (iNdEx + skippy) > l {
  3137  				return io.ErrUnexpectedEOF
  3138  			}
  3139  			iNdEx += skippy
  3140  		}
  3141  	}
  3142  
  3143  	if iNdEx > l {
  3144  		return io.ErrUnexpectedEOF
  3145  	}
  3146  	return nil
  3147  }
  3148  func skipGenerated(dAtA []byte) (n int, err error) {
  3149  	l := len(dAtA)
  3150  	iNdEx := 0
  3151  	depth := 0
  3152  	for iNdEx < l {
  3153  		var wire uint64
  3154  		for shift := uint(0); ; shift += 7 {
  3155  			if shift >= 64 {
  3156  				return 0, ErrIntOverflowGenerated
  3157  			}
  3158  			if iNdEx >= l {
  3159  				return 0, io.ErrUnexpectedEOF
  3160  			}
  3161  			b := dAtA[iNdEx]
  3162  			iNdEx++
  3163  			wire |= (uint64(b) & 0x7F) << shift
  3164  			if b < 0x80 {
  3165  				break
  3166  			}
  3167  		}
  3168  		wireType := int(wire & 0x7)
  3169  		switch wireType {
  3170  		case 0:
  3171  			for shift := uint(0); ; shift += 7 {
  3172  				if shift >= 64 {
  3173  					return 0, ErrIntOverflowGenerated
  3174  				}
  3175  				if iNdEx >= l {
  3176  					return 0, io.ErrUnexpectedEOF
  3177  				}
  3178  				iNdEx++
  3179  				if dAtA[iNdEx-1] < 0x80 {
  3180  					break
  3181  				}
  3182  			}
  3183  		case 1:
  3184  			iNdEx += 8
  3185  		case 2:
  3186  			var length int
  3187  			for shift := uint(0); ; shift += 7 {
  3188  				if shift >= 64 {
  3189  					return 0, ErrIntOverflowGenerated
  3190  				}
  3191  				if iNdEx >= l {
  3192  					return 0, io.ErrUnexpectedEOF
  3193  				}
  3194  				b := dAtA[iNdEx]
  3195  				iNdEx++
  3196  				length |= (int(b) & 0x7F) << shift
  3197  				if b < 0x80 {
  3198  					break
  3199  				}
  3200  			}
  3201  			if length < 0 {
  3202  				return 0, ErrInvalidLengthGenerated
  3203  			}
  3204  			iNdEx += length
  3205  		case 3:
  3206  			depth++
  3207  		case 4:
  3208  			if depth == 0 {
  3209  				return 0, ErrUnexpectedEndOfGroupGenerated
  3210  			}
  3211  			depth--
  3212  		case 5:
  3213  			iNdEx += 4
  3214  		default:
  3215  			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
  3216  		}
  3217  		if iNdEx < 0 {
  3218  			return 0, ErrInvalidLengthGenerated
  3219  		}
  3220  		if depth == 0 {
  3221  			return iNdEx, nil
  3222  		}
  3223  	}
  3224  	return 0, io.ErrUnexpectedEOF
  3225  }
  3226  
  3227  var (
  3228  	ErrInvalidLengthGenerated        = fmt.Errorf("proto: negative length found during unmarshaling")
  3229  	ErrIntOverflowGenerated          = fmt.Errorf("proto: integer overflow")
  3230  	ErrUnexpectedEndOfGroupGenerated = fmt.Errorf("proto: unexpected end of group")
  3231  )
  3232  

View as plain text