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

Documentation: k8s.io/api/rbac/v1

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

View as plain text