Source file src/k8s.io/api/networking/v1beta1/generated.pb.go

Documentation: k8s.io/api/networking/v1beta1

     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/networking/v1beta1/generated.proto
    19  
    20  package v1beta1
    21  
    22  import (
    23  	fmt "fmt"
    24  
    25  	io "io"
    26  
    27  	proto "github.com/gogo/protobuf/proto"
    28  	k8s_io_api_core_v1 "k8s.io/api/core/v1"
    29  	v11 "k8s.io/api/core/v1"
    30  
    31  	math "math"
    32  	math_bits "math/bits"
    33  	reflect "reflect"
    34  	strings "strings"
    35  )
    36  
    37  // Reference imports to suppress errors if they are not otherwise used.
    38  var _ = proto.Marshal
    39  var _ = fmt.Errorf
    40  var _ = math.Inf
    41  
    42  // This is a compile-time assertion to ensure that this generated file
    43  // is compatible with the proto package it is being compiled against.
    44  // A compilation error at this line likely means your copy of the
    45  // proto package needs to be updated.
    46  const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
    47  
    48  func (m *HTTPIngressPath) Reset()      { *m = HTTPIngressPath{} }
    49  func (*HTTPIngressPath) ProtoMessage() {}
    50  func (*HTTPIngressPath) Descriptor() ([]byte, []int) {
    51  	return fileDescriptor_9497719c79c89d2d, []int{0}
    52  }
    53  func (m *HTTPIngressPath) XXX_Unmarshal(b []byte) error {
    54  	return m.Unmarshal(b)
    55  }
    56  func (m *HTTPIngressPath) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    57  	b = b[:cap(b)]
    58  	n, err := m.MarshalToSizedBuffer(b)
    59  	if err != nil {
    60  		return nil, err
    61  	}
    62  	return b[:n], nil
    63  }
    64  func (m *HTTPIngressPath) XXX_Merge(src proto.Message) {
    65  	xxx_messageInfo_HTTPIngressPath.Merge(m, src)
    66  }
    67  func (m *HTTPIngressPath) XXX_Size() int {
    68  	return m.Size()
    69  }
    70  func (m *HTTPIngressPath) XXX_DiscardUnknown() {
    71  	xxx_messageInfo_HTTPIngressPath.DiscardUnknown(m)
    72  }
    73  
    74  var xxx_messageInfo_HTTPIngressPath proto.InternalMessageInfo
    75  
    76  func (m *HTTPIngressRuleValue) Reset()      { *m = HTTPIngressRuleValue{} }
    77  func (*HTTPIngressRuleValue) ProtoMessage() {}
    78  func (*HTTPIngressRuleValue) Descriptor() ([]byte, []int) {
    79  	return fileDescriptor_9497719c79c89d2d, []int{1}
    80  }
    81  func (m *HTTPIngressRuleValue) XXX_Unmarshal(b []byte) error {
    82  	return m.Unmarshal(b)
    83  }
    84  func (m *HTTPIngressRuleValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    85  	b = b[:cap(b)]
    86  	n, err := m.MarshalToSizedBuffer(b)
    87  	if err != nil {
    88  		return nil, err
    89  	}
    90  	return b[:n], nil
    91  }
    92  func (m *HTTPIngressRuleValue) XXX_Merge(src proto.Message) {
    93  	xxx_messageInfo_HTTPIngressRuleValue.Merge(m, src)
    94  }
    95  func (m *HTTPIngressRuleValue) XXX_Size() int {
    96  	return m.Size()
    97  }
    98  func (m *HTTPIngressRuleValue) XXX_DiscardUnknown() {
    99  	xxx_messageInfo_HTTPIngressRuleValue.DiscardUnknown(m)
   100  }
   101  
   102  var xxx_messageInfo_HTTPIngressRuleValue proto.InternalMessageInfo
   103  
   104  func (m *Ingress) Reset()      { *m = Ingress{} }
   105  func (*Ingress) ProtoMessage() {}
   106  func (*Ingress) Descriptor() ([]byte, []int) {
   107  	return fileDescriptor_9497719c79c89d2d, []int{2}
   108  }
   109  func (m *Ingress) XXX_Unmarshal(b []byte) error {
   110  	return m.Unmarshal(b)
   111  }
   112  func (m *Ingress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   113  	b = b[:cap(b)]
   114  	n, err := m.MarshalToSizedBuffer(b)
   115  	if err != nil {
   116  		return nil, err
   117  	}
   118  	return b[:n], nil
   119  }
   120  func (m *Ingress) XXX_Merge(src proto.Message) {
   121  	xxx_messageInfo_Ingress.Merge(m, src)
   122  }
   123  func (m *Ingress) XXX_Size() int {
   124  	return m.Size()
   125  }
   126  func (m *Ingress) XXX_DiscardUnknown() {
   127  	xxx_messageInfo_Ingress.DiscardUnknown(m)
   128  }
   129  
   130  var xxx_messageInfo_Ingress proto.InternalMessageInfo
   131  
   132  func (m *IngressBackend) Reset()      { *m = IngressBackend{} }
   133  func (*IngressBackend) ProtoMessage() {}
   134  func (*IngressBackend) Descriptor() ([]byte, []int) {
   135  	return fileDescriptor_9497719c79c89d2d, []int{3}
   136  }
   137  func (m *IngressBackend) XXX_Unmarshal(b []byte) error {
   138  	return m.Unmarshal(b)
   139  }
   140  func (m *IngressBackend) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   141  	b = b[:cap(b)]
   142  	n, err := m.MarshalToSizedBuffer(b)
   143  	if err != nil {
   144  		return nil, err
   145  	}
   146  	return b[:n], nil
   147  }
   148  func (m *IngressBackend) XXX_Merge(src proto.Message) {
   149  	xxx_messageInfo_IngressBackend.Merge(m, src)
   150  }
   151  func (m *IngressBackend) XXX_Size() int {
   152  	return m.Size()
   153  }
   154  func (m *IngressBackend) XXX_DiscardUnknown() {
   155  	xxx_messageInfo_IngressBackend.DiscardUnknown(m)
   156  }
   157  
   158  var xxx_messageInfo_IngressBackend proto.InternalMessageInfo
   159  
   160  func (m *IngressClass) Reset()      { *m = IngressClass{} }
   161  func (*IngressClass) ProtoMessage() {}
   162  func (*IngressClass) Descriptor() ([]byte, []int) {
   163  	return fileDescriptor_9497719c79c89d2d, []int{4}
   164  }
   165  func (m *IngressClass) XXX_Unmarshal(b []byte) error {
   166  	return m.Unmarshal(b)
   167  }
   168  func (m *IngressClass) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   169  	b = b[:cap(b)]
   170  	n, err := m.MarshalToSizedBuffer(b)
   171  	if err != nil {
   172  		return nil, err
   173  	}
   174  	return b[:n], nil
   175  }
   176  func (m *IngressClass) XXX_Merge(src proto.Message) {
   177  	xxx_messageInfo_IngressClass.Merge(m, src)
   178  }
   179  func (m *IngressClass) XXX_Size() int {
   180  	return m.Size()
   181  }
   182  func (m *IngressClass) XXX_DiscardUnknown() {
   183  	xxx_messageInfo_IngressClass.DiscardUnknown(m)
   184  }
   185  
   186  var xxx_messageInfo_IngressClass proto.InternalMessageInfo
   187  
   188  func (m *IngressClassList) Reset()      { *m = IngressClassList{} }
   189  func (*IngressClassList) ProtoMessage() {}
   190  func (*IngressClassList) Descriptor() ([]byte, []int) {
   191  	return fileDescriptor_9497719c79c89d2d, []int{5}
   192  }
   193  func (m *IngressClassList) XXX_Unmarshal(b []byte) error {
   194  	return m.Unmarshal(b)
   195  }
   196  func (m *IngressClassList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   197  	b = b[:cap(b)]
   198  	n, err := m.MarshalToSizedBuffer(b)
   199  	if err != nil {
   200  		return nil, err
   201  	}
   202  	return b[:n], nil
   203  }
   204  func (m *IngressClassList) XXX_Merge(src proto.Message) {
   205  	xxx_messageInfo_IngressClassList.Merge(m, src)
   206  }
   207  func (m *IngressClassList) XXX_Size() int {
   208  	return m.Size()
   209  }
   210  func (m *IngressClassList) XXX_DiscardUnknown() {
   211  	xxx_messageInfo_IngressClassList.DiscardUnknown(m)
   212  }
   213  
   214  var xxx_messageInfo_IngressClassList proto.InternalMessageInfo
   215  
   216  func (m *IngressClassParametersReference) Reset()      { *m = IngressClassParametersReference{} }
   217  func (*IngressClassParametersReference) ProtoMessage() {}
   218  func (*IngressClassParametersReference) Descriptor() ([]byte, []int) {
   219  	return fileDescriptor_9497719c79c89d2d, []int{6}
   220  }
   221  func (m *IngressClassParametersReference) XXX_Unmarshal(b []byte) error {
   222  	return m.Unmarshal(b)
   223  }
   224  func (m *IngressClassParametersReference) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   225  	b = b[:cap(b)]
   226  	n, err := m.MarshalToSizedBuffer(b)
   227  	if err != nil {
   228  		return nil, err
   229  	}
   230  	return b[:n], nil
   231  }
   232  func (m *IngressClassParametersReference) XXX_Merge(src proto.Message) {
   233  	xxx_messageInfo_IngressClassParametersReference.Merge(m, src)
   234  }
   235  func (m *IngressClassParametersReference) XXX_Size() int {
   236  	return m.Size()
   237  }
   238  func (m *IngressClassParametersReference) XXX_DiscardUnknown() {
   239  	xxx_messageInfo_IngressClassParametersReference.DiscardUnknown(m)
   240  }
   241  
   242  var xxx_messageInfo_IngressClassParametersReference proto.InternalMessageInfo
   243  
   244  func (m *IngressClassSpec) Reset()      { *m = IngressClassSpec{} }
   245  func (*IngressClassSpec) ProtoMessage() {}
   246  func (*IngressClassSpec) Descriptor() ([]byte, []int) {
   247  	return fileDescriptor_9497719c79c89d2d, []int{7}
   248  }
   249  func (m *IngressClassSpec) XXX_Unmarshal(b []byte) error {
   250  	return m.Unmarshal(b)
   251  }
   252  func (m *IngressClassSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   253  	b = b[:cap(b)]
   254  	n, err := m.MarshalToSizedBuffer(b)
   255  	if err != nil {
   256  		return nil, err
   257  	}
   258  	return b[:n], nil
   259  }
   260  func (m *IngressClassSpec) XXX_Merge(src proto.Message) {
   261  	xxx_messageInfo_IngressClassSpec.Merge(m, src)
   262  }
   263  func (m *IngressClassSpec) XXX_Size() int {
   264  	return m.Size()
   265  }
   266  func (m *IngressClassSpec) XXX_DiscardUnknown() {
   267  	xxx_messageInfo_IngressClassSpec.DiscardUnknown(m)
   268  }
   269  
   270  var xxx_messageInfo_IngressClassSpec proto.InternalMessageInfo
   271  
   272  func (m *IngressList) Reset()      { *m = IngressList{} }
   273  func (*IngressList) ProtoMessage() {}
   274  func (*IngressList) Descriptor() ([]byte, []int) {
   275  	return fileDescriptor_9497719c79c89d2d, []int{8}
   276  }
   277  func (m *IngressList) XXX_Unmarshal(b []byte) error {
   278  	return m.Unmarshal(b)
   279  }
   280  func (m *IngressList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   281  	b = b[:cap(b)]
   282  	n, err := m.MarshalToSizedBuffer(b)
   283  	if err != nil {
   284  		return nil, err
   285  	}
   286  	return b[:n], nil
   287  }
   288  func (m *IngressList) XXX_Merge(src proto.Message) {
   289  	xxx_messageInfo_IngressList.Merge(m, src)
   290  }
   291  func (m *IngressList) XXX_Size() int {
   292  	return m.Size()
   293  }
   294  func (m *IngressList) XXX_DiscardUnknown() {
   295  	xxx_messageInfo_IngressList.DiscardUnknown(m)
   296  }
   297  
   298  var xxx_messageInfo_IngressList proto.InternalMessageInfo
   299  
   300  func (m *IngressLoadBalancerIngress) Reset()      { *m = IngressLoadBalancerIngress{} }
   301  func (*IngressLoadBalancerIngress) ProtoMessage() {}
   302  func (*IngressLoadBalancerIngress) Descriptor() ([]byte, []int) {
   303  	return fileDescriptor_9497719c79c89d2d, []int{9}
   304  }
   305  func (m *IngressLoadBalancerIngress) XXX_Unmarshal(b []byte) error {
   306  	return m.Unmarshal(b)
   307  }
   308  func (m *IngressLoadBalancerIngress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   309  	b = b[:cap(b)]
   310  	n, err := m.MarshalToSizedBuffer(b)
   311  	if err != nil {
   312  		return nil, err
   313  	}
   314  	return b[:n], nil
   315  }
   316  func (m *IngressLoadBalancerIngress) XXX_Merge(src proto.Message) {
   317  	xxx_messageInfo_IngressLoadBalancerIngress.Merge(m, src)
   318  }
   319  func (m *IngressLoadBalancerIngress) XXX_Size() int {
   320  	return m.Size()
   321  }
   322  func (m *IngressLoadBalancerIngress) XXX_DiscardUnknown() {
   323  	xxx_messageInfo_IngressLoadBalancerIngress.DiscardUnknown(m)
   324  }
   325  
   326  var xxx_messageInfo_IngressLoadBalancerIngress proto.InternalMessageInfo
   327  
   328  func (m *IngressLoadBalancerStatus) Reset()      { *m = IngressLoadBalancerStatus{} }
   329  func (*IngressLoadBalancerStatus) ProtoMessage() {}
   330  func (*IngressLoadBalancerStatus) Descriptor() ([]byte, []int) {
   331  	return fileDescriptor_9497719c79c89d2d, []int{10}
   332  }
   333  func (m *IngressLoadBalancerStatus) XXX_Unmarshal(b []byte) error {
   334  	return m.Unmarshal(b)
   335  }
   336  func (m *IngressLoadBalancerStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   337  	b = b[:cap(b)]
   338  	n, err := m.MarshalToSizedBuffer(b)
   339  	if err != nil {
   340  		return nil, err
   341  	}
   342  	return b[:n], nil
   343  }
   344  func (m *IngressLoadBalancerStatus) XXX_Merge(src proto.Message) {
   345  	xxx_messageInfo_IngressLoadBalancerStatus.Merge(m, src)
   346  }
   347  func (m *IngressLoadBalancerStatus) XXX_Size() int {
   348  	return m.Size()
   349  }
   350  func (m *IngressLoadBalancerStatus) XXX_DiscardUnknown() {
   351  	xxx_messageInfo_IngressLoadBalancerStatus.DiscardUnknown(m)
   352  }
   353  
   354  var xxx_messageInfo_IngressLoadBalancerStatus proto.InternalMessageInfo
   355  
   356  func (m *IngressPortStatus) Reset()      { *m = IngressPortStatus{} }
   357  func (*IngressPortStatus) ProtoMessage() {}
   358  func (*IngressPortStatus) Descriptor() ([]byte, []int) {
   359  	return fileDescriptor_9497719c79c89d2d, []int{11}
   360  }
   361  func (m *IngressPortStatus) XXX_Unmarshal(b []byte) error {
   362  	return m.Unmarshal(b)
   363  }
   364  func (m *IngressPortStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   365  	b = b[:cap(b)]
   366  	n, err := m.MarshalToSizedBuffer(b)
   367  	if err != nil {
   368  		return nil, err
   369  	}
   370  	return b[:n], nil
   371  }
   372  func (m *IngressPortStatus) XXX_Merge(src proto.Message) {
   373  	xxx_messageInfo_IngressPortStatus.Merge(m, src)
   374  }
   375  func (m *IngressPortStatus) XXX_Size() int {
   376  	return m.Size()
   377  }
   378  func (m *IngressPortStatus) XXX_DiscardUnknown() {
   379  	xxx_messageInfo_IngressPortStatus.DiscardUnknown(m)
   380  }
   381  
   382  var xxx_messageInfo_IngressPortStatus proto.InternalMessageInfo
   383  
   384  func (m *IngressRule) Reset()      { *m = IngressRule{} }
   385  func (*IngressRule) ProtoMessage() {}
   386  func (*IngressRule) Descriptor() ([]byte, []int) {
   387  	return fileDescriptor_9497719c79c89d2d, []int{12}
   388  }
   389  func (m *IngressRule) XXX_Unmarshal(b []byte) error {
   390  	return m.Unmarshal(b)
   391  }
   392  func (m *IngressRule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   393  	b = b[:cap(b)]
   394  	n, err := m.MarshalToSizedBuffer(b)
   395  	if err != nil {
   396  		return nil, err
   397  	}
   398  	return b[:n], nil
   399  }
   400  func (m *IngressRule) XXX_Merge(src proto.Message) {
   401  	xxx_messageInfo_IngressRule.Merge(m, src)
   402  }
   403  func (m *IngressRule) XXX_Size() int {
   404  	return m.Size()
   405  }
   406  func (m *IngressRule) XXX_DiscardUnknown() {
   407  	xxx_messageInfo_IngressRule.DiscardUnknown(m)
   408  }
   409  
   410  var xxx_messageInfo_IngressRule proto.InternalMessageInfo
   411  
   412  func (m *IngressRuleValue) Reset()      { *m = IngressRuleValue{} }
   413  func (*IngressRuleValue) ProtoMessage() {}
   414  func (*IngressRuleValue) Descriptor() ([]byte, []int) {
   415  	return fileDescriptor_9497719c79c89d2d, []int{13}
   416  }
   417  func (m *IngressRuleValue) XXX_Unmarshal(b []byte) error {
   418  	return m.Unmarshal(b)
   419  }
   420  func (m *IngressRuleValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   421  	b = b[:cap(b)]
   422  	n, err := m.MarshalToSizedBuffer(b)
   423  	if err != nil {
   424  		return nil, err
   425  	}
   426  	return b[:n], nil
   427  }
   428  func (m *IngressRuleValue) XXX_Merge(src proto.Message) {
   429  	xxx_messageInfo_IngressRuleValue.Merge(m, src)
   430  }
   431  func (m *IngressRuleValue) XXX_Size() int {
   432  	return m.Size()
   433  }
   434  func (m *IngressRuleValue) XXX_DiscardUnknown() {
   435  	xxx_messageInfo_IngressRuleValue.DiscardUnknown(m)
   436  }
   437  
   438  var xxx_messageInfo_IngressRuleValue proto.InternalMessageInfo
   439  
   440  func (m *IngressSpec) Reset()      { *m = IngressSpec{} }
   441  func (*IngressSpec) ProtoMessage() {}
   442  func (*IngressSpec) Descriptor() ([]byte, []int) {
   443  	return fileDescriptor_9497719c79c89d2d, []int{14}
   444  }
   445  func (m *IngressSpec) XXX_Unmarshal(b []byte) error {
   446  	return m.Unmarshal(b)
   447  }
   448  func (m *IngressSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   449  	b = b[:cap(b)]
   450  	n, err := m.MarshalToSizedBuffer(b)
   451  	if err != nil {
   452  		return nil, err
   453  	}
   454  	return b[:n], nil
   455  }
   456  func (m *IngressSpec) XXX_Merge(src proto.Message) {
   457  	xxx_messageInfo_IngressSpec.Merge(m, src)
   458  }
   459  func (m *IngressSpec) XXX_Size() int {
   460  	return m.Size()
   461  }
   462  func (m *IngressSpec) XXX_DiscardUnknown() {
   463  	xxx_messageInfo_IngressSpec.DiscardUnknown(m)
   464  }
   465  
   466  var xxx_messageInfo_IngressSpec proto.InternalMessageInfo
   467  
   468  func (m *IngressStatus) Reset()      { *m = IngressStatus{} }
   469  func (*IngressStatus) ProtoMessage() {}
   470  func (*IngressStatus) Descriptor() ([]byte, []int) {
   471  	return fileDescriptor_9497719c79c89d2d, []int{15}
   472  }
   473  func (m *IngressStatus) XXX_Unmarshal(b []byte) error {
   474  	return m.Unmarshal(b)
   475  }
   476  func (m *IngressStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   477  	b = b[:cap(b)]
   478  	n, err := m.MarshalToSizedBuffer(b)
   479  	if err != nil {
   480  		return nil, err
   481  	}
   482  	return b[:n], nil
   483  }
   484  func (m *IngressStatus) XXX_Merge(src proto.Message) {
   485  	xxx_messageInfo_IngressStatus.Merge(m, src)
   486  }
   487  func (m *IngressStatus) XXX_Size() int {
   488  	return m.Size()
   489  }
   490  func (m *IngressStatus) XXX_DiscardUnknown() {
   491  	xxx_messageInfo_IngressStatus.DiscardUnknown(m)
   492  }
   493  
   494  var xxx_messageInfo_IngressStatus proto.InternalMessageInfo
   495  
   496  func (m *IngressTLS) Reset()      { *m = IngressTLS{} }
   497  func (*IngressTLS) ProtoMessage() {}
   498  func (*IngressTLS) Descriptor() ([]byte, []int) {
   499  	return fileDescriptor_9497719c79c89d2d, []int{16}
   500  }
   501  func (m *IngressTLS) XXX_Unmarshal(b []byte) error {
   502  	return m.Unmarshal(b)
   503  }
   504  func (m *IngressTLS) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   505  	b = b[:cap(b)]
   506  	n, err := m.MarshalToSizedBuffer(b)
   507  	if err != nil {
   508  		return nil, err
   509  	}
   510  	return b[:n], nil
   511  }
   512  func (m *IngressTLS) XXX_Merge(src proto.Message) {
   513  	xxx_messageInfo_IngressTLS.Merge(m, src)
   514  }
   515  func (m *IngressTLS) XXX_Size() int {
   516  	return m.Size()
   517  }
   518  func (m *IngressTLS) XXX_DiscardUnknown() {
   519  	xxx_messageInfo_IngressTLS.DiscardUnknown(m)
   520  }
   521  
   522  var xxx_messageInfo_IngressTLS proto.InternalMessageInfo
   523  
   524  func init() {
   525  	proto.RegisterType((*HTTPIngressPath)(nil), "k8s.io.api.networking.v1beta1.HTTPIngressPath")
   526  	proto.RegisterType((*HTTPIngressRuleValue)(nil), "k8s.io.api.networking.v1beta1.HTTPIngressRuleValue")
   527  	proto.RegisterType((*Ingress)(nil), "k8s.io.api.networking.v1beta1.Ingress")
   528  	proto.RegisterType((*IngressBackend)(nil), "k8s.io.api.networking.v1beta1.IngressBackend")
   529  	proto.RegisterType((*IngressClass)(nil), "k8s.io.api.networking.v1beta1.IngressClass")
   530  	proto.RegisterType((*IngressClassList)(nil), "k8s.io.api.networking.v1beta1.IngressClassList")
   531  	proto.RegisterType((*IngressClassParametersReference)(nil), "k8s.io.api.networking.v1beta1.IngressClassParametersReference")
   532  	proto.RegisterType((*IngressClassSpec)(nil), "k8s.io.api.networking.v1beta1.IngressClassSpec")
   533  	proto.RegisterType((*IngressList)(nil), "k8s.io.api.networking.v1beta1.IngressList")
   534  	proto.RegisterType((*IngressLoadBalancerIngress)(nil), "k8s.io.api.networking.v1beta1.IngressLoadBalancerIngress")
   535  	proto.RegisterType((*IngressLoadBalancerStatus)(nil), "k8s.io.api.networking.v1beta1.IngressLoadBalancerStatus")
   536  	proto.RegisterType((*IngressPortStatus)(nil), "k8s.io.api.networking.v1beta1.IngressPortStatus")
   537  	proto.RegisterType((*IngressRule)(nil), "k8s.io.api.networking.v1beta1.IngressRule")
   538  	proto.RegisterType((*IngressRuleValue)(nil), "k8s.io.api.networking.v1beta1.IngressRuleValue")
   539  	proto.RegisterType((*IngressSpec)(nil), "k8s.io.api.networking.v1beta1.IngressSpec")
   540  	proto.RegisterType((*IngressStatus)(nil), "k8s.io.api.networking.v1beta1.IngressStatus")
   541  	proto.RegisterType((*IngressTLS)(nil), "k8s.io.api.networking.v1beta1.IngressTLS")
   542  }
   543  
   544  func init() {
   545  	proto.RegisterFile("k8s.io/api/networking/v1beta1/generated.proto", fileDescriptor_9497719c79c89d2d)
   546  }
   547  
   548  var fileDescriptor_9497719c79c89d2d = []byte{
   549  	// 1234 bytes of a gzipped FileDescriptorProto
   550  	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x57, 0x4d, 0x6f, 0x1b, 0xc5,
   551  	0x1b, 0xcf, 0xda, 0x71, 0xe3, 0x8c, 0xd3, 0x34, 0xff, 0xf9, 0xe7, 0x60, 0x82, 0x6a, 0x47, 0x7b,
   552  	0x40, 0x81, 0x36, 0xbb, 0x4d, 0x5a, 0x50, 0xb9, 0x20, 0xd8, 0x08, 0x91, 0x28, 0x21, 0x31, 0x63,
   553  	0xf3, 0x22, 0xc4, 0x81, 0xc9, 0x7a, 0x6a, 0x2f, 0x5e, 0xef, 0xae, 0x66, 0x66, 0x83, 0x7a, 0x03,
   554  	0x71, 0xe2, 0x04, 0xdf, 0x01, 0x89, 0x8f, 0x80, 0xb8, 0x20, 0x21, 0xb8, 0xe4, 0xd8, 0x63, 0x2f,
   555  	0x44, 0xc4, 0x7c, 0x8b, 0x9e, 0xd0, 0x33, 0x3b, 0xfb, 0xe2, 0x97, 0xb4, 0x0e, 0x87, 0x9e, 0xe2,
   556  	0x7d, 0x5e, 0x7e, 0xcf, 0xfb, 0x33, 0x4f, 0xd0, 0xf6, 0xe0, 0xa1, 0xb0, 0xbc, 0xd0, 0xa6, 0x91,
   557  	0x67, 0x07, 0x4c, 0x7e, 0x1d, 0xf2, 0x81, 0x17, 0xf4, 0xec, 0xb3, 0x9d, 0x53, 0x26, 0xe9, 0x8e,
   558  	0xdd, 0x63, 0x01, 0xe3, 0x54, 0xb2, 0xae, 0x15, 0xf1, 0x50, 0x86, 0xf8, 0x76, 0x22, 0x6e, 0xd1,
   559  	0xc8, 0xb3, 0x72, 0x71, 0x4b, 0x8b, 0x6f, 0x6c, 0xf7, 0x3c, 0xd9, 0x8f, 0x4f, 0x2d, 0x37, 0x1c,
   560  	0xda, 0xbd, 0xb0, 0x17, 0xda, 0x4a, 0xeb, 0x34, 0x7e, 0xa4, 0xbe, 0xd4, 0x87, 0xfa, 0x95, 0xa0,
   561  	0x6d, 0x98, 0x05, 0xe3, 0x6e, 0xc8, 0x99, 0x7d, 0x36, 0x65, 0x71, 0xe3, 0x41, 0x2e, 0x33, 0xa4,
   562  	0x6e, 0xdf, 0x0b, 0x18, 0x7f, 0x6c, 0x47, 0x83, 0x1e, 0x10, 0x84, 0x3d, 0x64, 0x92, 0xce, 0xd2,
   563  	0xb2, 0xaf, 0xd2, 0xe2, 0x71, 0x20, 0xbd, 0x21, 0x9b, 0x52, 0x78, 0xeb, 0x45, 0x0a, 0xc2, 0xed,
   564  	0xb3, 0x21, 0x9d, 0xd2, 0xbb, 0x7f, 0x95, 0x5e, 0x2c, 0x3d, 0xdf, 0xf6, 0x02, 0x29, 0x24, 0x9f,
   565  	0x54, 0x32, 0xff, 0x34, 0xd0, 0xad, 0xfd, 0x4e, 0xa7, 0x75, 0x10, 0xf4, 0x38, 0x13, 0xa2, 0x45,
   566  	0x65, 0x1f, 0x6f, 0xa2, 0xc5, 0x88, 0xca, 0x7e, 0xdd, 0xd8, 0x34, 0xb6, 0x96, 0x9d, 0x95, 0xf3,
   567  	0x8b, 0xe6, 0xc2, 0xe8, 0xa2, 0xb9, 0x08, 0x3c, 0xa2, 0x38, 0xf8, 0x01, 0xaa, 0xc2, 0xdf, 0xce,
   568  	0xe3, 0x88, 0xd5, 0xcb, 0x4a, 0xaa, 0x3e, 0xba, 0x68, 0x56, 0x5b, 0x9a, 0xf6, 0xac, 0xf0, 0x9b,
   569  	0x64, 0x92, 0xf8, 0x33, 0xb4, 0x74, 0x4a, 0xdd, 0x01, 0x0b, 0xba, 0xf5, 0xd2, 0xa6, 0xb1, 0x55,
   570  	0xdb, 0xdd, 0xb6, 0x9e, 0x5b, 0x43, 0x4b, 0x3b, 0xe5, 0x24, 0x4a, 0xce, 0x2d, 0xed, 0xc9, 0x92,
   571  	0x26, 0x90, 0x14, 0xce, 0x1c, 0xa0, 0xf5, 0x42, 0x10, 0x24, 0xf6, 0xd9, 0x27, 0xd4, 0x8f, 0x19,
   572  	0x6e, 0xa3, 0x0a, 0x58, 0x17, 0x75, 0x63, 0xb3, 0xbc, 0x55, 0xdb, 0xb5, 0x5e, 0x60, 0x6f, 0x22,
   573  	0x11, 0xce, 0x4d, 0x6d, 0xb0, 0x02, 0x5f, 0x82, 0x24, 0x58, 0xe6, 0x0f, 0x25, 0xb4, 0xa4, 0xa5,
   574  	0xf0, 0x97, 0xa8, 0x0a, 0x75, 0xef, 0x52, 0x49, 0x55, 0xba, 0x6a, 0xbb, 0xf7, 0x0a, 0x36, 0xb2,
   575  	0x32, 0x58, 0xd1, 0xa0, 0x07, 0x04, 0x61, 0x81, 0xb4, 0x75, 0xb6, 0x63, 0x9d, 0x9c, 0x7e, 0xc5,
   576  	0x5c, 0xf9, 0x21, 0x93, 0xd4, 0xc1, 0xda, 0x0a, 0xca, 0x69, 0x24, 0x43, 0xc5, 0x47, 0x68, 0x51,
   577  	0x44, 0xcc, 0xd5, 0x19, 0x7b, 0x63, 0xbe, 0x8c, 0xb5, 0x23, 0xe6, 0xe6, 0x85, 0x83, 0x2f, 0xa2,
   578  	0x50, 0x70, 0x07, 0xdd, 0x10, 0x92, 0xca, 0x58, 0xa8, 0xb2, 0xd5, 0x76, 0xef, 0xce, 0x89, 0xa7,
   579  	0x74, 0x9c, 0x55, 0x8d, 0x78, 0x23, 0xf9, 0x26, 0x1a, 0xcb, 0xfc, 0xbe, 0x84, 0x56, 0xc7, 0x6b,
   580  	0x85, 0xdf, 0x44, 0x35, 0xc1, 0xf8, 0x99, 0xe7, 0xb2, 0x63, 0x3a, 0x64, 0xba, 0x95, 0xfe, 0xaf,
   581  	0xf5, 0x6b, 0xed, 0x9c, 0x45, 0x8a, 0x72, 0xb8, 0x97, 0xa9, 0xb5, 0x42, 0x2e, 0x75, 0xd0, 0x57,
   582  	0xa7, 0x14, 0x3a, 0xdb, 0x4a, 0x3a, 0xdb, 0x3a, 0x08, 0xe4, 0x09, 0x6f, 0x4b, 0xee, 0x05, 0xbd,
   583  	0x29, 0x43, 0x00, 0x46, 0x8a, 0xc8, 0xf8, 0x53, 0x54, 0xe5, 0x4c, 0x84, 0x31, 0x77, 0x99, 0x4e,
   584  	0xc5, 0x58, 0x33, 0xc2, 0x0a, 0x80, 0x32, 0x41, 0xdf, 0x76, 0x8f, 0x42, 0x97, 0xfa, 0x49, 0x71,
   585  	0x08, 0x7b, 0xc4, 0x38, 0x0b, 0x5c, 0xe6, 0xac, 0x40, 0xc3, 0x13, 0x0d, 0x41, 0x32, 0x30, 0x18,
   586  	0xa8, 0x15, 0x9d, 0x8b, 0x3d, 0x9f, 0xbe, 0x94, 0x16, 0xf9, 0x68, 0xac, 0x45, 0xec, 0xf9, 0x4a,
   587  	0xaa, 0x9c, 0xbb, 0xaa, 0x4f, 0xcc, 0x3f, 0x0c, 0xb4, 0x56, 0x14, 0x3c, 0xf2, 0x84, 0xc4, 0x5f,
   588  	0x4c, 0x45, 0x62, 0xcd, 0x17, 0x09, 0x68, 0xab, 0x38, 0xd6, 0xb4, 0xa9, 0x6a, 0x4a, 0x29, 0x44,
   589  	0xd1, 0x42, 0x15, 0x4f, 0xb2, 0xa1, 0xa8, 0x97, 0xd4, 0xac, 0xde, 0xb9, 0x46, 0x18, 0xf9, 0xa0,
   590  	0x1e, 0x00, 0x02, 0x49, 0x80, 0xcc, 0xbf, 0x0c, 0xd4, 0x2c, 0x8a, 0xb5, 0x28, 0xa7, 0x43, 0x26,
   591  	0x19, 0x17, 0x59, 0x19, 0xf1, 0x16, 0xaa, 0xd2, 0xd6, 0xc1, 0x07, 0x3c, 0x8c, 0xa3, 0x74, 0xdf,
   592  	0x81, 0x7f, 0xef, 0x69, 0x1a, 0xc9, 0xb8, 0xb0, 0x15, 0x07, 0x9e, 0x5e, 0x5d, 0x85, 0xad, 0x78,
   593  	0xe8, 0x05, 0x5d, 0xa2, 0x38, 0x20, 0x11, 0x40, 0xb3, 0x97, 0xc7, 0x25, 0x54, 0x97, 0x2b, 0x0e,
   594  	0x6e, 0xa2, 0x8a, 0x70, 0xc3, 0x88, 0xd5, 0x17, 0x95, 0xc8, 0x32, 0xb8, 0xdc, 0x06, 0x02, 0x49,
   595  	0xe8, 0xf8, 0x0e, 0x5a, 0x06, 0x41, 0x11, 0x51, 0x97, 0xd5, 0x2b, 0x4a, 0xe8, 0xe6, 0xe8, 0xa2,
   596  	0xb9, 0x7c, 0x9c, 0x12, 0x49, 0xce, 0x37, 0x7f, 0x99, 0x28, 0x12, 0xd4, 0x0f, 0xef, 0x22, 0xe4,
   597  	0x86, 0x81, 0xe4, 0xa1, 0xef, 0x33, 0xae, 0x43, 0xca, 0xda, 0x67, 0x2f, 0xe3, 0x90, 0x82, 0x14,
   598  	0x0e, 0x10, 0x8a, 0xb2, 0xdc, 0xe8, 0x36, 0x7a, 0xe7, 0x1a, 0xf9, 0x9f, 0x91, 0x58, 0x67, 0x15,
   599  	0xec, 0x15, 0x18, 0x05, 0x0b, 0xe6, 0xaf, 0x06, 0xaa, 0x69, 0xfd, 0x97, 0xd0, 0x58, 0x87, 0xe3,
   600  	0x8d, 0xf5, 0xda, 0x9c, 0x8f, 0xce, 0xec, 0x9e, 0xfa, 0xcd, 0x40, 0x1b, 0xa9, 0xeb, 0x21, 0xed,
   601  	0x3a, 0xd4, 0xa7, 0x81, 0xcb, 0x78, 0xfa, 0x1e, 0x6c, 0xa0, 0x92, 0x97, 0x36, 0x12, 0xd2, 0x00,
   602  	0xa5, 0x83, 0x16, 0x29, 0x79, 0x11, 0xbe, 0x8b, 0xaa, 0xfd, 0x50, 0x48, 0xd5, 0x22, 0x49, 0x13,
   603  	0x65, 0x5e, 0xef, 0x6b, 0x3a, 0xc9, 0x24, 0xf0, 0xc7, 0xa8, 0x12, 0x85, 0x5c, 0x8a, 0xfa, 0xa2,
   604  	0xf2, 0xfa, 0xde, 0x7c, 0x5e, 0xc3, 0x6e, 0xd3, 0xcb, 0x3a, 0x7f, 0xbc, 0x00, 0x86, 0x24, 0x68,
   605  	0xe6, 0xb7, 0x06, 0x7a, 0x65, 0x86, 0xff, 0x89, 0x0e, 0xee, 0xa2, 0x25, 0x2f, 0x61, 0xea, 0x17,
   606  	0xf3, 0xed, 0xf9, 0xcc, 0xce, 0x48, 0x45, 0xfe, 0x5a, 0xa7, 0xaf, 0x72, 0x0a, 0x6d, 0xfe, 0x64,
   607  	0xa0, 0xff, 0x4d, 0xf9, 0xab, 0xae, 0x0e, 0xd8, 0xf9, 0x90, 0xbc, 0x4a, 0xe1, 0xea, 0x80, 0xd5,
   608  	0xad, 0x38, 0xf8, 0x10, 0x55, 0xd5, 0xd1, 0xe2, 0x86, 0xbe, 0x4e, 0xa0, 0x9d, 0x26, 0xb0, 0xa5,
   609  	0xe9, 0xcf, 0x2e, 0x9a, 0xaf, 0x4e, 0x5f, 0x72, 0x56, 0xca, 0x26, 0x19, 0x00, 0x8c, 0x22, 0xe3,
   610  	0x3c, 0xe4, 0x7a, 0x5a, 0xd5, 0x28, 0xbe, 0x0f, 0x04, 0x92, 0xd0, 0xcd, 0x9f, 0xf3, 0x26, 0x85,
   611  	0x83, 0x02, 0xfc, 0x83, 0xe2, 0x4c, 0x5e, 0x45, 0x50, 0x3a, 0xa2, 0x38, 0x38, 0x46, 0x6b, 0xde,
   612  	0xc4, 0x05, 0x72, 0xbd, 0x9d, 0x9c, 0xa9, 0x39, 0x75, 0x0d, 0xbf, 0x36, 0xc9, 0x21, 0x53, 0x26,
   613  	0x4c, 0x86, 0xa6, 0xa4, 0xe0, 0x49, 0xe8, 0x4b, 0x19, 0xe9, 0x69, 0xba, 0x3f, 0xff, 0xdd, 0x93,
   614  	0xbb, 0x50, 0x55, 0xd1, 0x75, 0x3a, 0x2d, 0xa2, 0xa0, 0xcc, 0xdf, 0x4b, 0x59, 0x3e, 0xd4, 0xa2,
   615  	0x79, 0x37, 0x8b, 0x56, 0xed, 0x00, 0xf5, 0xcc, 0x27, 0x6b, 0x6d, 0xbd, 0xe0, 0x78, 0xc6, 0x23,
   616  	0x53, 0xd2, 0xb8, 0x93, 0xdf, 0x83, 0xc6, 0x7f, 0xb9, 0x07, 0x6b, 0xb3, 0x6e, 0x41, 0xbc, 0x8f,
   617  	0xca, 0xd2, 0x4f, 0x87, 0xfd, 0xf5, 0xf9, 0x10, 0x3b, 0x47, 0x6d, 0xa7, 0xa6, 0x53, 0x5e, 0xee,
   618  	0x1c, 0xb5, 0x09, 0x40, 0xe0, 0x13, 0x54, 0xe1, 0xb1, 0xcf, 0xe0, 0x56, 0x2a, 0xcf, 0x7f, 0x7b,
   619  	0x41, 0x06, 0xf3, 0xe1, 0x83, 0x2f, 0x41, 0x12, 0x1c, 0xf3, 0x3b, 0x03, 0xdd, 0x1c, 0xbb, 0xa8,
   620  	0x30, 0x47, 0x2b, 0x7e, 0x61, 0x76, 0x74, 0x1e, 0x1e, 0x5e, 0x7f, 0xea, 0xf4, 0xd0, 0xaf, 0x6b,
   621  	0xbb, 0x2b, 0x45, 0x1e, 0x19, 0xb3, 0x61, 0x52, 0x84, 0xf2, 0xb0, 0x61, 0x0e, 0xa0, 0x79, 0x93,
   622  	0x81, 0xd7, 0x73, 0x00, 0x3d, 0x2d, 0x48, 0x42, 0x87, 0x07, 0x45, 0x30, 0x97, 0x33, 0x79, 0x9c,
   623  	0x2f, 0xae, 0xec, 0x41, 0x69, 0x67, 0x1c, 0x52, 0x90, 0x72, 0xf6, 0xce, 0x2f, 0x1b, 0x0b, 0x4f,
   624  	0x2e, 0x1b, 0x0b, 0x4f, 0x2f, 0x1b, 0x0b, 0xdf, 0x8c, 0x1a, 0xc6, 0xf9, 0xa8, 0x61, 0x3c, 0x19,
   625  	0x35, 0x8c, 0xa7, 0xa3, 0x86, 0xf1, 0xf7, 0xa8, 0x61, 0xfc, 0xf8, 0x4f, 0x63, 0xe1, 0xf3, 0xdb,
   626  	0xcf, 0xfd, 0x87, 0xef, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xea, 0xf6, 0xe9, 0x27, 0x10, 0x0e,
   627  	0x00, 0x00,
   628  }
   629  
   630  func (m *HTTPIngressPath) Marshal() (dAtA []byte, err error) {
   631  	size := m.Size()
   632  	dAtA = make([]byte, size)
   633  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   634  	if err != nil {
   635  		return nil, err
   636  	}
   637  	return dAtA[:n], nil
   638  }
   639  
   640  func (m *HTTPIngressPath) MarshalTo(dAtA []byte) (int, error) {
   641  	size := m.Size()
   642  	return m.MarshalToSizedBuffer(dAtA[:size])
   643  }
   644  
   645  func (m *HTTPIngressPath) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   646  	i := len(dAtA)
   647  	_ = i
   648  	var l int
   649  	_ = l
   650  	if m.PathType != nil {
   651  		i -= len(*m.PathType)
   652  		copy(dAtA[i:], *m.PathType)
   653  		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.PathType)))
   654  		i--
   655  		dAtA[i] = 0x1a
   656  	}
   657  	{
   658  		size, err := m.Backend.MarshalToSizedBuffer(dAtA[:i])
   659  		if err != nil {
   660  			return 0, err
   661  		}
   662  		i -= size
   663  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   664  	}
   665  	i--
   666  	dAtA[i] = 0x12
   667  	i -= len(m.Path)
   668  	copy(dAtA[i:], m.Path)
   669  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Path)))
   670  	i--
   671  	dAtA[i] = 0xa
   672  	return len(dAtA) - i, nil
   673  }
   674  
   675  func (m *HTTPIngressRuleValue) Marshal() (dAtA []byte, err error) {
   676  	size := m.Size()
   677  	dAtA = make([]byte, size)
   678  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   679  	if err != nil {
   680  		return nil, err
   681  	}
   682  	return dAtA[:n], nil
   683  }
   684  
   685  func (m *HTTPIngressRuleValue) MarshalTo(dAtA []byte) (int, error) {
   686  	size := m.Size()
   687  	return m.MarshalToSizedBuffer(dAtA[:size])
   688  }
   689  
   690  func (m *HTTPIngressRuleValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   691  	i := len(dAtA)
   692  	_ = i
   693  	var l int
   694  	_ = l
   695  	if len(m.Paths) > 0 {
   696  		for iNdEx := len(m.Paths) - 1; iNdEx >= 0; iNdEx-- {
   697  			{
   698  				size, err := m.Paths[iNdEx].MarshalToSizedBuffer(dAtA[:i])
   699  				if err != nil {
   700  					return 0, err
   701  				}
   702  				i -= size
   703  				i = encodeVarintGenerated(dAtA, i, uint64(size))
   704  			}
   705  			i--
   706  			dAtA[i] = 0xa
   707  		}
   708  	}
   709  	return len(dAtA) - i, nil
   710  }
   711  
   712  func (m *Ingress) Marshal() (dAtA []byte, err error) {
   713  	size := m.Size()
   714  	dAtA = make([]byte, size)
   715  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   716  	if err != nil {
   717  		return nil, err
   718  	}
   719  	return dAtA[:n], nil
   720  }
   721  
   722  func (m *Ingress) MarshalTo(dAtA []byte) (int, error) {
   723  	size := m.Size()
   724  	return m.MarshalToSizedBuffer(dAtA[:size])
   725  }
   726  
   727  func (m *Ingress) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   728  	i := len(dAtA)
   729  	_ = i
   730  	var l int
   731  	_ = l
   732  	{
   733  		size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
   734  		if err != nil {
   735  			return 0, err
   736  		}
   737  		i -= size
   738  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   739  	}
   740  	i--
   741  	dAtA[i] = 0x1a
   742  	{
   743  		size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
   744  		if err != nil {
   745  			return 0, err
   746  		}
   747  		i -= size
   748  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   749  	}
   750  	i--
   751  	dAtA[i] = 0x12
   752  	{
   753  		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
   754  		if err != nil {
   755  			return 0, err
   756  		}
   757  		i -= size
   758  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   759  	}
   760  	i--
   761  	dAtA[i] = 0xa
   762  	return len(dAtA) - i, nil
   763  }
   764  
   765  func (m *IngressBackend) Marshal() (dAtA []byte, err error) {
   766  	size := m.Size()
   767  	dAtA = make([]byte, size)
   768  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   769  	if err != nil {
   770  		return nil, err
   771  	}
   772  	return dAtA[:n], nil
   773  }
   774  
   775  func (m *IngressBackend) MarshalTo(dAtA []byte) (int, error) {
   776  	size := m.Size()
   777  	return m.MarshalToSizedBuffer(dAtA[:size])
   778  }
   779  
   780  func (m *IngressBackend) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   781  	i := len(dAtA)
   782  	_ = i
   783  	var l int
   784  	_ = l
   785  	if m.Resource != nil {
   786  		{
   787  			size, err := m.Resource.MarshalToSizedBuffer(dAtA[:i])
   788  			if err != nil {
   789  				return 0, err
   790  			}
   791  			i -= size
   792  			i = encodeVarintGenerated(dAtA, i, uint64(size))
   793  		}
   794  		i--
   795  		dAtA[i] = 0x1a
   796  	}
   797  	{
   798  		size, err := m.ServicePort.MarshalToSizedBuffer(dAtA[:i])
   799  		if err != nil {
   800  			return 0, err
   801  		}
   802  		i -= size
   803  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   804  	}
   805  	i--
   806  	dAtA[i] = 0x12
   807  	i -= len(m.ServiceName)
   808  	copy(dAtA[i:], m.ServiceName)
   809  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ServiceName)))
   810  	i--
   811  	dAtA[i] = 0xa
   812  	return len(dAtA) - i, nil
   813  }
   814  
   815  func (m *IngressClass) Marshal() (dAtA []byte, err error) {
   816  	size := m.Size()
   817  	dAtA = make([]byte, size)
   818  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   819  	if err != nil {
   820  		return nil, err
   821  	}
   822  	return dAtA[:n], nil
   823  }
   824  
   825  func (m *IngressClass) MarshalTo(dAtA []byte) (int, error) {
   826  	size := m.Size()
   827  	return m.MarshalToSizedBuffer(dAtA[:size])
   828  }
   829  
   830  func (m *IngressClass) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   831  	i := len(dAtA)
   832  	_ = i
   833  	var l int
   834  	_ = l
   835  	{
   836  		size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
   837  		if err != nil {
   838  			return 0, err
   839  		}
   840  		i -= size
   841  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   842  	}
   843  	i--
   844  	dAtA[i] = 0x12
   845  	{
   846  		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
   847  		if err != nil {
   848  			return 0, err
   849  		}
   850  		i -= size
   851  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   852  	}
   853  	i--
   854  	dAtA[i] = 0xa
   855  	return len(dAtA) - i, nil
   856  }
   857  
   858  func (m *IngressClassList) Marshal() (dAtA []byte, err error) {
   859  	size := m.Size()
   860  	dAtA = make([]byte, size)
   861  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   862  	if err != nil {
   863  		return nil, err
   864  	}
   865  	return dAtA[:n], nil
   866  }
   867  
   868  func (m *IngressClassList) MarshalTo(dAtA []byte) (int, error) {
   869  	size := m.Size()
   870  	return m.MarshalToSizedBuffer(dAtA[:size])
   871  }
   872  
   873  func (m *IngressClassList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   874  	i := len(dAtA)
   875  	_ = i
   876  	var l int
   877  	_ = l
   878  	if len(m.Items) > 0 {
   879  		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
   880  			{
   881  				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
   882  				if err != nil {
   883  					return 0, err
   884  				}
   885  				i -= size
   886  				i = encodeVarintGenerated(dAtA, i, uint64(size))
   887  			}
   888  			i--
   889  			dAtA[i] = 0x12
   890  		}
   891  	}
   892  	{
   893  		size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
   894  		if err != nil {
   895  			return 0, err
   896  		}
   897  		i -= size
   898  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   899  	}
   900  	i--
   901  	dAtA[i] = 0xa
   902  	return len(dAtA) - i, nil
   903  }
   904  
   905  func (m *IngressClassParametersReference) Marshal() (dAtA []byte, err error) {
   906  	size := m.Size()
   907  	dAtA = make([]byte, size)
   908  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   909  	if err != nil {
   910  		return nil, err
   911  	}
   912  	return dAtA[:n], nil
   913  }
   914  
   915  func (m *IngressClassParametersReference) MarshalTo(dAtA []byte) (int, error) {
   916  	size := m.Size()
   917  	return m.MarshalToSizedBuffer(dAtA[:size])
   918  }
   919  
   920  func (m *IngressClassParametersReference) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   921  	i := len(dAtA)
   922  	_ = i
   923  	var l int
   924  	_ = l
   925  	if m.Namespace != nil {
   926  		i -= len(*m.Namespace)
   927  		copy(dAtA[i:], *m.Namespace)
   928  		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Namespace)))
   929  		i--
   930  		dAtA[i] = 0x2a
   931  	}
   932  	if m.Scope != nil {
   933  		i -= len(*m.Scope)
   934  		copy(dAtA[i:], *m.Scope)
   935  		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Scope)))
   936  		i--
   937  		dAtA[i] = 0x22
   938  	}
   939  	i -= len(m.Name)
   940  	copy(dAtA[i:], m.Name)
   941  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
   942  	i--
   943  	dAtA[i] = 0x1a
   944  	i -= len(m.Kind)
   945  	copy(dAtA[i:], m.Kind)
   946  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
   947  	i--
   948  	dAtA[i] = 0x12
   949  	if m.APIGroup != nil {
   950  		i -= len(*m.APIGroup)
   951  		copy(dAtA[i:], *m.APIGroup)
   952  		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.APIGroup)))
   953  		i--
   954  		dAtA[i] = 0xa
   955  	}
   956  	return len(dAtA) - i, nil
   957  }
   958  
   959  func (m *IngressClassSpec) Marshal() (dAtA []byte, err error) {
   960  	size := m.Size()
   961  	dAtA = make([]byte, size)
   962  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   963  	if err != nil {
   964  		return nil, err
   965  	}
   966  	return dAtA[:n], nil
   967  }
   968  
   969  func (m *IngressClassSpec) MarshalTo(dAtA []byte) (int, error) {
   970  	size := m.Size()
   971  	return m.MarshalToSizedBuffer(dAtA[:size])
   972  }
   973  
   974  func (m *IngressClassSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   975  	i := len(dAtA)
   976  	_ = i
   977  	var l int
   978  	_ = l
   979  	if m.Parameters != nil {
   980  		{
   981  			size, err := m.Parameters.MarshalToSizedBuffer(dAtA[:i])
   982  			if err != nil {
   983  				return 0, err
   984  			}
   985  			i -= size
   986  			i = encodeVarintGenerated(dAtA, i, uint64(size))
   987  		}
   988  		i--
   989  		dAtA[i] = 0x12
   990  	}
   991  	i -= len(m.Controller)
   992  	copy(dAtA[i:], m.Controller)
   993  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Controller)))
   994  	i--
   995  	dAtA[i] = 0xa
   996  	return len(dAtA) - i, nil
   997  }
   998  
   999  func (m *IngressList) Marshal() (dAtA []byte, err error) {
  1000  	size := m.Size()
  1001  	dAtA = make([]byte, size)
  1002  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1003  	if err != nil {
  1004  		return nil, err
  1005  	}
  1006  	return dAtA[:n], nil
  1007  }
  1008  
  1009  func (m *IngressList) MarshalTo(dAtA []byte) (int, error) {
  1010  	size := m.Size()
  1011  	return m.MarshalToSizedBuffer(dAtA[:size])
  1012  }
  1013  
  1014  func (m *IngressList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1015  	i := len(dAtA)
  1016  	_ = i
  1017  	var l int
  1018  	_ = l
  1019  	if len(m.Items) > 0 {
  1020  		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
  1021  			{
  1022  				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  1023  				if err != nil {
  1024  					return 0, err
  1025  				}
  1026  				i -= size
  1027  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  1028  			}
  1029  			i--
  1030  			dAtA[i] = 0x12
  1031  		}
  1032  	}
  1033  	{
  1034  		size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
  1035  		if err != nil {
  1036  			return 0, err
  1037  		}
  1038  		i -= size
  1039  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  1040  	}
  1041  	i--
  1042  	dAtA[i] = 0xa
  1043  	return len(dAtA) - i, nil
  1044  }
  1045  
  1046  func (m *IngressLoadBalancerIngress) Marshal() (dAtA []byte, err error) {
  1047  	size := m.Size()
  1048  	dAtA = make([]byte, size)
  1049  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1050  	if err != nil {
  1051  		return nil, err
  1052  	}
  1053  	return dAtA[:n], nil
  1054  }
  1055  
  1056  func (m *IngressLoadBalancerIngress) MarshalTo(dAtA []byte) (int, error) {
  1057  	size := m.Size()
  1058  	return m.MarshalToSizedBuffer(dAtA[:size])
  1059  }
  1060  
  1061  func (m *IngressLoadBalancerIngress) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1062  	i := len(dAtA)
  1063  	_ = i
  1064  	var l int
  1065  	_ = l
  1066  	if len(m.Ports) > 0 {
  1067  		for iNdEx := len(m.Ports) - 1; iNdEx >= 0; iNdEx-- {
  1068  			{
  1069  				size, err := m.Ports[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  1070  				if err != nil {
  1071  					return 0, err
  1072  				}
  1073  				i -= size
  1074  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  1075  			}
  1076  			i--
  1077  			dAtA[i] = 0x22
  1078  		}
  1079  	}
  1080  	i -= len(m.Hostname)
  1081  	copy(dAtA[i:], m.Hostname)
  1082  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Hostname)))
  1083  	i--
  1084  	dAtA[i] = 0x12
  1085  	i -= len(m.IP)
  1086  	copy(dAtA[i:], m.IP)
  1087  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.IP)))
  1088  	i--
  1089  	dAtA[i] = 0xa
  1090  	return len(dAtA) - i, nil
  1091  }
  1092  
  1093  func (m *IngressLoadBalancerStatus) Marshal() (dAtA []byte, err error) {
  1094  	size := m.Size()
  1095  	dAtA = make([]byte, size)
  1096  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1097  	if err != nil {
  1098  		return nil, err
  1099  	}
  1100  	return dAtA[:n], nil
  1101  }
  1102  
  1103  func (m *IngressLoadBalancerStatus) MarshalTo(dAtA []byte) (int, error) {
  1104  	size := m.Size()
  1105  	return m.MarshalToSizedBuffer(dAtA[:size])
  1106  }
  1107  
  1108  func (m *IngressLoadBalancerStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1109  	i := len(dAtA)
  1110  	_ = i
  1111  	var l int
  1112  	_ = l
  1113  	if len(m.Ingress) > 0 {
  1114  		for iNdEx := len(m.Ingress) - 1; iNdEx >= 0; iNdEx-- {
  1115  			{
  1116  				size, err := m.Ingress[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  1117  				if err != nil {
  1118  					return 0, err
  1119  				}
  1120  				i -= size
  1121  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  1122  			}
  1123  			i--
  1124  			dAtA[i] = 0xa
  1125  		}
  1126  	}
  1127  	return len(dAtA) - i, nil
  1128  }
  1129  
  1130  func (m *IngressPortStatus) Marshal() (dAtA []byte, err error) {
  1131  	size := m.Size()
  1132  	dAtA = make([]byte, size)
  1133  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1134  	if err != nil {
  1135  		return nil, err
  1136  	}
  1137  	return dAtA[:n], nil
  1138  }
  1139  
  1140  func (m *IngressPortStatus) MarshalTo(dAtA []byte) (int, error) {
  1141  	size := m.Size()
  1142  	return m.MarshalToSizedBuffer(dAtA[:size])
  1143  }
  1144  
  1145  func (m *IngressPortStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1146  	i := len(dAtA)
  1147  	_ = i
  1148  	var l int
  1149  	_ = l
  1150  	if m.Error != nil {
  1151  		i -= len(*m.Error)
  1152  		copy(dAtA[i:], *m.Error)
  1153  		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Error)))
  1154  		i--
  1155  		dAtA[i] = 0x1a
  1156  	}
  1157  	i -= len(m.Protocol)
  1158  	copy(dAtA[i:], m.Protocol)
  1159  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Protocol)))
  1160  	i--
  1161  	dAtA[i] = 0x12
  1162  	i = encodeVarintGenerated(dAtA, i, uint64(m.Port))
  1163  	i--
  1164  	dAtA[i] = 0x8
  1165  	return len(dAtA) - i, nil
  1166  }
  1167  
  1168  func (m *IngressRule) Marshal() (dAtA []byte, err error) {
  1169  	size := m.Size()
  1170  	dAtA = make([]byte, size)
  1171  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1172  	if err != nil {
  1173  		return nil, err
  1174  	}
  1175  	return dAtA[:n], nil
  1176  }
  1177  
  1178  func (m *IngressRule) MarshalTo(dAtA []byte) (int, error) {
  1179  	size := m.Size()
  1180  	return m.MarshalToSizedBuffer(dAtA[:size])
  1181  }
  1182  
  1183  func (m *IngressRule) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1184  	i := len(dAtA)
  1185  	_ = i
  1186  	var l int
  1187  	_ = l
  1188  	{
  1189  		size, err := m.IngressRuleValue.MarshalToSizedBuffer(dAtA[:i])
  1190  		if err != nil {
  1191  			return 0, err
  1192  		}
  1193  		i -= size
  1194  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  1195  	}
  1196  	i--
  1197  	dAtA[i] = 0x12
  1198  	i -= len(m.Host)
  1199  	copy(dAtA[i:], m.Host)
  1200  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Host)))
  1201  	i--
  1202  	dAtA[i] = 0xa
  1203  	return len(dAtA) - i, nil
  1204  }
  1205  
  1206  func (m *IngressRuleValue) Marshal() (dAtA []byte, err error) {
  1207  	size := m.Size()
  1208  	dAtA = make([]byte, size)
  1209  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1210  	if err != nil {
  1211  		return nil, err
  1212  	}
  1213  	return dAtA[:n], nil
  1214  }
  1215  
  1216  func (m *IngressRuleValue) MarshalTo(dAtA []byte) (int, error) {
  1217  	size := m.Size()
  1218  	return m.MarshalToSizedBuffer(dAtA[:size])
  1219  }
  1220  
  1221  func (m *IngressRuleValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1222  	i := len(dAtA)
  1223  	_ = i
  1224  	var l int
  1225  	_ = l
  1226  	if m.HTTP != nil {
  1227  		{
  1228  			size, err := m.HTTP.MarshalToSizedBuffer(dAtA[:i])
  1229  			if err != nil {
  1230  				return 0, err
  1231  			}
  1232  			i -= size
  1233  			i = encodeVarintGenerated(dAtA, i, uint64(size))
  1234  		}
  1235  		i--
  1236  		dAtA[i] = 0xa
  1237  	}
  1238  	return len(dAtA) - i, nil
  1239  }
  1240  
  1241  func (m *IngressSpec) Marshal() (dAtA []byte, err error) {
  1242  	size := m.Size()
  1243  	dAtA = make([]byte, size)
  1244  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1245  	if err != nil {
  1246  		return nil, err
  1247  	}
  1248  	return dAtA[:n], nil
  1249  }
  1250  
  1251  func (m *IngressSpec) MarshalTo(dAtA []byte) (int, error) {
  1252  	size := m.Size()
  1253  	return m.MarshalToSizedBuffer(dAtA[:size])
  1254  }
  1255  
  1256  func (m *IngressSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1257  	i := len(dAtA)
  1258  	_ = i
  1259  	var l int
  1260  	_ = l
  1261  	if m.IngressClassName != nil {
  1262  		i -= len(*m.IngressClassName)
  1263  		copy(dAtA[i:], *m.IngressClassName)
  1264  		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.IngressClassName)))
  1265  		i--
  1266  		dAtA[i] = 0x22
  1267  	}
  1268  	if len(m.Rules) > 0 {
  1269  		for iNdEx := len(m.Rules) - 1; iNdEx >= 0; iNdEx-- {
  1270  			{
  1271  				size, err := m.Rules[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  1272  				if err != nil {
  1273  					return 0, err
  1274  				}
  1275  				i -= size
  1276  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  1277  			}
  1278  			i--
  1279  			dAtA[i] = 0x1a
  1280  		}
  1281  	}
  1282  	if len(m.TLS) > 0 {
  1283  		for iNdEx := len(m.TLS) - 1; iNdEx >= 0; iNdEx-- {
  1284  			{
  1285  				size, err := m.TLS[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  1286  				if err != nil {
  1287  					return 0, err
  1288  				}
  1289  				i -= size
  1290  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  1291  			}
  1292  			i--
  1293  			dAtA[i] = 0x12
  1294  		}
  1295  	}
  1296  	if m.Backend != nil {
  1297  		{
  1298  			size, err := m.Backend.MarshalToSizedBuffer(dAtA[:i])
  1299  			if err != nil {
  1300  				return 0, err
  1301  			}
  1302  			i -= size
  1303  			i = encodeVarintGenerated(dAtA, i, uint64(size))
  1304  		}
  1305  		i--
  1306  		dAtA[i] = 0xa
  1307  	}
  1308  	return len(dAtA) - i, nil
  1309  }
  1310  
  1311  func (m *IngressStatus) Marshal() (dAtA []byte, err error) {
  1312  	size := m.Size()
  1313  	dAtA = make([]byte, size)
  1314  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1315  	if err != nil {
  1316  		return nil, err
  1317  	}
  1318  	return dAtA[:n], nil
  1319  }
  1320  
  1321  func (m *IngressStatus) MarshalTo(dAtA []byte) (int, error) {
  1322  	size := m.Size()
  1323  	return m.MarshalToSizedBuffer(dAtA[:size])
  1324  }
  1325  
  1326  func (m *IngressStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1327  	i := len(dAtA)
  1328  	_ = i
  1329  	var l int
  1330  	_ = l
  1331  	{
  1332  		size, err := m.LoadBalancer.MarshalToSizedBuffer(dAtA[:i])
  1333  		if err != nil {
  1334  			return 0, err
  1335  		}
  1336  		i -= size
  1337  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  1338  	}
  1339  	i--
  1340  	dAtA[i] = 0xa
  1341  	return len(dAtA) - i, nil
  1342  }
  1343  
  1344  func (m *IngressTLS) Marshal() (dAtA []byte, err error) {
  1345  	size := m.Size()
  1346  	dAtA = make([]byte, size)
  1347  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1348  	if err != nil {
  1349  		return nil, err
  1350  	}
  1351  	return dAtA[:n], nil
  1352  }
  1353  
  1354  func (m *IngressTLS) MarshalTo(dAtA []byte) (int, error) {
  1355  	size := m.Size()
  1356  	return m.MarshalToSizedBuffer(dAtA[:size])
  1357  }
  1358  
  1359  func (m *IngressTLS) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1360  	i := len(dAtA)
  1361  	_ = i
  1362  	var l int
  1363  	_ = l
  1364  	i -= len(m.SecretName)
  1365  	copy(dAtA[i:], m.SecretName)
  1366  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.SecretName)))
  1367  	i--
  1368  	dAtA[i] = 0x12
  1369  	if len(m.Hosts) > 0 {
  1370  		for iNdEx := len(m.Hosts) - 1; iNdEx >= 0; iNdEx-- {
  1371  			i -= len(m.Hosts[iNdEx])
  1372  			copy(dAtA[i:], m.Hosts[iNdEx])
  1373  			i = encodeVarintGenerated(dAtA, i, uint64(len(m.Hosts[iNdEx])))
  1374  			i--
  1375  			dAtA[i] = 0xa
  1376  		}
  1377  	}
  1378  	return len(dAtA) - i, nil
  1379  }
  1380  
  1381  func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
  1382  	offset -= sovGenerated(v)
  1383  	base := offset
  1384  	for v >= 1<<7 {
  1385  		dAtA[offset] = uint8(v&0x7f | 0x80)
  1386  		v >>= 7
  1387  		offset++
  1388  	}
  1389  	dAtA[offset] = uint8(v)
  1390  	return base
  1391  }
  1392  func (m *HTTPIngressPath) Size() (n int) {
  1393  	if m == nil {
  1394  		return 0
  1395  	}
  1396  	var l int
  1397  	_ = l
  1398  	l = len(m.Path)
  1399  	n += 1 + l + sovGenerated(uint64(l))
  1400  	l = m.Backend.Size()
  1401  	n += 1 + l + sovGenerated(uint64(l))
  1402  	if m.PathType != nil {
  1403  		l = len(*m.PathType)
  1404  		n += 1 + l + sovGenerated(uint64(l))
  1405  	}
  1406  	return n
  1407  }
  1408  
  1409  func (m *HTTPIngressRuleValue) Size() (n int) {
  1410  	if m == nil {
  1411  		return 0
  1412  	}
  1413  	var l int
  1414  	_ = l
  1415  	if len(m.Paths) > 0 {
  1416  		for _, e := range m.Paths {
  1417  			l = e.Size()
  1418  			n += 1 + l + sovGenerated(uint64(l))
  1419  		}
  1420  	}
  1421  	return n
  1422  }
  1423  
  1424  func (m *Ingress) Size() (n int) {
  1425  	if m == nil {
  1426  		return 0
  1427  	}
  1428  	var l int
  1429  	_ = l
  1430  	l = m.ObjectMeta.Size()
  1431  	n += 1 + l + sovGenerated(uint64(l))
  1432  	l = m.Spec.Size()
  1433  	n += 1 + l + sovGenerated(uint64(l))
  1434  	l = m.Status.Size()
  1435  	n += 1 + l + sovGenerated(uint64(l))
  1436  	return n
  1437  }
  1438  
  1439  func (m *IngressBackend) Size() (n int) {
  1440  	if m == nil {
  1441  		return 0
  1442  	}
  1443  	var l int
  1444  	_ = l
  1445  	l = len(m.ServiceName)
  1446  	n += 1 + l + sovGenerated(uint64(l))
  1447  	l = m.ServicePort.Size()
  1448  	n += 1 + l + sovGenerated(uint64(l))
  1449  	if m.Resource != nil {
  1450  		l = m.Resource.Size()
  1451  		n += 1 + l + sovGenerated(uint64(l))
  1452  	}
  1453  	return n
  1454  }
  1455  
  1456  func (m *IngressClass) Size() (n int) {
  1457  	if m == nil {
  1458  		return 0
  1459  	}
  1460  	var l int
  1461  	_ = l
  1462  	l = m.ObjectMeta.Size()
  1463  	n += 1 + l + sovGenerated(uint64(l))
  1464  	l = m.Spec.Size()
  1465  	n += 1 + l + sovGenerated(uint64(l))
  1466  	return n
  1467  }
  1468  
  1469  func (m *IngressClassList) Size() (n int) {
  1470  	if m == nil {
  1471  		return 0
  1472  	}
  1473  	var l int
  1474  	_ = l
  1475  	l = m.ListMeta.Size()
  1476  	n += 1 + l + sovGenerated(uint64(l))
  1477  	if len(m.Items) > 0 {
  1478  		for _, e := range m.Items {
  1479  			l = e.Size()
  1480  			n += 1 + l + sovGenerated(uint64(l))
  1481  		}
  1482  	}
  1483  	return n
  1484  }
  1485  
  1486  func (m *IngressClassParametersReference) Size() (n int) {
  1487  	if m == nil {
  1488  		return 0
  1489  	}
  1490  	var l int
  1491  	_ = l
  1492  	if m.APIGroup != nil {
  1493  		l = len(*m.APIGroup)
  1494  		n += 1 + l + sovGenerated(uint64(l))
  1495  	}
  1496  	l = len(m.Kind)
  1497  	n += 1 + l + sovGenerated(uint64(l))
  1498  	l = len(m.Name)
  1499  	n += 1 + l + sovGenerated(uint64(l))
  1500  	if m.Scope != nil {
  1501  		l = len(*m.Scope)
  1502  		n += 1 + l + sovGenerated(uint64(l))
  1503  	}
  1504  	if m.Namespace != nil {
  1505  		l = len(*m.Namespace)
  1506  		n += 1 + l + sovGenerated(uint64(l))
  1507  	}
  1508  	return n
  1509  }
  1510  
  1511  func (m *IngressClassSpec) Size() (n int) {
  1512  	if m == nil {
  1513  		return 0
  1514  	}
  1515  	var l int
  1516  	_ = l
  1517  	l = len(m.Controller)
  1518  	n += 1 + l + sovGenerated(uint64(l))
  1519  	if m.Parameters != nil {
  1520  		l = m.Parameters.Size()
  1521  		n += 1 + l + sovGenerated(uint64(l))
  1522  	}
  1523  	return n
  1524  }
  1525  
  1526  func (m *IngressList) Size() (n int) {
  1527  	if m == nil {
  1528  		return 0
  1529  	}
  1530  	var l int
  1531  	_ = l
  1532  	l = m.ListMeta.Size()
  1533  	n += 1 + l + sovGenerated(uint64(l))
  1534  	if len(m.Items) > 0 {
  1535  		for _, e := range m.Items {
  1536  			l = e.Size()
  1537  			n += 1 + l + sovGenerated(uint64(l))
  1538  		}
  1539  	}
  1540  	return n
  1541  }
  1542  
  1543  func (m *IngressLoadBalancerIngress) Size() (n int) {
  1544  	if m == nil {
  1545  		return 0
  1546  	}
  1547  	var l int
  1548  	_ = l
  1549  	l = len(m.IP)
  1550  	n += 1 + l + sovGenerated(uint64(l))
  1551  	l = len(m.Hostname)
  1552  	n += 1 + l + sovGenerated(uint64(l))
  1553  	if len(m.Ports) > 0 {
  1554  		for _, e := range m.Ports {
  1555  			l = e.Size()
  1556  			n += 1 + l + sovGenerated(uint64(l))
  1557  		}
  1558  	}
  1559  	return n
  1560  }
  1561  
  1562  func (m *IngressLoadBalancerStatus) Size() (n int) {
  1563  	if m == nil {
  1564  		return 0
  1565  	}
  1566  	var l int
  1567  	_ = l
  1568  	if len(m.Ingress) > 0 {
  1569  		for _, e := range m.Ingress {
  1570  			l = e.Size()
  1571  			n += 1 + l + sovGenerated(uint64(l))
  1572  		}
  1573  	}
  1574  	return n
  1575  }
  1576  
  1577  func (m *IngressPortStatus) Size() (n int) {
  1578  	if m == nil {
  1579  		return 0
  1580  	}
  1581  	var l int
  1582  	_ = l
  1583  	n += 1 + sovGenerated(uint64(m.Port))
  1584  	l = len(m.Protocol)
  1585  	n += 1 + l + sovGenerated(uint64(l))
  1586  	if m.Error != nil {
  1587  		l = len(*m.Error)
  1588  		n += 1 + l + sovGenerated(uint64(l))
  1589  	}
  1590  	return n
  1591  }
  1592  
  1593  func (m *IngressRule) Size() (n int) {
  1594  	if m == nil {
  1595  		return 0
  1596  	}
  1597  	var l int
  1598  	_ = l
  1599  	l = len(m.Host)
  1600  	n += 1 + l + sovGenerated(uint64(l))
  1601  	l = m.IngressRuleValue.Size()
  1602  	n += 1 + l + sovGenerated(uint64(l))
  1603  	return n
  1604  }
  1605  
  1606  func (m *IngressRuleValue) Size() (n int) {
  1607  	if m == nil {
  1608  		return 0
  1609  	}
  1610  	var l int
  1611  	_ = l
  1612  	if m.HTTP != nil {
  1613  		l = m.HTTP.Size()
  1614  		n += 1 + l + sovGenerated(uint64(l))
  1615  	}
  1616  	return n
  1617  }
  1618  
  1619  func (m *IngressSpec) Size() (n int) {
  1620  	if m == nil {
  1621  		return 0
  1622  	}
  1623  	var l int
  1624  	_ = l
  1625  	if m.Backend != nil {
  1626  		l = m.Backend.Size()
  1627  		n += 1 + l + sovGenerated(uint64(l))
  1628  	}
  1629  	if len(m.TLS) > 0 {
  1630  		for _, e := range m.TLS {
  1631  			l = e.Size()
  1632  			n += 1 + l + sovGenerated(uint64(l))
  1633  		}
  1634  	}
  1635  	if len(m.Rules) > 0 {
  1636  		for _, e := range m.Rules {
  1637  			l = e.Size()
  1638  			n += 1 + l + sovGenerated(uint64(l))
  1639  		}
  1640  	}
  1641  	if m.IngressClassName != nil {
  1642  		l = len(*m.IngressClassName)
  1643  		n += 1 + l + sovGenerated(uint64(l))
  1644  	}
  1645  	return n
  1646  }
  1647  
  1648  func (m *IngressStatus) Size() (n int) {
  1649  	if m == nil {
  1650  		return 0
  1651  	}
  1652  	var l int
  1653  	_ = l
  1654  	l = m.LoadBalancer.Size()
  1655  	n += 1 + l + sovGenerated(uint64(l))
  1656  	return n
  1657  }
  1658  
  1659  func (m *IngressTLS) Size() (n int) {
  1660  	if m == nil {
  1661  		return 0
  1662  	}
  1663  	var l int
  1664  	_ = l
  1665  	if len(m.Hosts) > 0 {
  1666  		for _, s := range m.Hosts {
  1667  			l = len(s)
  1668  			n += 1 + l + sovGenerated(uint64(l))
  1669  		}
  1670  	}
  1671  	l = len(m.SecretName)
  1672  	n += 1 + l + sovGenerated(uint64(l))
  1673  	return n
  1674  }
  1675  
  1676  func sovGenerated(x uint64) (n int) {
  1677  	return (math_bits.Len64(x|1) + 6) / 7
  1678  }
  1679  func sozGenerated(x uint64) (n int) {
  1680  	return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
  1681  }
  1682  func (this *HTTPIngressPath) String() string {
  1683  	if this == nil {
  1684  		return "nil"
  1685  	}
  1686  	s := strings.Join([]string{`&HTTPIngressPath{`,
  1687  		`Path:` + fmt.Sprintf("%v", this.Path) + `,`,
  1688  		`Backend:` + strings.Replace(strings.Replace(this.Backend.String(), "IngressBackend", "IngressBackend", 1), `&`, ``, 1) + `,`,
  1689  		`PathType:` + valueToStringGenerated(this.PathType) + `,`,
  1690  		`}`,
  1691  	}, "")
  1692  	return s
  1693  }
  1694  func (this *HTTPIngressRuleValue) String() string {
  1695  	if this == nil {
  1696  		return "nil"
  1697  	}
  1698  	repeatedStringForPaths := "[]HTTPIngressPath{"
  1699  	for _, f := range this.Paths {
  1700  		repeatedStringForPaths += strings.Replace(strings.Replace(f.String(), "HTTPIngressPath", "HTTPIngressPath", 1), `&`, ``, 1) + ","
  1701  	}
  1702  	repeatedStringForPaths += "}"
  1703  	s := strings.Join([]string{`&HTTPIngressRuleValue{`,
  1704  		`Paths:` + repeatedStringForPaths + `,`,
  1705  		`}`,
  1706  	}, "")
  1707  	return s
  1708  }
  1709  func (this *Ingress) String() string {
  1710  	if this == nil {
  1711  		return "nil"
  1712  	}
  1713  	s := strings.Join([]string{`&Ingress{`,
  1714  		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
  1715  		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "IngressSpec", "IngressSpec", 1), `&`, ``, 1) + `,`,
  1716  		`Status:` + strings.Replace(strings.Replace(this.Status.String(), "IngressStatus", "IngressStatus", 1), `&`, ``, 1) + `,`,
  1717  		`}`,
  1718  	}, "")
  1719  	return s
  1720  }
  1721  func (this *IngressBackend) String() string {
  1722  	if this == nil {
  1723  		return "nil"
  1724  	}
  1725  	s := strings.Join([]string{`&IngressBackend{`,
  1726  		`ServiceName:` + fmt.Sprintf("%v", this.ServiceName) + `,`,
  1727  		`ServicePort:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ServicePort), "IntOrString", "intstr.IntOrString", 1), `&`, ``, 1) + `,`,
  1728  		`Resource:` + strings.Replace(fmt.Sprintf("%v", this.Resource), "TypedLocalObjectReference", "v11.TypedLocalObjectReference", 1) + `,`,
  1729  		`}`,
  1730  	}, "")
  1731  	return s
  1732  }
  1733  func (this *IngressClass) String() string {
  1734  	if this == nil {
  1735  		return "nil"
  1736  	}
  1737  	s := strings.Join([]string{`&IngressClass{`,
  1738  		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
  1739  		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "IngressClassSpec", "IngressClassSpec", 1), `&`, ``, 1) + `,`,
  1740  		`}`,
  1741  	}, "")
  1742  	return s
  1743  }
  1744  func (this *IngressClassList) String() string {
  1745  	if this == nil {
  1746  		return "nil"
  1747  	}
  1748  	repeatedStringForItems := "[]IngressClass{"
  1749  	for _, f := range this.Items {
  1750  		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "IngressClass", "IngressClass", 1), `&`, ``, 1) + ","
  1751  	}
  1752  	repeatedStringForItems += "}"
  1753  	s := strings.Join([]string{`&IngressClassList{`,
  1754  		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
  1755  		`Items:` + repeatedStringForItems + `,`,
  1756  		`}`,
  1757  	}, "")
  1758  	return s
  1759  }
  1760  func (this *IngressClassParametersReference) String() string {
  1761  	if this == nil {
  1762  		return "nil"
  1763  	}
  1764  	s := strings.Join([]string{`&IngressClassParametersReference{`,
  1765  		`APIGroup:` + valueToStringGenerated(this.APIGroup) + `,`,
  1766  		`Kind:` + fmt.Sprintf("%v", this.Kind) + `,`,
  1767  		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
  1768  		`Scope:` + valueToStringGenerated(this.Scope) + `,`,
  1769  		`Namespace:` + valueToStringGenerated(this.Namespace) + `,`,
  1770  		`}`,
  1771  	}, "")
  1772  	return s
  1773  }
  1774  func (this *IngressClassSpec) String() string {
  1775  	if this == nil {
  1776  		return "nil"
  1777  	}
  1778  	s := strings.Join([]string{`&IngressClassSpec{`,
  1779  		`Controller:` + fmt.Sprintf("%v", this.Controller) + `,`,
  1780  		`Parameters:` + strings.Replace(this.Parameters.String(), "IngressClassParametersReference", "IngressClassParametersReference", 1) + `,`,
  1781  		`}`,
  1782  	}, "")
  1783  	return s
  1784  }
  1785  func (this *IngressList) String() string {
  1786  	if this == nil {
  1787  		return "nil"
  1788  	}
  1789  	repeatedStringForItems := "[]Ingress{"
  1790  	for _, f := range this.Items {
  1791  		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "Ingress", "Ingress", 1), `&`, ``, 1) + ","
  1792  	}
  1793  	repeatedStringForItems += "}"
  1794  	s := strings.Join([]string{`&IngressList{`,
  1795  		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
  1796  		`Items:` + repeatedStringForItems + `,`,
  1797  		`}`,
  1798  	}, "")
  1799  	return s
  1800  }
  1801  func (this *IngressLoadBalancerIngress) String() string {
  1802  	if this == nil {
  1803  		return "nil"
  1804  	}
  1805  	repeatedStringForPorts := "[]IngressPortStatus{"
  1806  	for _, f := range this.Ports {
  1807  		repeatedStringForPorts += strings.Replace(strings.Replace(f.String(), "IngressPortStatus", "IngressPortStatus", 1), `&`, ``, 1) + ","
  1808  	}
  1809  	repeatedStringForPorts += "}"
  1810  	s := strings.Join([]string{`&IngressLoadBalancerIngress{`,
  1811  		`IP:` + fmt.Sprintf("%v", this.IP) + `,`,
  1812  		`Hostname:` + fmt.Sprintf("%v", this.Hostname) + `,`,
  1813  		`Ports:` + repeatedStringForPorts + `,`,
  1814  		`}`,
  1815  	}, "")
  1816  	return s
  1817  }
  1818  func (this *IngressLoadBalancerStatus) String() string {
  1819  	if this == nil {
  1820  		return "nil"
  1821  	}
  1822  	repeatedStringForIngress := "[]IngressLoadBalancerIngress{"
  1823  	for _, f := range this.Ingress {
  1824  		repeatedStringForIngress += strings.Replace(strings.Replace(f.String(), "IngressLoadBalancerIngress", "IngressLoadBalancerIngress", 1), `&`, ``, 1) + ","
  1825  	}
  1826  	repeatedStringForIngress += "}"
  1827  	s := strings.Join([]string{`&IngressLoadBalancerStatus{`,
  1828  		`Ingress:` + repeatedStringForIngress + `,`,
  1829  		`}`,
  1830  	}, "")
  1831  	return s
  1832  }
  1833  func (this *IngressPortStatus) String() string {
  1834  	if this == nil {
  1835  		return "nil"
  1836  	}
  1837  	s := strings.Join([]string{`&IngressPortStatus{`,
  1838  		`Port:` + fmt.Sprintf("%v", this.Port) + `,`,
  1839  		`Protocol:` + fmt.Sprintf("%v", this.Protocol) + `,`,
  1840  		`Error:` + valueToStringGenerated(this.Error) + `,`,
  1841  		`}`,
  1842  	}, "")
  1843  	return s
  1844  }
  1845  func (this *IngressRule) String() string {
  1846  	if this == nil {
  1847  		return "nil"
  1848  	}
  1849  	s := strings.Join([]string{`&IngressRule{`,
  1850  		`Host:` + fmt.Sprintf("%v", this.Host) + `,`,
  1851  		`IngressRuleValue:` + strings.Replace(strings.Replace(this.IngressRuleValue.String(), "IngressRuleValue", "IngressRuleValue", 1), `&`, ``, 1) + `,`,
  1852  		`}`,
  1853  	}, "")
  1854  	return s
  1855  }
  1856  func (this *IngressRuleValue) String() string {
  1857  	if this == nil {
  1858  		return "nil"
  1859  	}
  1860  	s := strings.Join([]string{`&IngressRuleValue{`,
  1861  		`HTTP:` + strings.Replace(this.HTTP.String(), "HTTPIngressRuleValue", "HTTPIngressRuleValue", 1) + `,`,
  1862  		`}`,
  1863  	}, "")
  1864  	return s
  1865  }
  1866  func (this *IngressSpec) String() string {
  1867  	if this == nil {
  1868  		return "nil"
  1869  	}
  1870  	repeatedStringForTLS := "[]IngressTLS{"
  1871  	for _, f := range this.TLS {
  1872  		repeatedStringForTLS += strings.Replace(strings.Replace(f.String(), "IngressTLS", "IngressTLS", 1), `&`, ``, 1) + ","
  1873  	}
  1874  	repeatedStringForTLS += "}"
  1875  	repeatedStringForRules := "[]IngressRule{"
  1876  	for _, f := range this.Rules {
  1877  		repeatedStringForRules += strings.Replace(strings.Replace(f.String(), "IngressRule", "IngressRule", 1), `&`, ``, 1) + ","
  1878  	}
  1879  	repeatedStringForRules += "}"
  1880  	s := strings.Join([]string{`&IngressSpec{`,
  1881  		`Backend:` + strings.Replace(this.Backend.String(), "IngressBackend", "IngressBackend", 1) + `,`,
  1882  		`TLS:` + repeatedStringForTLS + `,`,
  1883  		`Rules:` + repeatedStringForRules + `,`,
  1884  		`IngressClassName:` + valueToStringGenerated(this.IngressClassName) + `,`,
  1885  		`}`,
  1886  	}, "")
  1887  	return s
  1888  }
  1889  func (this *IngressStatus) String() string {
  1890  	if this == nil {
  1891  		return "nil"
  1892  	}
  1893  	s := strings.Join([]string{`&IngressStatus{`,
  1894  		`LoadBalancer:` + strings.Replace(strings.Replace(this.LoadBalancer.String(), "IngressLoadBalancerStatus", "IngressLoadBalancerStatus", 1), `&`, ``, 1) + `,`,
  1895  		`}`,
  1896  	}, "")
  1897  	return s
  1898  }
  1899  func (this *IngressTLS) String() string {
  1900  	if this == nil {
  1901  		return "nil"
  1902  	}
  1903  	s := strings.Join([]string{`&IngressTLS{`,
  1904  		`Hosts:` + fmt.Sprintf("%v", this.Hosts) + `,`,
  1905  		`SecretName:` + fmt.Sprintf("%v", this.SecretName) + `,`,
  1906  		`}`,
  1907  	}, "")
  1908  	return s
  1909  }
  1910  func valueToStringGenerated(v interface{}) string {
  1911  	rv := reflect.ValueOf(v)
  1912  	if rv.IsNil() {
  1913  		return "nil"
  1914  	}
  1915  	pv := reflect.Indirect(rv).Interface()
  1916  	return fmt.Sprintf("*%v", pv)
  1917  }
  1918  func (m *HTTPIngressPath) Unmarshal(dAtA []byte) error {
  1919  	l := len(dAtA)
  1920  	iNdEx := 0
  1921  	for iNdEx < l {
  1922  		preIndex := iNdEx
  1923  		var wire uint64
  1924  		for shift := uint(0); ; shift += 7 {
  1925  			if shift >= 64 {
  1926  				return ErrIntOverflowGenerated
  1927  			}
  1928  			if iNdEx >= l {
  1929  				return io.ErrUnexpectedEOF
  1930  			}
  1931  			b := dAtA[iNdEx]
  1932  			iNdEx++
  1933  			wire |= uint64(b&0x7F) << shift
  1934  			if b < 0x80 {
  1935  				break
  1936  			}
  1937  		}
  1938  		fieldNum := int32(wire >> 3)
  1939  		wireType := int(wire & 0x7)
  1940  		if wireType == 4 {
  1941  			return fmt.Errorf("proto: HTTPIngressPath: wiretype end group for non-group")
  1942  		}
  1943  		if fieldNum <= 0 {
  1944  			return fmt.Errorf("proto: HTTPIngressPath: illegal tag %d (wire type %d)", fieldNum, wire)
  1945  		}
  1946  		switch fieldNum {
  1947  		case 1:
  1948  			if wireType != 2 {
  1949  				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
  1950  			}
  1951  			var stringLen uint64
  1952  			for shift := uint(0); ; shift += 7 {
  1953  				if shift >= 64 {
  1954  					return ErrIntOverflowGenerated
  1955  				}
  1956  				if iNdEx >= l {
  1957  					return io.ErrUnexpectedEOF
  1958  				}
  1959  				b := dAtA[iNdEx]
  1960  				iNdEx++
  1961  				stringLen |= uint64(b&0x7F) << shift
  1962  				if b < 0x80 {
  1963  					break
  1964  				}
  1965  			}
  1966  			intStringLen := int(stringLen)
  1967  			if intStringLen < 0 {
  1968  				return ErrInvalidLengthGenerated
  1969  			}
  1970  			postIndex := iNdEx + intStringLen
  1971  			if postIndex < 0 {
  1972  				return ErrInvalidLengthGenerated
  1973  			}
  1974  			if postIndex > l {
  1975  				return io.ErrUnexpectedEOF
  1976  			}
  1977  			m.Path = string(dAtA[iNdEx:postIndex])
  1978  			iNdEx = postIndex
  1979  		case 2:
  1980  			if wireType != 2 {
  1981  				return fmt.Errorf("proto: wrong wireType = %d for field Backend", wireType)
  1982  			}
  1983  			var msglen int
  1984  			for shift := uint(0); ; shift += 7 {
  1985  				if shift >= 64 {
  1986  					return ErrIntOverflowGenerated
  1987  				}
  1988  				if iNdEx >= l {
  1989  					return io.ErrUnexpectedEOF
  1990  				}
  1991  				b := dAtA[iNdEx]
  1992  				iNdEx++
  1993  				msglen |= int(b&0x7F) << shift
  1994  				if b < 0x80 {
  1995  					break
  1996  				}
  1997  			}
  1998  			if msglen < 0 {
  1999  				return ErrInvalidLengthGenerated
  2000  			}
  2001  			postIndex := iNdEx + msglen
  2002  			if postIndex < 0 {
  2003  				return ErrInvalidLengthGenerated
  2004  			}
  2005  			if postIndex > l {
  2006  				return io.ErrUnexpectedEOF
  2007  			}
  2008  			if err := m.Backend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2009  				return err
  2010  			}
  2011  			iNdEx = postIndex
  2012  		case 3:
  2013  			if wireType != 2 {
  2014  				return fmt.Errorf("proto: wrong wireType = %d for field PathType", wireType)
  2015  			}
  2016  			var stringLen uint64
  2017  			for shift := uint(0); ; shift += 7 {
  2018  				if shift >= 64 {
  2019  					return ErrIntOverflowGenerated
  2020  				}
  2021  				if iNdEx >= l {
  2022  					return io.ErrUnexpectedEOF
  2023  				}
  2024  				b := dAtA[iNdEx]
  2025  				iNdEx++
  2026  				stringLen |= uint64(b&0x7F) << shift
  2027  				if b < 0x80 {
  2028  					break
  2029  				}
  2030  			}
  2031  			intStringLen := int(stringLen)
  2032  			if intStringLen < 0 {
  2033  				return ErrInvalidLengthGenerated
  2034  			}
  2035  			postIndex := iNdEx + intStringLen
  2036  			if postIndex < 0 {
  2037  				return ErrInvalidLengthGenerated
  2038  			}
  2039  			if postIndex > l {
  2040  				return io.ErrUnexpectedEOF
  2041  			}
  2042  			s := PathType(dAtA[iNdEx:postIndex])
  2043  			m.PathType = &s
  2044  			iNdEx = postIndex
  2045  		default:
  2046  			iNdEx = preIndex
  2047  			skippy, err := skipGenerated(dAtA[iNdEx:])
  2048  			if err != nil {
  2049  				return err
  2050  			}
  2051  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2052  				return ErrInvalidLengthGenerated
  2053  			}
  2054  			if (iNdEx + skippy) > l {
  2055  				return io.ErrUnexpectedEOF
  2056  			}
  2057  			iNdEx += skippy
  2058  		}
  2059  	}
  2060  
  2061  	if iNdEx > l {
  2062  		return io.ErrUnexpectedEOF
  2063  	}
  2064  	return nil
  2065  }
  2066  func (m *HTTPIngressRuleValue) Unmarshal(dAtA []byte) error {
  2067  	l := len(dAtA)
  2068  	iNdEx := 0
  2069  	for iNdEx < l {
  2070  		preIndex := iNdEx
  2071  		var wire uint64
  2072  		for shift := uint(0); ; shift += 7 {
  2073  			if shift >= 64 {
  2074  				return ErrIntOverflowGenerated
  2075  			}
  2076  			if iNdEx >= l {
  2077  				return io.ErrUnexpectedEOF
  2078  			}
  2079  			b := dAtA[iNdEx]
  2080  			iNdEx++
  2081  			wire |= uint64(b&0x7F) << shift
  2082  			if b < 0x80 {
  2083  				break
  2084  			}
  2085  		}
  2086  		fieldNum := int32(wire >> 3)
  2087  		wireType := int(wire & 0x7)
  2088  		if wireType == 4 {
  2089  			return fmt.Errorf("proto: HTTPIngressRuleValue: wiretype end group for non-group")
  2090  		}
  2091  		if fieldNum <= 0 {
  2092  			return fmt.Errorf("proto: HTTPIngressRuleValue: illegal tag %d (wire type %d)", fieldNum, wire)
  2093  		}
  2094  		switch fieldNum {
  2095  		case 1:
  2096  			if wireType != 2 {
  2097  				return fmt.Errorf("proto: wrong wireType = %d for field Paths", wireType)
  2098  			}
  2099  			var msglen int
  2100  			for shift := uint(0); ; shift += 7 {
  2101  				if shift >= 64 {
  2102  					return ErrIntOverflowGenerated
  2103  				}
  2104  				if iNdEx >= l {
  2105  					return io.ErrUnexpectedEOF
  2106  				}
  2107  				b := dAtA[iNdEx]
  2108  				iNdEx++
  2109  				msglen |= int(b&0x7F) << shift
  2110  				if b < 0x80 {
  2111  					break
  2112  				}
  2113  			}
  2114  			if msglen < 0 {
  2115  				return ErrInvalidLengthGenerated
  2116  			}
  2117  			postIndex := iNdEx + msglen
  2118  			if postIndex < 0 {
  2119  				return ErrInvalidLengthGenerated
  2120  			}
  2121  			if postIndex > l {
  2122  				return io.ErrUnexpectedEOF
  2123  			}
  2124  			m.Paths = append(m.Paths, HTTPIngressPath{})
  2125  			if err := m.Paths[len(m.Paths)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2126  				return err
  2127  			}
  2128  			iNdEx = postIndex
  2129  		default:
  2130  			iNdEx = preIndex
  2131  			skippy, err := skipGenerated(dAtA[iNdEx:])
  2132  			if err != nil {
  2133  				return err
  2134  			}
  2135  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2136  				return ErrInvalidLengthGenerated
  2137  			}
  2138  			if (iNdEx + skippy) > l {
  2139  				return io.ErrUnexpectedEOF
  2140  			}
  2141  			iNdEx += skippy
  2142  		}
  2143  	}
  2144  
  2145  	if iNdEx > l {
  2146  		return io.ErrUnexpectedEOF
  2147  	}
  2148  	return nil
  2149  }
  2150  func (m *Ingress) Unmarshal(dAtA []byte) error {
  2151  	l := len(dAtA)
  2152  	iNdEx := 0
  2153  	for iNdEx < l {
  2154  		preIndex := iNdEx
  2155  		var wire uint64
  2156  		for shift := uint(0); ; shift += 7 {
  2157  			if shift >= 64 {
  2158  				return ErrIntOverflowGenerated
  2159  			}
  2160  			if iNdEx >= l {
  2161  				return io.ErrUnexpectedEOF
  2162  			}
  2163  			b := dAtA[iNdEx]
  2164  			iNdEx++
  2165  			wire |= uint64(b&0x7F) << shift
  2166  			if b < 0x80 {
  2167  				break
  2168  			}
  2169  		}
  2170  		fieldNum := int32(wire >> 3)
  2171  		wireType := int(wire & 0x7)
  2172  		if wireType == 4 {
  2173  			return fmt.Errorf("proto: Ingress: wiretype end group for non-group")
  2174  		}
  2175  		if fieldNum <= 0 {
  2176  			return fmt.Errorf("proto: Ingress: illegal tag %d (wire type %d)", fieldNum, wire)
  2177  		}
  2178  		switch fieldNum {
  2179  		case 1:
  2180  			if wireType != 2 {
  2181  				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
  2182  			}
  2183  			var msglen int
  2184  			for shift := uint(0); ; shift += 7 {
  2185  				if shift >= 64 {
  2186  					return ErrIntOverflowGenerated
  2187  				}
  2188  				if iNdEx >= l {
  2189  					return io.ErrUnexpectedEOF
  2190  				}
  2191  				b := dAtA[iNdEx]
  2192  				iNdEx++
  2193  				msglen |= int(b&0x7F) << shift
  2194  				if b < 0x80 {
  2195  					break
  2196  				}
  2197  			}
  2198  			if msglen < 0 {
  2199  				return ErrInvalidLengthGenerated
  2200  			}
  2201  			postIndex := iNdEx + msglen
  2202  			if postIndex < 0 {
  2203  				return ErrInvalidLengthGenerated
  2204  			}
  2205  			if postIndex > l {
  2206  				return io.ErrUnexpectedEOF
  2207  			}
  2208  			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2209  				return err
  2210  			}
  2211  			iNdEx = postIndex
  2212  		case 2:
  2213  			if wireType != 2 {
  2214  				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
  2215  			}
  2216  			var msglen int
  2217  			for shift := uint(0); ; shift += 7 {
  2218  				if shift >= 64 {
  2219  					return ErrIntOverflowGenerated
  2220  				}
  2221  				if iNdEx >= l {
  2222  					return io.ErrUnexpectedEOF
  2223  				}
  2224  				b := dAtA[iNdEx]
  2225  				iNdEx++
  2226  				msglen |= int(b&0x7F) << shift
  2227  				if b < 0x80 {
  2228  					break
  2229  				}
  2230  			}
  2231  			if msglen < 0 {
  2232  				return ErrInvalidLengthGenerated
  2233  			}
  2234  			postIndex := iNdEx + msglen
  2235  			if postIndex < 0 {
  2236  				return ErrInvalidLengthGenerated
  2237  			}
  2238  			if postIndex > l {
  2239  				return io.ErrUnexpectedEOF
  2240  			}
  2241  			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2242  				return err
  2243  			}
  2244  			iNdEx = postIndex
  2245  		case 3:
  2246  			if wireType != 2 {
  2247  				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
  2248  			}
  2249  			var msglen int
  2250  			for shift := uint(0); ; shift += 7 {
  2251  				if shift >= 64 {
  2252  					return ErrIntOverflowGenerated
  2253  				}
  2254  				if iNdEx >= l {
  2255  					return io.ErrUnexpectedEOF
  2256  				}
  2257  				b := dAtA[iNdEx]
  2258  				iNdEx++
  2259  				msglen |= int(b&0x7F) << shift
  2260  				if b < 0x80 {
  2261  					break
  2262  				}
  2263  			}
  2264  			if msglen < 0 {
  2265  				return ErrInvalidLengthGenerated
  2266  			}
  2267  			postIndex := iNdEx + msglen
  2268  			if postIndex < 0 {
  2269  				return ErrInvalidLengthGenerated
  2270  			}
  2271  			if postIndex > l {
  2272  				return io.ErrUnexpectedEOF
  2273  			}
  2274  			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2275  				return err
  2276  			}
  2277  			iNdEx = postIndex
  2278  		default:
  2279  			iNdEx = preIndex
  2280  			skippy, err := skipGenerated(dAtA[iNdEx:])
  2281  			if err != nil {
  2282  				return err
  2283  			}
  2284  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2285  				return ErrInvalidLengthGenerated
  2286  			}
  2287  			if (iNdEx + skippy) > l {
  2288  				return io.ErrUnexpectedEOF
  2289  			}
  2290  			iNdEx += skippy
  2291  		}
  2292  	}
  2293  
  2294  	if iNdEx > l {
  2295  		return io.ErrUnexpectedEOF
  2296  	}
  2297  	return nil
  2298  }
  2299  func (m *IngressBackend) Unmarshal(dAtA []byte) error {
  2300  	l := len(dAtA)
  2301  	iNdEx := 0
  2302  	for iNdEx < l {
  2303  		preIndex := iNdEx
  2304  		var wire uint64
  2305  		for shift := uint(0); ; shift += 7 {
  2306  			if shift >= 64 {
  2307  				return ErrIntOverflowGenerated
  2308  			}
  2309  			if iNdEx >= l {
  2310  				return io.ErrUnexpectedEOF
  2311  			}
  2312  			b := dAtA[iNdEx]
  2313  			iNdEx++
  2314  			wire |= uint64(b&0x7F) << shift
  2315  			if b < 0x80 {
  2316  				break
  2317  			}
  2318  		}
  2319  		fieldNum := int32(wire >> 3)
  2320  		wireType := int(wire & 0x7)
  2321  		if wireType == 4 {
  2322  			return fmt.Errorf("proto: IngressBackend: wiretype end group for non-group")
  2323  		}
  2324  		if fieldNum <= 0 {
  2325  			return fmt.Errorf("proto: IngressBackend: illegal tag %d (wire type %d)", fieldNum, wire)
  2326  		}
  2327  		switch fieldNum {
  2328  		case 1:
  2329  			if wireType != 2 {
  2330  				return fmt.Errorf("proto: wrong wireType = %d for field ServiceName", wireType)
  2331  			}
  2332  			var stringLen uint64
  2333  			for shift := uint(0); ; shift += 7 {
  2334  				if shift >= 64 {
  2335  					return ErrIntOverflowGenerated
  2336  				}
  2337  				if iNdEx >= l {
  2338  					return io.ErrUnexpectedEOF
  2339  				}
  2340  				b := dAtA[iNdEx]
  2341  				iNdEx++
  2342  				stringLen |= uint64(b&0x7F) << shift
  2343  				if b < 0x80 {
  2344  					break
  2345  				}
  2346  			}
  2347  			intStringLen := int(stringLen)
  2348  			if intStringLen < 0 {
  2349  				return ErrInvalidLengthGenerated
  2350  			}
  2351  			postIndex := iNdEx + intStringLen
  2352  			if postIndex < 0 {
  2353  				return ErrInvalidLengthGenerated
  2354  			}
  2355  			if postIndex > l {
  2356  				return io.ErrUnexpectedEOF
  2357  			}
  2358  			m.ServiceName = string(dAtA[iNdEx:postIndex])
  2359  			iNdEx = postIndex
  2360  		case 2:
  2361  			if wireType != 2 {
  2362  				return fmt.Errorf("proto: wrong wireType = %d for field ServicePort", wireType)
  2363  			}
  2364  			var msglen int
  2365  			for shift := uint(0); ; shift += 7 {
  2366  				if shift >= 64 {
  2367  					return ErrIntOverflowGenerated
  2368  				}
  2369  				if iNdEx >= l {
  2370  					return io.ErrUnexpectedEOF
  2371  				}
  2372  				b := dAtA[iNdEx]
  2373  				iNdEx++
  2374  				msglen |= int(b&0x7F) << shift
  2375  				if b < 0x80 {
  2376  					break
  2377  				}
  2378  			}
  2379  			if msglen < 0 {
  2380  				return ErrInvalidLengthGenerated
  2381  			}
  2382  			postIndex := iNdEx + msglen
  2383  			if postIndex < 0 {
  2384  				return ErrInvalidLengthGenerated
  2385  			}
  2386  			if postIndex > l {
  2387  				return io.ErrUnexpectedEOF
  2388  			}
  2389  			if err := m.ServicePort.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2390  				return err
  2391  			}
  2392  			iNdEx = postIndex
  2393  		case 3:
  2394  			if wireType != 2 {
  2395  				return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType)
  2396  			}
  2397  			var msglen int
  2398  			for shift := uint(0); ; shift += 7 {
  2399  				if shift >= 64 {
  2400  					return ErrIntOverflowGenerated
  2401  				}
  2402  				if iNdEx >= l {
  2403  					return io.ErrUnexpectedEOF
  2404  				}
  2405  				b := dAtA[iNdEx]
  2406  				iNdEx++
  2407  				msglen |= int(b&0x7F) << shift
  2408  				if b < 0x80 {
  2409  					break
  2410  				}
  2411  			}
  2412  			if msglen < 0 {
  2413  				return ErrInvalidLengthGenerated
  2414  			}
  2415  			postIndex := iNdEx + msglen
  2416  			if postIndex < 0 {
  2417  				return ErrInvalidLengthGenerated
  2418  			}
  2419  			if postIndex > l {
  2420  				return io.ErrUnexpectedEOF
  2421  			}
  2422  			if m.Resource == nil {
  2423  				m.Resource = &v11.TypedLocalObjectReference{}
  2424  			}
  2425  			if err := m.Resource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2426  				return err
  2427  			}
  2428  			iNdEx = postIndex
  2429  		default:
  2430  			iNdEx = preIndex
  2431  			skippy, err := skipGenerated(dAtA[iNdEx:])
  2432  			if err != nil {
  2433  				return err
  2434  			}
  2435  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2436  				return ErrInvalidLengthGenerated
  2437  			}
  2438  			if (iNdEx + skippy) > l {
  2439  				return io.ErrUnexpectedEOF
  2440  			}
  2441  			iNdEx += skippy
  2442  		}
  2443  	}
  2444  
  2445  	if iNdEx > l {
  2446  		return io.ErrUnexpectedEOF
  2447  	}
  2448  	return nil
  2449  }
  2450  func (m *IngressClass) Unmarshal(dAtA []byte) error {
  2451  	l := len(dAtA)
  2452  	iNdEx := 0
  2453  	for iNdEx < l {
  2454  		preIndex := iNdEx
  2455  		var wire uint64
  2456  		for shift := uint(0); ; shift += 7 {
  2457  			if shift >= 64 {
  2458  				return ErrIntOverflowGenerated
  2459  			}
  2460  			if iNdEx >= l {
  2461  				return io.ErrUnexpectedEOF
  2462  			}
  2463  			b := dAtA[iNdEx]
  2464  			iNdEx++
  2465  			wire |= uint64(b&0x7F) << shift
  2466  			if b < 0x80 {
  2467  				break
  2468  			}
  2469  		}
  2470  		fieldNum := int32(wire >> 3)
  2471  		wireType := int(wire & 0x7)
  2472  		if wireType == 4 {
  2473  			return fmt.Errorf("proto: IngressClass: wiretype end group for non-group")
  2474  		}
  2475  		if fieldNum <= 0 {
  2476  			return fmt.Errorf("proto: IngressClass: illegal tag %d (wire type %d)", fieldNum, wire)
  2477  		}
  2478  		switch fieldNum {
  2479  		case 1:
  2480  			if wireType != 2 {
  2481  				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
  2482  			}
  2483  			var msglen int
  2484  			for shift := uint(0); ; shift += 7 {
  2485  				if shift >= 64 {
  2486  					return ErrIntOverflowGenerated
  2487  				}
  2488  				if iNdEx >= l {
  2489  					return io.ErrUnexpectedEOF
  2490  				}
  2491  				b := dAtA[iNdEx]
  2492  				iNdEx++
  2493  				msglen |= int(b&0x7F) << shift
  2494  				if b < 0x80 {
  2495  					break
  2496  				}
  2497  			}
  2498  			if msglen < 0 {
  2499  				return ErrInvalidLengthGenerated
  2500  			}
  2501  			postIndex := iNdEx + msglen
  2502  			if postIndex < 0 {
  2503  				return ErrInvalidLengthGenerated
  2504  			}
  2505  			if postIndex > l {
  2506  				return io.ErrUnexpectedEOF
  2507  			}
  2508  			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2509  				return err
  2510  			}
  2511  			iNdEx = postIndex
  2512  		case 2:
  2513  			if wireType != 2 {
  2514  				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
  2515  			}
  2516  			var msglen int
  2517  			for shift := uint(0); ; shift += 7 {
  2518  				if shift >= 64 {
  2519  					return ErrIntOverflowGenerated
  2520  				}
  2521  				if iNdEx >= l {
  2522  					return io.ErrUnexpectedEOF
  2523  				}
  2524  				b := dAtA[iNdEx]
  2525  				iNdEx++
  2526  				msglen |= int(b&0x7F) << shift
  2527  				if b < 0x80 {
  2528  					break
  2529  				}
  2530  			}
  2531  			if msglen < 0 {
  2532  				return ErrInvalidLengthGenerated
  2533  			}
  2534  			postIndex := iNdEx + msglen
  2535  			if postIndex < 0 {
  2536  				return ErrInvalidLengthGenerated
  2537  			}
  2538  			if postIndex > l {
  2539  				return io.ErrUnexpectedEOF
  2540  			}
  2541  			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2542  				return err
  2543  			}
  2544  			iNdEx = postIndex
  2545  		default:
  2546  			iNdEx = preIndex
  2547  			skippy, err := skipGenerated(dAtA[iNdEx:])
  2548  			if err != nil {
  2549  				return err
  2550  			}
  2551  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2552  				return ErrInvalidLengthGenerated
  2553  			}
  2554  			if (iNdEx + skippy) > l {
  2555  				return io.ErrUnexpectedEOF
  2556  			}
  2557  			iNdEx += skippy
  2558  		}
  2559  	}
  2560  
  2561  	if iNdEx > l {
  2562  		return io.ErrUnexpectedEOF
  2563  	}
  2564  	return nil
  2565  }
  2566  func (m *IngressClassList) Unmarshal(dAtA []byte) error {
  2567  	l := len(dAtA)
  2568  	iNdEx := 0
  2569  	for iNdEx < l {
  2570  		preIndex := iNdEx
  2571  		var wire uint64
  2572  		for shift := uint(0); ; shift += 7 {
  2573  			if shift >= 64 {
  2574  				return ErrIntOverflowGenerated
  2575  			}
  2576  			if iNdEx >= l {
  2577  				return io.ErrUnexpectedEOF
  2578  			}
  2579  			b := dAtA[iNdEx]
  2580  			iNdEx++
  2581  			wire |= uint64(b&0x7F) << shift
  2582  			if b < 0x80 {
  2583  				break
  2584  			}
  2585  		}
  2586  		fieldNum := int32(wire >> 3)
  2587  		wireType := int(wire & 0x7)
  2588  		if wireType == 4 {
  2589  			return fmt.Errorf("proto: IngressClassList: wiretype end group for non-group")
  2590  		}
  2591  		if fieldNum <= 0 {
  2592  			return fmt.Errorf("proto: IngressClassList: illegal tag %d (wire type %d)", fieldNum, wire)
  2593  		}
  2594  		switch fieldNum {
  2595  		case 1:
  2596  			if wireType != 2 {
  2597  				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
  2598  			}
  2599  			var msglen int
  2600  			for shift := uint(0); ; shift += 7 {
  2601  				if shift >= 64 {
  2602  					return ErrIntOverflowGenerated
  2603  				}
  2604  				if iNdEx >= l {
  2605  					return io.ErrUnexpectedEOF
  2606  				}
  2607  				b := dAtA[iNdEx]
  2608  				iNdEx++
  2609  				msglen |= int(b&0x7F) << shift
  2610  				if b < 0x80 {
  2611  					break
  2612  				}
  2613  			}
  2614  			if msglen < 0 {
  2615  				return ErrInvalidLengthGenerated
  2616  			}
  2617  			postIndex := iNdEx + msglen
  2618  			if postIndex < 0 {
  2619  				return ErrInvalidLengthGenerated
  2620  			}
  2621  			if postIndex > l {
  2622  				return io.ErrUnexpectedEOF
  2623  			}
  2624  			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2625  				return err
  2626  			}
  2627  			iNdEx = postIndex
  2628  		case 2:
  2629  			if wireType != 2 {
  2630  				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
  2631  			}
  2632  			var msglen int
  2633  			for shift := uint(0); ; shift += 7 {
  2634  				if shift >= 64 {
  2635  					return ErrIntOverflowGenerated
  2636  				}
  2637  				if iNdEx >= l {
  2638  					return io.ErrUnexpectedEOF
  2639  				}
  2640  				b := dAtA[iNdEx]
  2641  				iNdEx++
  2642  				msglen |= int(b&0x7F) << shift
  2643  				if b < 0x80 {
  2644  					break
  2645  				}
  2646  			}
  2647  			if msglen < 0 {
  2648  				return ErrInvalidLengthGenerated
  2649  			}
  2650  			postIndex := iNdEx + msglen
  2651  			if postIndex < 0 {
  2652  				return ErrInvalidLengthGenerated
  2653  			}
  2654  			if postIndex > l {
  2655  				return io.ErrUnexpectedEOF
  2656  			}
  2657  			m.Items = append(m.Items, IngressClass{})
  2658  			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2659  				return err
  2660  			}
  2661  			iNdEx = postIndex
  2662  		default:
  2663  			iNdEx = preIndex
  2664  			skippy, err := skipGenerated(dAtA[iNdEx:])
  2665  			if err != nil {
  2666  				return err
  2667  			}
  2668  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2669  				return ErrInvalidLengthGenerated
  2670  			}
  2671  			if (iNdEx + skippy) > l {
  2672  				return io.ErrUnexpectedEOF
  2673  			}
  2674  			iNdEx += skippy
  2675  		}
  2676  	}
  2677  
  2678  	if iNdEx > l {
  2679  		return io.ErrUnexpectedEOF
  2680  	}
  2681  	return nil
  2682  }
  2683  func (m *IngressClassParametersReference) Unmarshal(dAtA []byte) error {
  2684  	l := len(dAtA)
  2685  	iNdEx := 0
  2686  	for iNdEx < l {
  2687  		preIndex := iNdEx
  2688  		var wire uint64
  2689  		for shift := uint(0); ; shift += 7 {
  2690  			if shift >= 64 {
  2691  				return ErrIntOverflowGenerated
  2692  			}
  2693  			if iNdEx >= l {
  2694  				return io.ErrUnexpectedEOF
  2695  			}
  2696  			b := dAtA[iNdEx]
  2697  			iNdEx++
  2698  			wire |= uint64(b&0x7F) << shift
  2699  			if b < 0x80 {
  2700  				break
  2701  			}
  2702  		}
  2703  		fieldNum := int32(wire >> 3)
  2704  		wireType := int(wire & 0x7)
  2705  		if wireType == 4 {
  2706  			return fmt.Errorf("proto: IngressClassParametersReference: wiretype end group for non-group")
  2707  		}
  2708  		if fieldNum <= 0 {
  2709  			return fmt.Errorf("proto: IngressClassParametersReference: illegal tag %d (wire type %d)", fieldNum, wire)
  2710  		}
  2711  		switch fieldNum {
  2712  		case 1:
  2713  			if wireType != 2 {
  2714  				return fmt.Errorf("proto: wrong wireType = %d for field APIGroup", wireType)
  2715  			}
  2716  			var stringLen uint64
  2717  			for shift := uint(0); ; shift += 7 {
  2718  				if shift >= 64 {
  2719  					return ErrIntOverflowGenerated
  2720  				}
  2721  				if iNdEx >= l {
  2722  					return io.ErrUnexpectedEOF
  2723  				}
  2724  				b := dAtA[iNdEx]
  2725  				iNdEx++
  2726  				stringLen |= uint64(b&0x7F) << shift
  2727  				if b < 0x80 {
  2728  					break
  2729  				}
  2730  			}
  2731  			intStringLen := int(stringLen)
  2732  			if intStringLen < 0 {
  2733  				return ErrInvalidLengthGenerated
  2734  			}
  2735  			postIndex := iNdEx + intStringLen
  2736  			if postIndex < 0 {
  2737  				return ErrInvalidLengthGenerated
  2738  			}
  2739  			if postIndex > l {
  2740  				return io.ErrUnexpectedEOF
  2741  			}
  2742  			s := string(dAtA[iNdEx:postIndex])
  2743  			m.APIGroup = &s
  2744  			iNdEx = postIndex
  2745  		case 2:
  2746  			if wireType != 2 {
  2747  				return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
  2748  			}
  2749  			var stringLen uint64
  2750  			for shift := uint(0); ; shift += 7 {
  2751  				if shift >= 64 {
  2752  					return ErrIntOverflowGenerated
  2753  				}
  2754  				if iNdEx >= l {
  2755  					return io.ErrUnexpectedEOF
  2756  				}
  2757  				b := dAtA[iNdEx]
  2758  				iNdEx++
  2759  				stringLen |= uint64(b&0x7F) << shift
  2760  				if b < 0x80 {
  2761  					break
  2762  				}
  2763  			}
  2764  			intStringLen := int(stringLen)
  2765  			if intStringLen < 0 {
  2766  				return ErrInvalidLengthGenerated
  2767  			}
  2768  			postIndex := iNdEx + intStringLen
  2769  			if postIndex < 0 {
  2770  				return ErrInvalidLengthGenerated
  2771  			}
  2772  			if postIndex > l {
  2773  				return io.ErrUnexpectedEOF
  2774  			}
  2775  			m.Kind = string(dAtA[iNdEx:postIndex])
  2776  			iNdEx = postIndex
  2777  		case 3:
  2778  			if wireType != 2 {
  2779  				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
  2780  			}
  2781  			var stringLen uint64
  2782  			for shift := uint(0); ; shift += 7 {
  2783  				if shift >= 64 {
  2784  					return ErrIntOverflowGenerated
  2785  				}
  2786  				if iNdEx >= l {
  2787  					return io.ErrUnexpectedEOF
  2788  				}
  2789  				b := dAtA[iNdEx]
  2790  				iNdEx++
  2791  				stringLen |= uint64(b&0x7F) << shift
  2792  				if b < 0x80 {
  2793  					break
  2794  				}
  2795  			}
  2796  			intStringLen := int(stringLen)
  2797  			if intStringLen < 0 {
  2798  				return ErrInvalidLengthGenerated
  2799  			}
  2800  			postIndex := iNdEx + intStringLen
  2801  			if postIndex < 0 {
  2802  				return ErrInvalidLengthGenerated
  2803  			}
  2804  			if postIndex > l {
  2805  				return io.ErrUnexpectedEOF
  2806  			}
  2807  			m.Name = string(dAtA[iNdEx:postIndex])
  2808  			iNdEx = postIndex
  2809  		case 4:
  2810  			if wireType != 2 {
  2811  				return fmt.Errorf("proto: wrong wireType = %d for field Scope", wireType)
  2812  			}
  2813  			var stringLen uint64
  2814  			for shift := uint(0); ; shift += 7 {
  2815  				if shift >= 64 {
  2816  					return ErrIntOverflowGenerated
  2817  				}
  2818  				if iNdEx >= l {
  2819  					return io.ErrUnexpectedEOF
  2820  				}
  2821  				b := dAtA[iNdEx]
  2822  				iNdEx++
  2823  				stringLen |= uint64(b&0x7F) << shift
  2824  				if b < 0x80 {
  2825  					break
  2826  				}
  2827  			}
  2828  			intStringLen := int(stringLen)
  2829  			if intStringLen < 0 {
  2830  				return ErrInvalidLengthGenerated
  2831  			}
  2832  			postIndex := iNdEx + intStringLen
  2833  			if postIndex < 0 {
  2834  				return ErrInvalidLengthGenerated
  2835  			}
  2836  			if postIndex > l {
  2837  				return io.ErrUnexpectedEOF
  2838  			}
  2839  			s := string(dAtA[iNdEx:postIndex])
  2840  			m.Scope = &s
  2841  			iNdEx = postIndex
  2842  		case 5:
  2843  			if wireType != 2 {
  2844  				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
  2845  			}
  2846  			var stringLen uint64
  2847  			for shift := uint(0); ; shift += 7 {
  2848  				if shift >= 64 {
  2849  					return ErrIntOverflowGenerated
  2850  				}
  2851  				if iNdEx >= l {
  2852  					return io.ErrUnexpectedEOF
  2853  				}
  2854  				b := dAtA[iNdEx]
  2855  				iNdEx++
  2856  				stringLen |= uint64(b&0x7F) << shift
  2857  				if b < 0x80 {
  2858  					break
  2859  				}
  2860  			}
  2861  			intStringLen := int(stringLen)
  2862  			if intStringLen < 0 {
  2863  				return ErrInvalidLengthGenerated
  2864  			}
  2865  			postIndex := iNdEx + intStringLen
  2866  			if postIndex < 0 {
  2867  				return ErrInvalidLengthGenerated
  2868  			}
  2869  			if postIndex > l {
  2870  				return io.ErrUnexpectedEOF
  2871  			}
  2872  			s := string(dAtA[iNdEx:postIndex])
  2873  			m.Namespace = &s
  2874  			iNdEx = postIndex
  2875  		default:
  2876  			iNdEx = preIndex
  2877  			skippy, err := skipGenerated(dAtA[iNdEx:])
  2878  			if err != nil {
  2879  				return err
  2880  			}
  2881  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2882  				return ErrInvalidLengthGenerated
  2883  			}
  2884  			if (iNdEx + skippy) > l {
  2885  				return io.ErrUnexpectedEOF
  2886  			}
  2887  			iNdEx += skippy
  2888  		}
  2889  	}
  2890  
  2891  	if iNdEx > l {
  2892  		return io.ErrUnexpectedEOF
  2893  	}
  2894  	return nil
  2895  }
  2896  func (m *IngressClassSpec) Unmarshal(dAtA []byte) error {
  2897  	l := len(dAtA)
  2898  	iNdEx := 0
  2899  	for iNdEx < l {
  2900  		preIndex := iNdEx
  2901  		var wire uint64
  2902  		for shift := uint(0); ; shift += 7 {
  2903  			if shift >= 64 {
  2904  				return ErrIntOverflowGenerated
  2905  			}
  2906  			if iNdEx >= l {
  2907  				return io.ErrUnexpectedEOF
  2908  			}
  2909  			b := dAtA[iNdEx]
  2910  			iNdEx++
  2911  			wire |= uint64(b&0x7F) << shift
  2912  			if b < 0x80 {
  2913  				break
  2914  			}
  2915  		}
  2916  		fieldNum := int32(wire >> 3)
  2917  		wireType := int(wire & 0x7)
  2918  		if wireType == 4 {
  2919  			return fmt.Errorf("proto: IngressClassSpec: wiretype end group for non-group")
  2920  		}
  2921  		if fieldNum <= 0 {
  2922  			return fmt.Errorf("proto: IngressClassSpec: illegal tag %d (wire type %d)", fieldNum, wire)
  2923  		}
  2924  		switch fieldNum {
  2925  		case 1:
  2926  			if wireType != 2 {
  2927  				return fmt.Errorf("proto: wrong wireType = %d for field Controller", wireType)
  2928  			}
  2929  			var stringLen uint64
  2930  			for shift := uint(0); ; shift += 7 {
  2931  				if shift >= 64 {
  2932  					return ErrIntOverflowGenerated
  2933  				}
  2934  				if iNdEx >= l {
  2935  					return io.ErrUnexpectedEOF
  2936  				}
  2937  				b := dAtA[iNdEx]
  2938  				iNdEx++
  2939  				stringLen |= uint64(b&0x7F) << shift
  2940  				if b < 0x80 {
  2941  					break
  2942  				}
  2943  			}
  2944  			intStringLen := int(stringLen)
  2945  			if intStringLen < 0 {
  2946  				return ErrInvalidLengthGenerated
  2947  			}
  2948  			postIndex := iNdEx + intStringLen
  2949  			if postIndex < 0 {
  2950  				return ErrInvalidLengthGenerated
  2951  			}
  2952  			if postIndex > l {
  2953  				return io.ErrUnexpectedEOF
  2954  			}
  2955  			m.Controller = string(dAtA[iNdEx:postIndex])
  2956  			iNdEx = postIndex
  2957  		case 2:
  2958  			if wireType != 2 {
  2959  				return fmt.Errorf("proto: wrong wireType = %d for field Parameters", wireType)
  2960  			}
  2961  			var msglen int
  2962  			for shift := uint(0); ; shift += 7 {
  2963  				if shift >= 64 {
  2964  					return ErrIntOverflowGenerated
  2965  				}
  2966  				if iNdEx >= l {
  2967  					return io.ErrUnexpectedEOF
  2968  				}
  2969  				b := dAtA[iNdEx]
  2970  				iNdEx++
  2971  				msglen |= int(b&0x7F) << shift
  2972  				if b < 0x80 {
  2973  					break
  2974  				}
  2975  			}
  2976  			if msglen < 0 {
  2977  				return ErrInvalidLengthGenerated
  2978  			}
  2979  			postIndex := iNdEx + msglen
  2980  			if postIndex < 0 {
  2981  				return ErrInvalidLengthGenerated
  2982  			}
  2983  			if postIndex > l {
  2984  				return io.ErrUnexpectedEOF
  2985  			}
  2986  			if m.Parameters == nil {
  2987  				m.Parameters = &IngressClassParametersReference{}
  2988  			}
  2989  			if err := m.Parameters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2990  				return err
  2991  			}
  2992  			iNdEx = postIndex
  2993  		default:
  2994  			iNdEx = preIndex
  2995  			skippy, err := skipGenerated(dAtA[iNdEx:])
  2996  			if err != nil {
  2997  				return err
  2998  			}
  2999  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  3000  				return ErrInvalidLengthGenerated
  3001  			}
  3002  			if (iNdEx + skippy) > l {
  3003  				return io.ErrUnexpectedEOF
  3004  			}
  3005  			iNdEx += skippy
  3006  		}
  3007  	}
  3008  
  3009  	if iNdEx > l {
  3010  		return io.ErrUnexpectedEOF
  3011  	}
  3012  	return nil
  3013  }
  3014  func (m *IngressList) Unmarshal(dAtA []byte) error {
  3015  	l := len(dAtA)
  3016  	iNdEx := 0
  3017  	for iNdEx < l {
  3018  		preIndex := iNdEx
  3019  		var wire uint64
  3020  		for shift := uint(0); ; shift += 7 {
  3021  			if shift >= 64 {
  3022  				return ErrIntOverflowGenerated
  3023  			}
  3024  			if iNdEx >= l {
  3025  				return io.ErrUnexpectedEOF
  3026  			}
  3027  			b := dAtA[iNdEx]
  3028  			iNdEx++
  3029  			wire |= uint64(b&0x7F) << shift
  3030  			if b < 0x80 {
  3031  				break
  3032  			}
  3033  		}
  3034  		fieldNum := int32(wire >> 3)
  3035  		wireType := int(wire & 0x7)
  3036  		if wireType == 4 {
  3037  			return fmt.Errorf("proto: IngressList: wiretype end group for non-group")
  3038  		}
  3039  		if fieldNum <= 0 {
  3040  			return fmt.Errorf("proto: IngressList: illegal tag %d (wire type %d)", fieldNum, wire)
  3041  		}
  3042  		switch fieldNum {
  3043  		case 1:
  3044  			if wireType != 2 {
  3045  				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
  3046  			}
  3047  			var msglen int
  3048  			for shift := uint(0); ; shift += 7 {
  3049  				if shift >= 64 {
  3050  					return ErrIntOverflowGenerated
  3051  				}
  3052  				if iNdEx >= l {
  3053  					return io.ErrUnexpectedEOF
  3054  				}
  3055  				b := dAtA[iNdEx]
  3056  				iNdEx++
  3057  				msglen |= int(b&0x7F) << shift
  3058  				if b < 0x80 {
  3059  					break
  3060  				}
  3061  			}
  3062  			if msglen < 0 {
  3063  				return ErrInvalidLengthGenerated
  3064  			}
  3065  			postIndex := iNdEx + msglen
  3066  			if postIndex < 0 {
  3067  				return ErrInvalidLengthGenerated
  3068  			}
  3069  			if postIndex > l {
  3070  				return io.ErrUnexpectedEOF
  3071  			}
  3072  			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  3073  				return err
  3074  			}
  3075  			iNdEx = postIndex
  3076  		case 2:
  3077  			if wireType != 2 {
  3078  				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
  3079  			}
  3080  			var msglen int
  3081  			for shift := uint(0); ; shift += 7 {
  3082  				if shift >= 64 {
  3083  					return ErrIntOverflowGenerated
  3084  				}
  3085  				if iNdEx >= l {
  3086  					return io.ErrUnexpectedEOF
  3087  				}
  3088  				b := dAtA[iNdEx]
  3089  				iNdEx++
  3090  				msglen |= int(b&0x7F) << shift
  3091  				if b < 0x80 {
  3092  					break
  3093  				}
  3094  			}
  3095  			if msglen < 0 {
  3096  				return ErrInvalidLengthGenerated
  3097  			}
  3098  			postIndex := iNdEx + msglen
  3099  			if postIndex < 0 {
  3100  				return ErrInvalidLengthGenerated
  3101  			}
  3102  			if postIndex > l {
  3103  				return io.ErrUnexpectedEOF
  3104  			}
  3105  			m.Items = append(m.Items, Ingress{})
  3106  			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  3107  				return err
  3108  			}
  3109  			iNdEx = postIndex
  3110  		default:
  3111  			iNdEx = preIndex
  3112  			skippy, err := skipGenerated(dAtA[iNdEx:])
  3113  			if err != nil {
  3114  				return err
  3115  			}
  3116  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  3117  				return ErrInvalidLengthGenerated
  3118  			}
  3119  			if (iNdEx + skippy) > l {
  3120  				return io.ErrUnexpectedEOF
  3121  			}
  3122  			iNdEx += skippy
  3123  		}
  3124  	}
  3125  
  3126  	if iNdEx > l {
  3127  		return io.ErrUnexpectedEOF
  3128  	}
  3129  	return nil
  3130  }
  3131  func (m *IngressLoadBalancerIngress) Unmarshal(dAtA []byte) error {
  3132  	l := len(dAtA)
  3133  	iNdEx := 0
  3134  	for iNdEx < l {
  3135  		preIndex := iNdEx
  3136  		var wire uint64
  3137  		for shift := uint(0); ; shift += 7 {
  3138  			if shift >= 64 {
  3139  				return ErrIntOverflowGenerated
  3140  			}
  3141  			if iNdEx >= l {
  3142  				return io.ErrUnexpectedEOF
  3143  			}
  3144  			b := dAtA[iNdEx]
  3145  			iNdEx++
  3146  			wire |= uint64(b&0x7F) << shift
  3147  			if b < 0x80 {
  3148  				break
  3149  			}
  3150  		}
  3151  		fieldNum := int32(wire >> 3)
  3152  		wireType := int(wire & 0x7)
  3153  		if wireType == 4 {
  3154  			return fmt.Errorf("proto: IngressLoadBalancerIngress: wiretype end group for non-group")
  3155  		}
  3156  		if fieldNum <= 0 {
  3157  			return fmt.Errorf("proto: IngressLoadBalancerIngress: illegal tag %d (wire type %d)", fieldNum, wire)
  3158  		}
  3159  		switch fieldNum {
  3160  		case 1:
  3161  			if wireType != 2 {
  3162  				return fmt.Errorf("proto: wrong wireType = %d for field IP", wireType)
  3163  			}
  3164  			var stringLen uint64
  3165  			for shift := uint(0); ; shift += 7 {
  3166  				if shift >= 64 {
  3167  					return ErrIntOverflowGenerated
  3168  				}
  3169  				if iNdEx >= l {
  3170  					return io.ErrUnexpectedEOF
  3171  				}
  3172  				b := dAtA[iNdEx]
  3173  				iNdEx++
  3174  				stringLen |= uint64(b&0x7F) << shift
  3175  				if b < 0x80 {
  3176  					break
  3177  				}
  3178  			}
  3179  			intStringLen := int(stringLen)
  3180  			if intStringLen < 0 {
  3181  				return ErrInvalidLengthGenerated
  3182  			}
  3183  			postIndex := iNdEx + intStringLen
  3184  			if postIndex < 0 {
  3185  				return ErrInvalidLengthGenerated
  3186  			}
  3187  			if postIndex > l {
  3188  				return io.ErrUnexpectedEOF
  3189  			}
  3190  			m.IP = string(dAtA[iNdEx:postIndex])
  3191  			iNdEx = postIndex
  3192  		case 2:
  3193  			if wireType != 2 {
  3194  				return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType)
  3195  			}
  3196  			var stringLen uint64
  3197  			for shift := uint(0); ; shift += 7 {
  3198  				if shift >= 64 {
  3199  					return ErrIntOverflowGenerated
  3200  				}
  3201  				if iNdEx >= l {
  3202  					return io.ErrUnexpectedEOF
  3203  				}
  3204  				b := dAtA[iNdEx]
  3205  				iNdEx++
  3206  				stringLen |= uint64(b&0x7F) << shift
  3207  				if b < 0x80 {
  3208  					break
  3209  				}
  3210  			}
  3211  			intStringLen := int(stringLen)
  3212  			if intStringLen < 0 {
  3213  				return ErrInvalidLengthGenerated
  3214  			}
  3215  			postIndex := iNdEx + intStringLen
  3216  			if postIndex < 0 {
  3217  				return ErrInvalidLengthGenerated
  3218  			}
  3219  			if postIndex > l {
  3220  				return io.ErrUnexpectedEOF
  3221  			}
  3222  			m.Hostname = string(dAtA[iNdEx:postIndex])
  3223  			iNdEx = postIndex
  3224  		case 4:
  3225  			if wireType != 2 {
  3226  				return fmt.Errorf("proto: wrong wireType = %d for field Ports", wireType)
  3227  			}
  3228  			var msglen int
  3229  			for shift := uint(0); ; shift += 7 {
  3230  				if shift >= 64 {
  3231  					return ErrIntOverflowGenerated
  3232  				}
  3233  				if iNdEx >= l {
  3234  					return io.ErrUnexpectedEOF
  3235  				}
  3236  				b := dAtA[iNdEx]
  3237  				iNdEx++
  3238  				msglen |= int(b&0x7F) << shift
  3239  				if b < 0x80 {
  3240  					break
  3241  				}
  3242  			}
  3243  			if msglen < 0 {
  3244  				return ErrInvalidLengthGenerated
  3245  			}
  3246  			postIndex := iNdEx + msglen
  3247  			if postIndex < 0 {
  3248  				return ErrInvalidLengthGenerated
  3249  			}
  3250  			if postIndex > l {
  3251  				return io.ErrUnexpectedEOF
  3252  			}
  3253  			m.Ports = append(m.Ports, IngressPortStatus{})
  3254  			if err := m.Ports[len(m.Ports)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  3255  				return err
  3256  			}
  3257  			iNdEx = postIndex
  3258  		default:
  3259  			iNdEx = preIndex
  3260  			skippy, err := skipGenerated(dAtA[iNdEx:])
  3261  			if err != nil {
  3262  				return err
  3263  			}
  3264  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  3265  				return ErrInvalidLengthGenerated
  3266  			}
  3267  			if (iNdEx + skippy) > l {
  3268  				return io.ErrUnexpectedEOF
  3269  			}
  3270  			iNdEx += skippy
  3271  		}
  3272  	}
  3273  
  3274  	if iNdEx > l {
  3275  		return io.ErrUnexpectedEOF
  3276  	}
  3277  	return nil
  3278  }
  3279  func (m *IngressLoadBalancerStatus) Unmarshal(dAtA []byte) error {
  3280  	l := len(dAtA)
  3281  	iNdEx := 0
  3282  	for iNdEx < l {
  3283  		preIndex := iNdEx
  3284  		var wire uint64
  3285  		for shift := uint(0); ; shift += 7 {
  3286  			if shift >= 64 {
  3287  				return ErrIntOverflowGenerated
  3288  			}
  3289  			if iNdEx >= l {
  3290  				return io.ErrUnexpectedEOF
  3291  			}
  3292  			b := dAtA[iNdEx]
  3293  			iNdEx++
  3294  			wire |= uint64(b&0x7F) << shift
  3295  			if b < 0x80 {
  3296  				break
  3297  			}
  3298  		}
  3299  		fieldNum := int32(wire >> 3)
  3300  		wireType := int(wire & 0x7)
  3301  		if wireType == 4 {
  3302  			return fmt.Errorf("proto: IngressLoadBalancerStatus: wiretype end group for non-group")
  3303  		}
  3304  		if fieldNum <= 0 {
  3305  			return fmt.Errorf("proto: IngressLoadBalancerStatus: illegal tag %d (wire type %d)", fieldNum, wire)
  3306  		}
  3307  		switch fieldNum {
  3308  		case 1:
  3309  			if wireType != 2 {
  3310  				return fmt.Errorf("proto: wrong wireType = %d for field Ingress", wireType)
  3311  			}
  3312  			var msglen int
  3313  			for shift := uint(0); ; shift += 7 {
  3314  				if shift >= 64 {
  3315  					return ErrIntOverflowGenerated
  3316  				}
  3317  				if iNdEx >= l {
  3318  					return io.ErrUnexpectedEOF
  3319  				}
  3320  				b := dAtA[iNdEx]
  3321  				iNdEx++
  3322  				msglen |= int(b&0x7F) << shift
  3323  				if b < 0x80 {
  3324  					break
  3325  				}
  3326  			}
  3327  			if msglen < 0 {
  3328  				return ErrInvalidLengthGenerated
  3329  			}
  3330  			postIndex := iNdEx + msglen
  3331  			if postIndex < 0 {
  3332  				return ErrInvalidLengthGenerated
  3333  			}
  3334  			if postIndex > l {
  3335  				return io.ErrUnexpectedEOF
  3336  			}
  3337  			m.Ingress = append(m.Ingress, IngressLoadBalancerIngress{})
  3338  			if err := m.Ingress[len(m.Ingress)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  3339  				return err
  3340  			}
  3341  			iNdEx = postIndex
  3342  		default:
  3343  			iNdEx = preIndex
  3344  			skippy, err := skipGenerated(dAtA[iNdEx:])
  3345  			if err != nil {
  3346  				return err
  3347  			}
  3348  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  3349  				return ErrInvalidLengthGenerated
  3350  			}
  3351  			if (iNdEx + skippy) > l {
  3352  				return io.ErrUnexpectedEOF
  3353  			}
  3354  			iNdEx += skippy
  3355  		}
  3356  	}
  3357  
  3358  	if iNdEx > l {
  3359  		return io.ErrUnexpectedEOF
  3360  	}
  3361  	return nil
  3362  }
  3363  func (m *IngressPortStatus) Unmarshal(dAtA []byte) error {
  3364  	l := len(dAtA)
  3365  	iNdEx := 0
  3366  	for iNdEx < l {
  3367  		preIndex := iNdEx
  3368  		var wire uint64
  3369  		for shift := uint(0); ; shift += 7 {
  3370  			if shift >= 64 {
  3371  				return ErrIntOverflowGenerated
  3372  			}
  3373  			if iNdEx >= l {
  3374  				return io.ErrUnexpectedEOF
  3375  			}
  3376  			b := dAtA[iNdEx]
  3377  			iNdEx++
  3378  			wire |= uint64(b&0x7F) << shift
  3379  			if b < 0x80 {
  3380  				break
  3381  			}
  3382  		}
  3383  		fieldNum := int32(wire >> 3)
  3384  		wireType := int(wire & 0x7)
  3385  		if wireType == 4 {
  3386  			return fmt.Errorf("proto: IngressPortStatus: wiretype end group for non-group")
  3387  		}
  3388  		if fieldNum <= 0 {
  3389  			return fmt.Errorf("proto: IngressPortStatus: illegal tag %d (wire type %d)", fieldNum, wire)
  3390  		}
  3391  		switch fieldNum {
  3392  		case 1:
  3393  			if wireType != 0 {
  3394  				return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
  3395  			}
  3396  			m.Port = 0
  3397  			for shift := uint(0); ; shift += 7 {
  3398  				if shift >= 64 {
  3399  					return ErrIntOverflowGenerated
  3400  				}
  3401  				if iNdEx >= l {
  3402  					return io.ErrUnexpectedEOF
  3403  				}
  3404  				b := dAtA[iNdEx]
  3405  				iNdEx++
  3406  				m.Port |= int32(b&0x7F) << shift
  3407  				if b < 0x80 {
  3408  					break
  3409  				}
  3410  			}
  3411  		case 2:
  3412  			if wireType != 2 {
  3413  				return fmt.Errorf("proto: wrong wireType = %d for field Protocol", wireType)
  3414  			}
  3415  			var stringLen uint64
  3416  			for shift := uint(0); ; shift += 7 {
  3417  				if shift >= 64 {
  3418  					return ErrIntOverflowGenerated
  3419  				}
  3420  				if iNdEx >= l {
  3421  					return io.ErrUnexpectedEOF
  3422  				}
  3423  				b := dAtA[iNdEx]
  3424  				iNdEx++
  3425  				stringLen |= uint64(b&0x7F) << shift
  3426  				if b < 0x80 {
  3427  					break
  3428  				}
  3429  			}
  3430  			intStringLen := int(stringLen)
  3431  			if intStringLen < 0 {
  3432  				return ErrInvalidLengthGenerated
  3433  			}
  3434  			postIndex := iNdEx + intStringLen
  3435  			if postIndex < 0 {
  3436  				return ErrInvalidLengthGenerated
  3437  			}
  3438  			if postIndex > l {
  3439  				return io.ErrUnexpectedEOF
  3440  			}
  3441  			m.Protocol = k8s_io_api_core_v1.Protocol(dAtA[iNdEx:postIndex])
  3442  			iNdEx = postIndex
  3443  		case 3:
  3444  			if wireType != 2 {
  3445  				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
  3446  			}
  3447  			var stringLen uint64
  3448  			for shift := uint(0); ; shift += 7 {
  3449  				if shift >= 64 {
  3450  					return ErrIntOverflowGenerated
  3451  				}
  3452  				if iNdEx >= l {
  3453  					return io.ErrUnexpectedEOF
  3454  				}
  3455  				b := dAtA[iNdEx]
  3456  				iNdEx++
  3457  				stringLen |= uint64(b&0x7F) << shift
  3458  				if b < 0x80 {
  3459  					break
  3460  				}
  3461  			}
  3462  			intStringLen := int(stringLen)
  3463  			if intStringLen < 0 {
  3464  				return ErrInvalidLengthGenerated
  3465  			}
  3466  			postIndex := iNdEx + intStringLen
  3467  			if postIndex < 0 {
  3468  				return ErrInvalidLengthGenerated
  3469  			}
  3470  			if postIndex > l {
  3471  				return io.ErrUnexpectedEOF
  3472  			}
  3473  			s := string(dAtA[iNdEx:postIndex])
  3474  			m.Error = &s
  3475  			iNdEx = postIndex
  3476  		default:
  3477  			iNdEx = preIndex
  3478  			skippy, err := skipGenerated(dAtA[iNdEx:])
  3479  			if err != nil {
  3480  				return err
  3481  			}
  3482  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  3483  				return ErrInvalidLengthGenerated
  3484  			}
  3485  			if (iNdEx + skippy) > l {
  3486  				return io.ErrUnexpectedEOF
  3487  			}
  3488  			iNdEx += skippy
  3489  		}
  3490  	}
  3491  
  3492  	if iNdEx > l {
  3493  		return io.ErrUnexpectedEOF
  3494  	}
  3495  	return nil
  3496  }
  3497  func (m *IngressRule) Unmarshal(dAtA []byte) error {
  3498  	l := len(dAtA)
  3499  	iNdEx := 0
  3500  	for iNdEx < l {
  3501  		preIndex := iNdEx
  3502  		var wire uint64
  3503  		for shift := uint(0); ; shift += 7 {
  3504  			if shift >= 64 {
  3505  				return ErrIntOverflowGenerated
  3506  			}
  3507  			if iNdEx >= l {
  3508  				return io.ErrUnexpectedEOF
  3509  			}
  3510  			b := dAtA[iNdEx]
  3511  			iNdEx++
  3512  			wire |= uint64(b&0x7F) << shift
  3513  			if b < 0x80 {
  3514  				break
  3515  			}
  3516  		}
  3517  		fieldNum := int32(wire >> 3)
  3518  		wireType := int(wire & 0x7)
  3519  		if wireType == 4 {
  3520  			return fmt.Errorf("proto: IngressRule: wiretype end group for non-group")
  3521  		}
  3522  		if fieldNum <= 0 {
  3523  			return fmt.Errorf("proto: IngressRule: illegal tag %d (wire type %d)", fieldNum, wire)
  3524  		}
  3525  		switch fieldNum {
  3526  		case 1:
  3527  			if wireType != 2 {
  3528  				return fmt.Errorf("proto: wrong wireType = %d for field Host", wireType)
  3529  			}
  3530  			var stringLen uint64
  3531  			for shift := uint(0); ; shift += 7 {
  3532  				if shift >= 64 {
  3533  					return ErrIntOverflowGenerated
  3534  				}
  3535  				if iNdEx >= l {
  3536  					return io.ErrUnexpectedEOF
  3537  				}
  3538  				b := dAtA[iNdEx]
  3539  				iNdEx++
  3540  				stringLen |= uint64(b&0x7F) << shift
  3541  				if b < 0x80 {
  3542  					break
  3543  				}
  3544  			}
  3545  			intStringLen := int(stringLen)
  3546  			if intStringLen < 0 {
  3547  				return ErrInvalidLengthGenerated
  3548  			}
  3549  			postIndex := iNdEx + intStringLen
  3550  			if postIndex < 0 {
  3551  				return ErrInvalidLengthGenerated
  3552  			}
  3553  			if postIndex > l {
  3554  				return io.ErrUnexpectedEOF
  3555  			}
  3556  			m.Host = string(dAtA[iNdEx:postIndex])
  3557  			iNdEx = postIndex
  3558  		case 2:
  3559  			if wireType != 2 {
  3560  				return fmt.Errorf("proto: wrong wireType = %d for field IngressRuleValue", wireType)
  3561  			}
  3562  			var msglen int
  3563  			for shift := uint(0); ; shift += 7 {
  3564  				if shift >= 64 {
  3565  					return ErrIntOverflowGenerated
  3566  				}
  3567  				if iNdEx >= l {
  3568  					return io.ErrUnexpectedEOF
  3569  				}
  3570  				b := dAtA[iNdEx]
  3571  				iNdEx++
  3572  				msglen |= int(b&0x7F) << shift
  3573  				if b < 0x80 {
  3574  					break
  3575  				}
  3576  			}
  3577  			if msglen < 0 {
  3578  				return ErrInvalidLengthGenerated
  3579  			}
  3580  			postIndex := iNdEx + msglen
  3581  			if postIndex < 0 {
  3582  				return ErrInvalidLengthGenerated
  3583  			}
  3584  			if postIndex > l {
  3585  				return io.ErrUnexpectedEOF
  3586  			}
  3587  			if err := m.IngressRuleValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  3588  				return err
  3589  			}
  3590  			iNdEx = postIndex
  3591  		default:
  3592  			iNdEx = preIndex
  3593  			skippy, err := skipGenerated(dAtA[iNdEx:])
  3594  			if err != nil {
  3595  				return err
  3596  			}
  3597  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  3598  				return ErrInvalidLengthGenerated
  3599  			}
  3600  			if (iNdEx + skippy) > l {
  3601  				return io.ErrUnexpectedEOF
  3602  			}
  3603  			iNdEx += skippy
  3604  		}
  3605  	}
  3606  
  3607  	if iNdEx > l {
  3608  		return io.ErrUnexpectedEOF
  3609  	}
  3610  	return nil
  3611  }
  3612  func (m *IngressRuleValue) Unmarshal(dAtA []byte) error {
  3613  	l := len(dAtA)
  3614  	iNdEx := 0
  3615  	for iNdEx < l {
  3616  		preIndex := iNdEx
  3617  		var wire uint64
  3618  		for shift := uint(0); ; shift += 7 {
  3619  			if shift >= 64 {
  3620  				return ErrIntOverflowGenerated
  3621  			}
  3622  			if iNdEx >= l {
  3623  				return io.ErrUnexpectedEOF
  3624  			}
  3625  			b := dAtA[iNdEx]
  3626  			iNdEx++
  3627  			wire |= uint64(b&0x7F) << shift
  3628  			if b < 0x80 {
  3629  				break
  3630  			}
  3631  		}
  3632  		fieldNum := int32(wire >> 3)
  3633  		wireType := int(wire & 0x7)
  3634  		if wireType == 4 {
  3635  			return fmt.Errorf("proto: IngressRuleValue: wiretype end group for non-group")
  3636  		}
  3637  		if fieldNum <= 0 {
  3638  			return fmt.Errorf("proto: IngressRuleValue: illegal tag %d (wire type %d)", fieldNum, wire)
  3639  		}
  3640  		switch fieldNum {
  3641  		case 1:
  3642  			if wireType != 2 {
  3643  				return fmt.Errorf("proto: wrong wireType = %d for field HTTP", wireType)
  3644  			}
  3645  			var msglen int
  3646  			for shift := uint(0); ; shift += 7 {
  3647  				if shift >= 64 {
  3648  					return ErrIntOverflowGenerated
  3649  				}
  3650  				if iNdEx >= l {
  3651  					return io.ErrUnexpectedEOF
  3652  				}
  3653  				b := dAtA[iNdEx]
  3654  				iNdEx++
  3655  				msglen |= int(b&0x7F) << shift
  3656  				if b < 0x80 {
  3657  					break
  3658  				}
  3659  			}
  3660  			if msglen < 0 {
  3661  				return ErrInvalidLengthGenerated
  3662  			}
  3663  			postIndex := iNdEx + msglen
  3664  			if postIndex < 0 {
  3665  				return ErrInvalidLengthGenerated
  3666  			}
  3667  			if postIndex > l {
  3668  				return io.ErrUnexpectedEOF
  3669  			}
  3670  			if m.HTTP == nil {
  3671  				m.HTTP = &HTTPIngressRuleValue{}
  3672  			}
  3673  			if err := m.HTTP.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  3674  				return err
  3675  			}
  3676  			iNdEx = postIndex
  3677  		default:
  3678  			iNdEx = preIndex
  3679  			skippy, err := skipGenerated(dAtA[iNdEx:])
  3680  			if err != nil {
  3681  				return err
  3682  			}
  3683  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  3684  				return ErrInvalidLengthGenerated
  3685  			}
  3686  			if (iNdEx + skippy) > l {
  3687  				return io.ErrUnexpectedEOF
  3688  			}
  3689  			iNdEx += skippy
  3690  		}
  3691  	}
  3692  
  3693  	if iNdEx > l {
  3694  		return io.ErrUnexpectedEOF
  3695  	}
  3696  	return nil
  3697  }
  3698  func (m *IngressSpec) Unmarshal(dAtA []byte) error {
  3699  	l := len(dAtA)
  3700  	iNdEx := 0
  3701  	for iNdEx < l {
  3702  		preIndex := iNdEx
  3703  		var wire uint64
  3704  		for shift := uint(0); ; shift += 7 {
  3705  			if shift >= 64 {
  3706  				return ErrIntOverflowGenerated
  3707  			}
  3708  			if iNdEx >= l {
  3709  				return io.ErrUnexpectedEOF
  3710  			}
  3711  			b := dAtA[iNdEx]
  3712  			iNdEx++
  3713  			wire |= uint64(b&0x7F) << shift
  3714  			if b < 0x80 {
  3715  				break
  3716  			}
  3717  		}
  3718  		fieldNum := int32(wire >> 3)
  3719  		wireType := int(wire & 0x7)
  3720  		if wireType == 4 {
  3721  			return fmt.Errorf("proto: IngressSpec: wiretype end group for non-group")
  3722  		}
  3723  		if fieldNum <= 0 {
  3724  			return fmt.Errorf("proto: IngressSpec: illegal tag %d (wire type %d)", fieldNum, wire)
  3725  		}
  3726  		switch fieldNum {
  3727  		case 1:
  3728  			if wireType != 2 {
  3729  				return fmt.Errorf("proto: wrong wireType = %d for field Backend", wireType)
  3730  			}
  3731  			var msglen int
  3732  			for shift := uint(0); ; shift += 7 {
  3733  				if shift >= 64 {
  3734  					return ErrIntOverflowGenerated
  3735  				}
  3736  				if iNdEx >= l {
  3737  					return io.ErrUnexpectedEOF
  3738  				}
  3739  				b := dAtA[iNdEx]
  3740  				iNdEx++
  3741  				msglen |= int(b&0x7F) << shift
  3742  				if b < 0x80 {
  3743  					break
  3744  				}
  3745  			}
  3746  			if msglen < 0 {
  3747  				return ErrInvalidLengthGenerated
  3748  			}
  3749  			postIndex := iNdEx + msglen
  3750  			if postIndex < 0 {
  3751  				return ErrInvalidLengthGenerated
  3752  			}
  3753  			if postIndex > l {
  3754  				return io.ErrUnexpectedEOF
  3755  			}
  3756  			if m.Backend == nil {
  3757  				m.Backend = &IngressBackend{}
  3758  			}
  3759  			if err := m.Backend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  3760  				return err
  3761  			}
  3762  			iNdEx = postIndex
  3763  		case 2:
  3764  			if wireType != 2 {
  3765  				return fmt.Errorf("proto: wrong wireType = %d for field TLS", wireType)
  3766  			}
  3767  			var msglen int
  3768  			for shift := uint(0); ; shift += 7 {
  3769  				if shift >= 64 {
  3770  					return ErrIntOverflowGenerated
  3771  				}
  3772  				if iNdEx >= l {
  3773  					return io.ErrUnexpectedEOF
  3774  				}
  3775  				b := dAtA[iNdEx]
  3776  				iNdEx++
  3777  				msglen |= int(b&0x7F) << shift
  3778  				if b < 0x80 {
  3779  					break
  3780  				}
  3781  			}
  3782  			if msglen < 0 {
  3783  				return ErrInvalidLengthGenerated
  3784  			}
  3785  			postIndex := iNdEx + msglen
  3786  			if postIndex < 0 {
  3787  				return ErrInvalidLengthGenerated
  3788  			}
  3789  			if postIndex > l {
  3790  				return io.ErrUnexpectedEOF
  3791  			}
  3792  			m.TLS = append(m.TLS, IngressTLS{})
  3793  			if err := m.TLS[len(m.TLS)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  3794  				return err
  3795  			}
  3796  			iNdEx = postIndex
  3797  		case 3:
  3798  			if wireType != 2 {
  3799  				return fmt.Errorf("proto: wrong wireType = %d for field Rules", wireType)
  3800  			}
  3801  			var msglen int
  3802  			for shift := uint(0); ; shift += 7 {
  3803  				if shift >= 64 {
  3804  					return ErrIntOverflowGenerated
  3805  				}
  3806  				if iNdEx >= l {
  3807  					return io.ErrUnexpectedEOF
  3808  				}
  3809  				b := dAtA[iNdEx]
  3810  				iNdEx++
  3811  				msglen |= int(b&0x7F) << shift
  3812  				if b < 0x80 {
  3813  					break
  3814  				}
  3815  			}
  3816  			if msglen < 0 {
  3817  				return ErrInvalidLengthGenerated
  3818  			}
  3819  			postIndex := iNdEx + msglen
  3820  			if postIndex < 0 {
  3821  				return ErrInvalidLengthGenerated
  3822  			}
  3823  			if postIndex > l {
  3824  				return io.ErrUnexpectedEOF
  3825  			}
  3826  			m.Rules = append(m.Rules, IngressRule{})
  3827  			if err := m.Rules[len(m.Rules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  3828  				return err
  3829  			}
  3830  			iNdEx = postIndex
  3831  		case 4:
  3832  			if wireType != 2 {
  3833  				return fmt.Errorf("proto: wrong wireType = %d for field IngressClassName", wireType)
  3834  			}
  3835  			var stringLen uint64
  3836  			for shift := uint(0); ; shift += 7 {
  3837  				if shift >= 64 {
  3838  					return ErrIntOverflowGenerated
  3839  				}
  3840  				if iNdEx >= l {
  3841  					return io.ErrUnexpectedEOF
  3842  				}
  3843  				b := dAtA[iNdEx]
  3844  				iNdEx++
  3845  				stringLen |= uint64(b&0x7F) << shift
  3846  				if b < 0x80 {
  3847  					break
  3848  				}
  3849  			}
  3850  			intStringLen := int(stringLen)
  3851  			if intStringLen < 0 {
  3852  				return ErrInvalidLengthGenerated
  3853  			}
  3854  			postIndex := iNdEx + intStringLen
  3855  			if postIndex < 0 {
  3856  				return ErrInvalidLengthGenerated
  3857  			}
  3858  			if postIndex > l {
  3859  				return io.ErrUnexpectedEOF
  3860  			}
  3861  			s := string(dAtA[iNdEx:postIndex])
  3862  			m.IngressClassName = &s
  3863  			iNdEx = postIndex
  3864  		default:
  3865  			iNdEx = preIndex
  3866  			skippy, err := skipGenerated(dAtA[iNdEx:])
  3867  			if err != nil {
  3868  				return err
  3869  			}
  3870  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  3871  				return ErrInvalidLengthGenerated
  3872  			}
  3873  			if (iNdEx + skippy) > l {
  3874  				return io.ErrUnexpectedEOF
  3875  			}
  3876  			iNdEx += skippy
  3877  		}
  3878  	}
  3879  
  3880  	if iNdEx > l {
  3881  		return io.ErrUnexpectedEOF
  3882  	}
  3883  	return nil
  3884  }
  3885  func (m *IngressStatus) Unmarshal(dAtA []byte) error {
  3886  	l := len(dAtA)
  3887  	iNdEx := 0
  3888  	for iNdEx < l {
  3889  		preIndex := iNdEx
  3890  		var wire uint64
  3891  		for shift := uint(0); ; shift += 7 {
  3892  			if shift >= 64 {
  3893  				return ErrIntOverflowGenerated
  3894  			}
  3895  			if iNdEx >= l {
  3896  				return io.ErrUnexpectedEOF
  3897  			}
  3898  			b := dAtA[iNdEx]
  3899  			iNdEx++
  3900  			wire |= uint64(b&0x7F) << shift
  3901  			if b < 0x80 {
  3902  				break
  3903  			}
  3904  		}
  3905  		fieldNum := int32(wire >> 3)
  3906  		wireType := int(wire & 0x7)
  3907  		if wireType == 4 {
  3908  			return fmt.Errorf("proto: IngressStatus: wiretype end group for non-group")
  3909  		}
  3910  		if fieldNum <= 0 {
  3911  			return fmt.Errorf("proto: IngressStatus: illegal tag %d (wire type %d)", fieldNum, wire)
  3912  		}
  3913  		switch fieldNum {
  3914  		case 1:
  3915  			if wireType != 2 {
  3916  				return fmt.Errorf("proto: wrong wireType = %d for field LoadBalancer", wireType)
  3917  			}
  3918  			var msglen int
  3919  			for shift := uint(0); ; shift += 7 {
  3920  				if shift >= 64 {
  3921  					return ErrIntOverflowGenerated
  3922  				}
  3923  				if iNdEx >= l {
  3924  					return io.ErrUnexpectedEOF
  3925  				}
  3926  				b := dAtA[iNdEx]
  3927  				iNdEx++
  3928  				msglen |= int(b&0x7F) << shift
  3929  				if b < 0x80 {
  3930  					break
  3931  				}
  3932  			}
  3933  			if msglen < 0 {
  3934  				return ErrInvalidLengthGenerated
  3935  			}
  3936  			postIndex := iNdEx + msglen
  3937  			if postIndex < 0 {
  3938  				return ErrInvalidLengthGenerated
  3939  			}
  3940  			if postIndex > l {
  3941  				return io.ErrUnexpectedEOF
  3942  			}
  3943  			if err := m.LoadBalancer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  3944  				return err
  3945  			}
  3946  			iNdEx = postIndex
  3947  		default:
  3948  			iNdEx = preIndex
  3949  			skippy, err := skipGenerated(dAtA[iNdEx:])
  3950  			if err != nil {
  3951  				return err
  3952  			}
  3953  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  3954  				return ErrInvalidLengthGenerated
  3955  			}
  3956  			if (iNdEx + skippy) > l {
  3957  				return io.ErrUnexpectedEOF
  3958  			}
  3959  			iNdEx += skippy
  3960  		}
  3961  	}
  3962  
  3963  	if iNdEx > l {
  3964  		return io.ErrUnexpectedEOF
  3965  	}
  3966  	return nil
  3967  }
  3968  func (m *IngressTLS) Unmarshal(dAtA []byte) error {
  3969  	l := len(dAtA)
  3970  	iNdEx := 0
  3971  	for iNdEx < l {
  3972  		preIndex := iNdEx
  3973  		var wire uint64
  3974  		for shift := uint(0); ; shift += 7 {
  3975  			if shift >= 64 {
  3976  				return ErrIntOverflowGenerated
  3977  			}
  3978  			if iNdEx >= l {
  3979  				return io.ErrUnexpectedEOF
  3980  			}
  3981  			b := dAtA[iNdEx]
  3982  			iNdEx++
  3983  			wire |= uint64(b&0x7F) << shift
  3984  			if b < 0x80 {
  3985  				break
  3986  			}
  3987  		}
  3988  		fieldNum := int32(wire >> 3)
  3989  		wireType := int(wire & 0x7)
  3990  		if wireType == 4 {
  3991  			return fmt.Errorf("proto: IngressTLS: wiretype end group for non-group")
  3992  		}
  3993  		if fieldNum <= 0 {
  3994  			return fmt.Errorf("proto: IngressTLS: illegal tag %d (wire type %d)", fieldNum, wire)
  3995  		}
  3996  		switch fieldNum {
  3997  		case 1:
  3998  			if wireType != 2 {
  3999  				return fmt.Errorf("proto: wrong wireType = %d for field Hosts", wireType)
  4000  			}
  4001  			var stringLen uint64
  4002  			for shift := uint(0); ; shift += 7 {
  4003  				if shift >= 64 {
  4004  					return ErrIntOverflowGenerated
  4005  				}
  4006  				if iNdEx >= l {
  4007  					return io.ErrUnexpectedEOF
  4008  				}
  4009  				b := dAtA[iNdEx]
  4010  				iNdEx++
  4011  				stringLen |= uint64(b&0x7F) << shift
  4012  				if b < 0x80 {
  4013  					break
  4014  				}
  4015  			}
  4016  			intStringLen := int(stringLen)
  4017  			if intStringLen < 0 {
  4018  				return ErrInvalidLengthGenerated
  4019  			}
  4020  			postIndex := iNdEx + intStringLen
  4021  			if postIndex < 0 {
  4022  				return ErrInvalidLengthGenerated
  4023  			}
  4024  			if postIndex > l {
  4025  				return io.ErrUnexpectedEOF
  4026  			}
  4027  			m.Hosts = append(m.Hosts, string(dAtA[iNdEx:postIndex]))
  4028  			iNdEx = postIndex
  4029  		case 2:
  4030  			if wireType != 2 {
  4031  				return fmt.Errorf("proto: wrong wireType = %d for field SecretName", wireType)
  4032  			}
  4033  			var stringLen uint64
  4034  			for shift := uint(0); ; shift += 7 {
  4035  				if shift >= 64 {
  4036  					return ErrIntOverflowGenerated
  4037  				}
  4038  				if iNdEx >= l {
  4039  					return io.ErrUnexpectedEOF
  4040  				}
  4041  				b := dAtA[iNdEx]
  4042  				iNdEx++
  4043  				stringLen |= uint64(b&0x7F) << shift
  4044  				if b < 0x80 {
  4045  					break
  4046  				}
  4047  			}
  4048  			intStringLen := int(stringLen)
  4049  			if intStringLen < 0 {
  4050  				return ErrInvalidLengthGenerated
  4051  			}
  4052  			postIndex := iNdEx + intStringLen
  4053  			if postIndex < 0 {
  4054  				return ErrInvalidLengthGenerated
  4055  			}
  4056  			if postIndex > l {
  4057  				return io.ErrUnexpectedEOF
  4058  			}
  4059  			m.SecretName = string(dAtA[iNdEx:postIndex])
  4060  			iNdEx = postIndex
  4061  		default:
  4062  			iNdEx = preIndex
  4063  			skippy, err := skipGenerated(dAtA[iNdEx:])
  4064  			if err != nil {
  4065  				return err
  4066  			}
  4067  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  4068  				return ErrInvalidLengthGenerated
  4069  			}
  4070  			if (iNdEx + skippy) > l {
  4071  				return io.ErrUnexpectedEOF
  4072  			}
  4073  			iNdEx += skippy
  4074  		}
  4075  	}
  4076  
  4077  	if iNdEx > l {
  4078  		return io.ErrUnexpectedEOF
  4079  	}
  4080  	return nil
  4081  }
  4082  func skipGenerated(dAtA []byte) (n int, err error) {
  4083  	l := len(dAtA)
  4084  	iNdEx := 0
  4085  	depth := 0
  4086  	for iNdEx < l {
  4087  		var wire uint64
  4088  		for shift := uint(0); ; shift += 7 {
  4089  			if shift >= 64 {
  4090  				return 0, ErrIntOverflowGenerated
  4091  			}
  4092  			if iNdEx >= l {
  4093  				return 0, io.ErrUnexpectedEOF
  4094  			}
  4095  			b := dAtA[iNdEx]
  4096  			iNdEx++
  4097  			wire |= (uint64(b) & 0x7F) << shift
  4098  			if b < 0x80 {
  4099  				break
  4100  			}
  4101  		}
  4102  		wireType := int(wire & 0x7)
  4103  		switch wireType {
  4104  		case 0:
  4105  			for shift := uint(0); ; shift += 7 {
  4106  				if shift >= 64 {
  4107  					return 0, ErrIntOverflowGenerated
  4108  				}
  4109  				if iNdEx >= l {
  4110  					return 0, io.ErrUnexpectedEOF
  4111  				}
  4112  				iNdEx++
  4113  				if dAtA[iNdEx-1] < 0x80 {
  4114  					break
  4115  				}
  4116  			}
  4117  		case 1:
  4118  			iNdEx += 8
  4119  		case 2:
  4120  			var length int
  4121  			for shift := uint(0); ; shift += 7 {
  4122  				if shift >= 64 {
  4123  					return 0, ErrIntOverflowGenerated
  4124  				}
  4125  				if iNdEx >= l {
  4126  					return 0, io.ErrUnexpectedEOF
  4127  				}
  4128  				b := dAtA[iNdEx]
  4129  				iNdEx++
  4130  				length |= (int(b) & 0x7F) << shift
  4131  				if b < 0x80 {
  4132  					break
  4133  				}
  4134  			}
  4135  			if length < 0 {
  4136  				return 0, ErrInvalidLengthGenerated
  4137  			}
  4138  			iNdEx += length
  4139  		case 3:
  4140  			depth++
  4141  		case 4:
  4142  			if depth == 0 {
  4143  				return 0, ErrUnexpectedEndOfGroupGenerated
  4144  			}
  4145  			depth--
  4146  		case 5:
  4147  			iNdEx += 4
  4148  		default:
  4149  			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
  4150  		}
  4151  		if iNdEx < 0 {
  4152  			return 0, ErrInvalidLengthGenerated
  4153  		}
  4154  		if depth == 0 {
  4155  			return iNdEx, nil
  4156  		}
  4157  	}
  4158  	return 0, io.ErrUnexpectedEOF
  4159  }
  4160  
  4161  var (
  4162  	ErrInvalidLengthGenerated        = fmt.Errorf("proto: negative length found during unmarshaling")
  4163  	ErrIntOverflowGenerated          = fmt.Errorf("proto: integer overflow")
  4164  	ErrUnexpectedEndOfGroupGenerated = fmt.Errorf("proto: unexpected end of group")
  4165  )
  4166  

View as plain text