types.generated.go

/*
Copyright 2016 The Kubernetes Authors.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

// ************************************************************
// DO NOT EDIT.
// THIS FILE IS AUTO-GENERATED BY codecgen.
// ************************************************************

package v1alpha1

import (
	"errors"
	"fmt"
	codec1978 "github.com/ugorji/go/codec"
	pkg2_v1 "k8s.io/kubernetes/pkg/api/v1"
	pkg1_v1 "k8s.io/kubernetes/pkg/apis/meta/v1"
	pkg4_runtime "k8s.io/kubernetes/pkg/runtime"
	pkg3_types "k8s.io/kubernetes/pkg/types"
	"reflect"
	"runtime"
	time "time"
)

const (
	// ----- content types ----
	codecSelferC_UTF81234 = 1
	codecSelferC_RAW1234  = 0
	// ----- value types used ----
	codecSelferValueTypeArray1234 = 10
	codecSelferValueTypeMap1234   = 9
	// ----- containerStateValues ----
	codecSelfer_containerMapKey1234    = 2
	codecSelfer_containerMapValue1234  = 3
	codecSelfer_containerMapEnd1234    = 4
	codecSelfer_containerArrayElem1234 = 6
	codecSelfer_containerArrayEnd1234  = 7
)

var (
	codecSelferBitsize1234                         = uint8(reflect.TypeOf(uint(0)).Bits())
	codecSelferOnlyMapOrArrayEncodeToStructErr1234 = errors.New(`only encoded map or array can be decoded into a struct`)
)

type codecSelfer1234 struct{}

func init() {
	if codec1978.GenVersion != 5 {
		_, file, _, _ := runtime.Caller(0)
		err := fmt.Errorf("codecgen version mismatch: current: %v, need %v. Re-generate file: %v",
			5, codec1978.GenVersion, file)
		panic(err)
	}
	if false { // reference the types, but skip this branch at build/run time
		var v0 pkg2_v1.ObjectMeta
		var v1 pkg1_v1.TypeMeta
		var v2 pkg4_runtime.RawExtension
		var v3 pkg3_types.UID
		var v4 time.Time
		_, _, _, _, _ = v0, v1, v2, v3, v4
	}
}

func (x *Broker) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1 := z.EncBinary()
		_ = yym1
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			var yyq2 [5]bool
			_, _, _ = yysep2, yyq2, yy2arr2
			const yyr2 bool = false
			yyq2[0] = x.Kind != ""
			yyq2[1] = x.APIVersion != ""
			yyq2[2] = true
			var yynn2 int
			if yyr2 || yy2arr2 {
				r.EncodeArrayStart(5)
			} else {
				yynn2 = 2
				for _, b := range yyq2 {
					if b {
						yynn2++
					}
				}
				r.EncodeMapStart(yynn2)
				yynn2 = 0
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq2[0] {
					yym4 := z.EncBinary()
					_ = yym4
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq2[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym5 := z.EncBinary()
					_ = yym5
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq2[1] {
					yym7 := z.EncBinary()
					_ = yym7
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq2[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym8 := z.EncBinary()
					_ = yym8
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq2[2] {
					yy10 := &x.ObjectMeta
					yy10.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq2[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy11 := &x.ObjectMeta
					yy11.CodecEncodeSelf(e)
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy13 := &x.Spec
				yy13.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("spec"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy14 := &x.Spec
				yy14.CodecEncodeSelf(e)
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy16 := &x.Status
				yy16.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("status"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy17 := &x.Status
				yy17.CodecEncodeSelf(e)
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *Broker) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym18 := z.DecBinary()
	_ = yym18
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct19 := r.ContainerType()
		if yyct19 == codecSelferValueTypeMap1234 {
			yyl19 := r.ReadMapStart()
			if yyl19 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl19, d)
			}
		} else if yyct19 == codecSelferValueTypeArray1234 {
			yyl19 := r.ReadArrayStart()
			if yyl19 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl19, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *Broker) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys20Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys20Slc
	var yyhl20 bool = l >= 0
	for yyj20 := 0; ; yyj20++ {
		if yyhl20 {
			if yyj20 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys20Slc = r.DecodeBytes(yys20Slc, true, true)
		yys20 := string(yys20Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys20 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv23 := &x.ObjectMeta
				yyv23.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = BrokerSpec{}
			} else {
				yyv24 := &x.Spec
				yyv24.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = BrokerStatus{}
			} else {
				yyv25 := &x.Status
				yyv25.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys20)
		} // end switch yys20
	} // end for yyj20
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *Broker) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj26 int
	var yyb26 bool
	var yyhl26 bool = l >= 0
	yyj26++
	if yyhl26 {
		yyb26 = yyj26 > l
	} else {
		yyb26 = r.CheckBreak()
	}
	if yyb26 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj26++
	if yyhl26 {
		yyb26 = yyj26 > l
	} else {
		yyb26 = r.CheckBreak()
	}
	if yyb26 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj26++
	if yyhl26 {
		yyb26 = yyj26 > l
	} else {
		yyb26 = r.CheckBreak()
	}
	if yyb26 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv29 := &x.ObjectMeta
		yyv29.CodecDecodeSelf(d)
	}
	yyj26++
	if yyhl26 {
		yyb26 = yyj26 > l
	} else {
		yyb26 = r.CheckBreak()
	}
	if yyb26 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = BrokerSpec{}
	} else {
		yyv30 := &x.Spec
		yyv30.CodecDecodeSelf(d)
	}
	yyj26++
	if yyhl26 {
		yyb26 = yyj26 > l
	} else {
		yyb26 = r.CheckBreak()
	}
	if yyb26 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = BrokerStatus{}
	} else {
		yyv31 := &x.Status
		yyv31.CodecDecodeSelf(d)
	}
	for {
		yyj26++
		if yyhl26 {
			yyb26 = yyj26 > l
		} else {
			yyb26 = r.CheckBreak()
		}
		if yyb26 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj26-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *BrokerList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym32 := z.EncBinary()
		_ = yym32
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep33 := !z.EncBinary()
			yy2arr33 := z.EncBasicHandle().StructToArray
			var yyq33 [4]bool
			_, _, _ = yysep33, yyq33, yy2arr33
			const yyr33 bool = false
			yyq33[0] = x.Kind != ""
			yyq33[1] = x.APIVersion != ""
			yyq33[2] = true
			var yynn33 int
			if yyr33 || yy2arr33 {
				r.EncodeArrayStart(4)
			} else {
				yynn33 = 1
				for _, b := range yyq33 {
					if b {
						yynn33++
					}
				}
				r.EncodeMapStart(yynn33)
				yynn33 = 0
			}
			if yyr33 || yy2arr33 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq33[0] {
					yym35 := z.EncBinary()
					_ = yym35
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq33[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym36 := z.EncBinary()
					_ = yym36
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr33 || yy2arr33 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq33[1] {
					yym38 := z.EncBinary()
					_ = yym38
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq33[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym39 := z.EncBinary()
					_ = yym39
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr33 || yy2arr33 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq33[2] {
					yy41 := &x.ListMeta
					yym42 := z.EncBinary()
					_ = yym42
					if false {
					} else if z.HasExtensions() && z.EncExt(yy41) {
					} else {
						z.EncFallback(yy41)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq33[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy43 := &x.ListMeta
					yym44 := z.EncBinary()
					_ = yym44
					if false {
					} else if z.HasExtensions() && z.EncExt(yy43) {
					} else {
						z.EncFallback(yy43)
					}
				}
			}
			if yyr33 || yy2arr33 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym46 := z.EncBinary()
					_ = yym46
					if false {
					} else {
						h.encSliceBroker(([]Broker)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym47 := z.EncBinary()
					_ = yym47
					if false {
					} else {
						h.encSliceBroker(([]Broker)(x.Items), e)
					}
				}
			}
			if yyr33 || yy2arr33 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *BrokerList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym48 := z.DecBinary()
	_ = yym48
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct49 := r.ContainerType()
		if yyct49 == codecSelferValueTypeMap1234 {
			yyl49 := r.ReadMapStart()
			if yyl49 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl49, d)
			}
		} else if yyct49 == codecSelferValueTypeArray1234 {
			yyl49 := r.ReadArrayStart()
			if yyl49 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl49, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *BrokerList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys50Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys50Slc
	var yyhl50 bool = l >= 0
	for yyj50 := 0; ; yyj50++ {
		if yyhl50 {
			if yyj50 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys50Slc = r.DecodeBytes(yys50Slc, true, true)
		yys50 := string(yys50Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys50 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_v1.ListMeta{}
			} else {
				yyv53 := &x.ListMeta
				yym54 := z.DecBinary()
				_ = yym54
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv53) {
				} else {
					z.DecFallback(yyv53, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv55 := &x.Items
				yym56 := z.DecBinary()
				_ = yym56
				if false {
				} else {
					h.decSliceBroker((*[]Broker)(yyv55), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys50)
		} // end switch yys50
	} // end for yyj50
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *BrokerList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj57 int
	var yyb57 bool
	var yyhl57 bool = l >= 0
	yyj57++
	if yyhl57 {
		yyb57 = yyj57 > l
	} else {
		yyb57 = r.CheckBreak()
	}
	if yyb57 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj57++
	if yyhl57 {
		yyb57 = yyj57 > l
	} else {
		yyb57 = r.CheckBreak()
	}
	if yyb57 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj57++
	if yyhl57 {
		yyb57 = yyj57 > l
	} else {
		yyb57 = r.CheckBreak()
	}
	if yyb57 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_v1.ListMeta{}
	} else {
		yyv60 := &x.ListMeta
		yym61 := z.DecBinary()
		_ = yym61
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv60) {
		} else {
			z.DecFallback(yyv60, false)
		}
	}
	yyj57++
	if yyhl57 {
		yyb57 = yyj57 > l
	} else {
		yyb57 = r.CheckBreak()
	}
	if yyb57 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv62 := &x.Items
		yym63 := z.DecBinary()
		_ = yym63
		if false {
		} else {
			h.decSliceBroker((*[]Broker)(yyv62), d)
		}
	}
	for {
		yyj57++
		if yyhl57 {
			yyb57 = yyj57 > l
		} else {
			yyb57 = r.CheckBreak()
		}
		if yyb57 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj57-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *BrokerSpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym64 := z.EncBinary()
		_ = yym64
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep65 := !z.EncBinary()
			yy2arr65 := z.EncBasicHandle().StructToArray
			var yyq65 [2]bool
			_, _, _ = yysep65, yyq65, yy2arr65
			const yyr65 bool = false
			yyq65[1] = x.AuthSecret != nil
			var yynn65 int
			if yyr65 || yy2arr65 {
				r.EncodeArrayStart(2)
			} else {
				yynn65 = 1
				for _, b := range yyq65 {
					if b {
						yynn65++
					}
				}
				r.EncodeMapStart(yynn65)
				yynn65 = 0
			}
			if yyr65 || yy2arr65 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym67 := z.EncBinary()
				_ = yym67
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.URL))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("url"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym68 := z.EncBinary()
				_ = yym68
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.URL))
				}
			}
			if yyr65 || yy2arr65 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq65[1] {
					if x.AuthSecret == nil {
						r.EncodeNil()
					} else {
						x.AuthSecret.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq65[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("authSecret"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.AuthSecret == nil {
						r.EncodeNil()
					} else {
						x.AuthSecret.CodecEncodeSelf(e)
					}
				}
			}
			if yyr65 || yy2arr65 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *BrokerSpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym70 := z.DecBinary()
	_ = yym70
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct71 := r.ContainerType()
		if yyct71 == codecSelferValueTypeMap1234 {
			yyl71 := r.ReadMapStart()
			if yyl71 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl71, d)
			}
		} else if yyct71 == codecSelferValueTypeArray1234 {
			yyl71 := r.ReadArrayStart()
			if yyl71 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl71, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *BrokerSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys72Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys72Slc
	var yyhl72 bool = l >= 0
	for yyj72 := 0; ; yyj72++ {
		if yyhl72 {
			if yyj72 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys72Slc = r.DecodeBytes(yys72Slc, true, true)
		yys72 := string(yys72Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys72 {
		case "url":
			if r.TryDecodeAsNil() {
				x.URL = ""
			} else {
				x.URL = string(r.DecodeString())
			}
		case "authSecret":
			if r.TryDecodeAsNil() {
				if x.AuthSecret != nil {
					x.AuthSecret = nil
				}
			} else {
				if x.AuthSecret == nil {
					x.AuthSecret = new(pkg2_v1.ObjectReference)
				}
				x.AuthSecret.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys72)
		} // end switch yys72
	} // end for yyj72
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *BrokerSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj75 int
	var yyb75 bool
	var yyhl75 bool = l >= 0
	yyj75++
	if yyhl75 {
		yyb75 = yyj75 > l
	} else {
		yyb75 = r.CheckBreak()
	}
	if yyb75 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.URL = ""
	} else {
		x.URL = string(r.DecodeString())
	}
	yyj75++
	if yyhl75 {
		yyb75 = yyj75 > l
	} else {
		yyb75 = r.CheckBreak()
	}
	if yyb75 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.AuthSecret != nil {
			x.AuthSecret = nil
		}
	} else {
		if x.AuthSecret == nil {
			x.AuthSecret = new(pkg2_v1.ObjectReference)
		}
		x.AuthSecret.CodecDecodeSelf(d)
	}
	for {
		yyj75++
		if yyhl75 {
			yyb75 = yyj75 > l
		} else {
			yyb75 = r.CheckBreak()
		}
		if yyb75 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj75-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *BrokerStatus) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym78 := z.EncBinary()
		_ = yym78
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep79 := !z.EncBinary()
			yy2arr79 := z.EncBasicHandle().StructToArray
			var yyq79 [1]bool
			_, _, _ = yysep79, yyq79, yy2arr79
			const yyr79 bool = false
			var yynn79 int
			if yyr79 || yy2arr79 {
				r.EncodeArrayStart(1)
			} else {
				yynn79 = 1
				for _, b := range yyq79 {
					if b {
						yynn79++
					}
				}
				r.EncodeMapStart(yynn79)
				yynn79 = 0
			}
			if yyr79 || yy2arr79 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Conditions == nil {
					r.EncodeNil()
				} else {
					yym81 := z.EncBinary()
					_ = yym81
					if false {
					} else {
						h.encSliceBrokerCondition(([]BrokerCondition)(x.Conditions), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("conditions"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Conditions == nil {
					r.EncodeNil()
				} else {
					yym82 := z.EncBinary()
					_ = yym82
					if false {
					} else {
						h.encSliceBrokerCondition(([]BrokerCondition)(x.Conditions), e)
					}
				}
			}
			if yyr79 || yy2arr79 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *BrokerStatus) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym83 := z.DecBinary()
	_ = yym83
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct84 := r.ContainerType()
		if yyct84 == codecSelferValueTypeMap1234 {
			yyl84 := r.ReadMapStart()
			if yyl84 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl84, d)
			}
		} else if yyct84 == codecSelferValueTypeArray1234 {
			yyl84 := r.ReadArrayStart()
			if yyl84 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl84, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *BrokerStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys85Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys85Slc
	var yyhl85 bool = l >= 0
	for yyj85 := 0; ; yyj85++ {
		if yyhl85 {
			if yyj85 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys85Slc = r.DecodeBytes(yys85Slc, true, true)
		yys85 := string(yys85Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys85 {
		case "conditions":
			if r.TryDecodeAsNil() {
				x.Conditions = nil
			} else {
				yyv86 := &x.Conditions
				yym87 := z.DecBinary()
				_ = yym87
				if false {
				} else {
					h.decSliceBrokerCondition((*[]BrokerCondition)(yyv86), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys85)
		} // end switch yys85
	} // end for yyj85
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *BrokerStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj88 int
	var yyb88 bool
	var yyhl88 bool = l >= 0
	yyj88++
	if yyhl88 {
		yyb88 = yyj88 > l
	} else {
		yyb88 = r.CheckBreak()
	}
	if yyb88 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Conditions = nil
	} else {
		yyv89 := &x.Conditions
		yym90 := z.DecBinary()
		_ = yym90
		if false {
		} else {
			h.decSliceBrokerCondition((*[]BrokerCondition)(yyv89), d)
		}
	}
	for {
		yyj88++
		if yyhl88 {
			yyb88 = yyj88 > l
		} else {
			yyb88 = r.CheckBreak()
		}
		if yyb88 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj88-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *BrokerCondition) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym91 := z.EncBinary()
		_ = yym91
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep92 := !z.EncBinary()
			yy2arr92 := z.EncBasicHandle().StructToArray
			var yyq92 [4]bool
			_, _, _ = yysep92, yyq92, yy2arr92
			const yyr92 bool = false
			var yynn92 int
			if yyr92 || yy2arr92 {
				r.EncodeArrayStart(4)
			} else {
				yynn92 = 4
				for _, b := range yyq92 {
					if b {
						yynn92++
					}
				}
				r.EncodeMapStart(yynn92)
				yynn92 = 0
			}
			if yyr92 || yy2arr92 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				x.Type.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("type"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				x.Type.CodecEncodeSelf(e)
			}
			if yyr92 || yy2arr92 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				x.Status.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("status"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				x.Status.CodecEncodeSelf(e)
			}
			if yyr92 || yy2arr92 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym96 := z.EncBinary()
				_ = yym96
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("reason"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym97 := z.EncBinary()
				_ = yym97
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
				}
			}
			if yyr92 || yy2arr92 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym99 := z.EncBinary()
				_ = yym99
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Message))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("message"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym100 := z.EncBinary()
				_ = yym100
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Message))
				}
			}
			if yyr92 || yy2arr92 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *BrokerCondition) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym101 := z.DecBinary()
	_ = yym101
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct102 := r.ContainerType()
		if yyct102 == codecSelferValueTypeMap1234 {
			yyl102 := r.ReadMapStart()
			if yyl102 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl102, d)
			}
		} else if yyct102 == codecSelferValueTypeArray1234 {
			yyl102 := r.ReadArrayStart()
			if yyl102 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl102, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *BrokerCondition) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys103Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys103Slc
	var yyhl103 bool = l >= 0
	for yyj103 := 0; ; yyj103++ {
		if yyhl103 {
			if yyj103 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys103Slc = r.DecodeBytes(yys103Slc, true, true)
		yys103 := string(yys103Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys103 {
		case "type":
			if r.TryDecodeAsNil() {
				x.Type = ""
			} else {
				x.Type = BrokerConditionType(r.DecodeString())
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = ""
			} else {
				x.Status = ConditionStatus(r.DecodeString())
			}
		case "reason":
			if r.TryDecodeAsNil() {
				x.Reason = ""
			} else {
				x.Reason = string(r.DecodeString())
			}
		case "message":
			if r.TryDecodeAsNil() {
				x.Message = ""
			} else {
				x.Message = string(r.DecodeString())
			}
		default:
			z.DecStructFieldNotFound(-1, yys103)
		} // end switch yys103
	} // end for yyj103
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *BrokerCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj108 int
	var yyb108 bool
	var yyhl108 bool = l >= 0
	yyj108++
	if yyhl108 {
		yyb108 = yyj108 > l
	} else {
		yyb108 = r.CheckBreak()
	}
	if yyb108 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		x.Type = BrokerConditionType(r.DecodeString())
	}
	yyj108++
	if yyhl108 {
		yyb108 = yyj108 > l
	} else {
		yyb108 = r.CheckBreak()
	}
	if yyb108 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = ""
	} else {
		x.Status = ConditionStatus(r.DecodeString())
	}
	yyj108++
	if yyhl108 {
		yyb108 = yyj108 > l
	} else {
		yyb108 = r.CheckBreak()
	}
	if yyb108 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Reason = ""
	} else {
		x.Reason = string(r.DecodeString())
	}
	yyj108++
	if yyhl108 {
		yyb108 = yyj108 > l
	} else {
		yyb108 = r.CheckBreak()
	}
	if yyb108 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Message = ""
	} else {
		x.Message = string(r.DecodeString())
	}
	for {
		yyj108++
		if yyhl108 {
			yyb108 = yyj108 > l
		} else {
			yyb108 = r.CheckBreak()
		}
		if yyb108 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj108-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x BrokerConditionType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym113 := z.EncBinary()
	_ = yym113
	if false {
	} else if z.HasExtensions() && z.EncExt(x) {
	} else {
		r.EncodeString(codecSelferC_UTF81234, string(x))
	}
}

func (x *BrokerConditionType) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym114 := z.DecBinary()
	_ = yym114
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		*((*string)(x)) = r.DecodeString()
	}
}

func (x ConditionStatus) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym115 := z.EncBinary()
	_ = yym115
	if false {
	} else if z.HasExtensions() && z.EncExt(x) {
	} else {
		r.EncodeString(codecSelferC_UTF81234, string(x))
	}
}

func (x *ConditionStatus) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym116 := z.DecBinary()
	_ = yym116
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		*((*string)(x)) = r.DecodeString()
	}
}

func (x *ServiceClassList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym117 := z.EncBinary()
		_ = yym117
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep118 := !z.EncBinary()
			yy2arr118 := z.EncBasicHandle().StructToArray
			var yyq118 [4]bool
			_, _, _ = yysep118, yyq118, yy2arr118
			const yyr118 bool = false
			yyq118[0] = x.Kind != ""
			yyq118[1] = x.APIVersion != ""
			yyq118[2] = true
			var yynn118 int
			if yyr118 || yy2arr118 {
				r.EncodeArrayStart(4)
			} else {
				yynn118 = 1
				for _, b := range yyq118 {
					if b {
						yynn118++
					}
				}
				r.EncodeMapStart(yynn118)
				yynn118 = 0
			}
			if yyr118 || yy2arr118 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq118[0] {
					yym120 := z.EncBinary()
					_ = yym120
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq118[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym121 := z.EncBinary()
					_ = yym121
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr118 || yy2arr118 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq118[1] {
					yym123 := z.EncBinary()
					_ = yym123
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq118[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym124 := z.EncBinary()
					_ = yym124
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr118 || yy2arr118 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq118[2] {
					yy126 := &x.ListMeta
					yym127 := z.EncBinary()
					_ = yym127
					if false {
					} else if z.HasExtensions() && z.EncExt(yy126) {
					} else {
						z.EncFallback(yy126)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq118[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy128 := &x.ListMeta
					yym129 := z.EncBinary()
					_ = yym129
					if false {
					} else if z.HasExtensions() && z.EncExt(yy128) {
					} else {
						z.EncFallback(yy128)
					}
				}
			}
			if yyr118 || yy2arr118 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym131 := z.EncBinary()
					_ = yym131
					if false {
					} else {
						h.encSliceServiceClass(([]ServiceClass)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym132 := z.EncBinary()
					_ = yym132
					if false {
					} else {
						h.encSliceServiceClass(([]ServiceClass)(x.Items), e)
					}
				}
			}
			if yyr118 || yy2arr118 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ServiceClassList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym133 := z.DecBinary()
	_ = yym133
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct134 := r.ContainerType()
		if yyct134 == codecSelferValueTypeMap1234 {
			yyl134 := r.ReadMapStart()
			if yyl134 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl134, d)
			}
		} else if yyct134 == codecSelferValueTypeArray1234 {
			yyl134 := r.ReadArrayStart()
			if yyl134 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl134, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ServiceClassList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys135Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys135Slc
	var yyhl135 bool = l >= 0
	for yyj135 := 0; ; yyj135++ {
		if yyhl135 {
			if yyj135 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys135Slc = r.DecodeBytes(yys135Slc, true, true)
		yys135 := string(yys135Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys135 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_v1.ListMeta{}
			} else {
				yyv138 := &x.ListMeta
				yym139 := z.DecBinary()
				_ = yym139
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv138) {
				} else {
					z.DecFallback(yyv138, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv140 := &x.Items
				yym141 := z.DecBinary()
				_ = yym141
				if false {
				} else {
					h.decSliceServiceClass((*[]ServiceClass)(yyv140), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys135)
		} // end switch yys135
	} // end for yyj135
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ServiceClassList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj142 int
	var yyb142 bool
	var yyhl142 bool = l >= 0
	yyj142++
	if yyhl142 {
		yyb142 = yyj142 > l
	} else {
		yyb142 = r.CheckBreak()
	}
	if yyb142 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj142++
	if yyhl142 {
		yyb142 = yyj142 > l
	} else {
		yyb142 = r.CheckBreak()
	}
	if yyb142 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj142++
	if yyhl142 {
		yyb142 = yyj142 > l
	} else {
		yyb142 = r.CheckBreak()
	}
	if yyb142 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_v1.ListMeta{}
	} else {
		yyv145 := &x.ListMeta
		yym146 := z.DecBinary()
		_ = yym146
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv145) {
		} else {
			z.DecFallback(yyv145, false)
		}
	}
	yyj142++
	if yyhl142 {
		yyb142 = yyj142 > l
	} else {
		yyb142 = r.CheckBreak()
	}
	if yyb142 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv147 := &x.Items
		yym148 := z.DecBinary()
		_ = yym148
		if false {
		} else {
			h.decSliceServiceClass((*[]ServiceClass)(yyv147), d)
		}
	}
	for {
		yyj142++
		if yyhl142 {
			yyb142 = yyj142 > l
		} else {
			yyb142 = r.CheckBreak()
		}
		if yyb142 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj142-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ServiceClass) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym149 := z.EncBinary()
		_ = yym149
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep150 := !z.EncBinary()
			yy2arr150 := z.EncBasicHandle().StructToArray
			var yyq150 [15]bool
			_, _, _ = yysep150, yyq150, yy2arr150
			const yyr150 bool = false
			yyq150[0] = x.Kind != ""
			yyq150[1] = x.APIVersion != ""
			yyq150[2] = true
			yyq150[8] = len(x.OSBTags) != 0
			yyq150[9] = len(x.OSBRequires) != 0
			yyq150[10] = x.OSBMaxDBPerNode != nil
			yyq150[11] = x.OSBDashboardOAuth2ClientID != nil
			yyq150[12] = x.OSBDashboardSecret != nil
			yyq150[13] = x.OSBDashboardRedirectURI != nil
			var yynn150 int
			if yyr150 || yy2arr150 {
				r.EncodeArrayStart(15)
			} else {
				yynn150 = 6
				for _, b := range yyq150 {
					if b {
						yynn150++
					}
				}
				r.EncodeMapStart(yynn150)
				yynn150 = 0
			}
			if yyr150 || yy2arr150 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq150[0] {
					yym152 := z.EncBinary()
					_ = yym152
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq150[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym153 := z.EncBinary()
					_ = yym153
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr150 || yy2arr150 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq150[1] {
					yym155 := z.EncBinary()
					_ = yym155
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq150[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym156 := z.EncBinary()
					_ = yym156
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr150 || yy2arr150 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq150[2] {
					yy158 := &x.ObjectMeta
					yy158.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq150[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy159 := &x.ObjectMeta
					yy159.CodecEncodeSelf(e)
				}
			}
			if yyr150 || yy2arr150 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym161 := z.EncBinary()
				_ = yym161
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.BrokerName))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("brokerName"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym162 := z.EncBinary()
				_ = yym162
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.BrokerName))
				}
			}
			if yyr150 || yy2arr150 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym164 := z.EncBinary()
				_ = yym164
				if false {
				} else {
					r.EncodeBool(bool(x.Bindable))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("bindable"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym165 := z.EncBinary()
				_ = yym165
				if false {
				} else {
					r.EncodeBool(bool(x.Bindable))
				}
			}
			if yyr150 || yy2arr150 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Plans == nil {
					r.EncodeNil()
				} else {
					yym167 := z.EncBinary()
					_ = yym167
					if false {
					} else {
						h.encSliceServicePlan(([]ServicePlan)(x.Plans), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("plans"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Plans == nil {
					r.EncodeNil()
				} else {
					yym168 := z.EncBinary()
					_ = yym168
					if false {
					} else {
						h.encSliceServicePlan(([]ServicePlan)(x.Plans), e)
					}
				}
			}
			if yyr150 || yy2arr150 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym170 := z.EncBinary()
				_ = yym170
				if false {
				} else {
					r.EncodeBool(bool(x.PlanUpdatable))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("planUpdatable"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym171 := z.EncBinary()
				_ = yym171
				if false {
				} else {
					r.EncodeBool(bool(x.PlanUpdatable))
				}
			}
			if yyr150 || yy2arr150 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym173 := z.EncBinary()
				_ = yym173
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.OSBGUID))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("osbGuid"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym174 := z.EncBinary()
				_ = yym174
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.OSBGUID))
				}
			}
			if yyr150 || yy2arr150 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq150[8] {
					if x.OSBTags == nil {
						r.EncodeNil()
					} else {
						yym176 := z.EncBinary()
						_ = yym176
						if false {
						} else {
							z.F.EncSliceStringV(x.OSBTags, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq150[8] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("osbTags"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.OSBTags == nil {
						r.EncodeNil()
					} else {
						yym177 := z.EncBinary()
						_ = yym177
						if false {
						} else {
							z.F.EncSliceStringV(x.OSBTags, false, e)
						}
					}
				}
			}
			if yyr150 || yy2arr150 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq150[9] {
					if x.OSBRequires == nil {
						r.EncodeNil()
					} else {
						yym179 := z.EncBinary()
						_ = yym179
						if false {
						} else {
							z.F.EncSliceStringV(x.OSBRequires, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq150[9] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("osbRequires"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.OSBRequires == nil {
						r.EncodeNil()
					} else {
						yym180 := z.EncBinary()
						_ = yym180
						if false {
						} else {
							z.F.EncSliceStringV(x.OSBRequires, false, e)
						}
					}
				}
			}
			if yyr150 || yy2arr150 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq150[10] {
					if x.OSBMaxDBPerNode == nil {
						r.EncodeNil()
					} else {
						yy182 := *x.OSBMaxDBPerNode
						yym183 := z.EncBinary()
						_ = yym183
						if false {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy182))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq150[10] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("osbMaxDBPerNode"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.OSBMaxDBPerNode == nil {
						r.EncodeNil()
					} else {
						yy184 := *x.OSBMaxDBPerNode
						yym185 := z.EncBinary()
						_ = yym185
						if false {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy184))
						}
					}
				}
			}
			if yyr150 || yy2arr150 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq150[11] {
					if x.OSBDashboardOAuth2ClientID == nil {
						r.EncodeNil()
					} else {
						yy187 := *x.OSBDashboardOAuth2ClientID
						yym188 := z.EncBinary()
						_ = yym188
						if false {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy187))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq150[11] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("osbDashboardOAuth2ClientID"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.OSBDashboardOAuth2ClientID == nil {
						r.EncodeNil()
					} else {
						yy189 := *x.OSBDashboardOAuth2ClientID
						yym190 := z.EncBinary()
						_ = yym190
						if false {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy189))
						}
					}
				}
			}
			if yyr150 || yy2arr150 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq150[12] {
					if x.OSBDashboardSecret == nil {
						r.EncodeNil()
					} else {
						yy192 := *x.OSBDashboardSecret
						yym193 := z.EncBinary()
						_ = yym193
						if false {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy192))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq150[12] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("osbDashboardSecret"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.OSBDashboardSecret == nil {
						r.EncodeNil()
					} else {
						yy194 := *x.OSBDashboardSecret
						yym195 := z.EncBinary()
						_ = yym195
						if false {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy194))
						}
					}
				}
			}
			if yyr150 || yy2arr150 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq150[13] {
					if x.OSBDashboardRedirectURI == nil {
						r.EncodeNil()
					} else {
						yy197 := *x.OSBDashboardRedirectURI
						yym198 := z.EncBinary()
						_ = yym198
						if false {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy197))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq150[13] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("osbDashboardRedirectURI"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.OSBDashboardRedirectURI == nil {
						r.EncodeNil()
					} else {
						yy199 := *x.OSBDashboardRedirectURI
						yym200 := z.EncBinary()
						_ = yym200
						if false {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy199))
						}
					}
				}
			}
			if yyr150 || yy2arr150 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.OSBMetadata == nil {
					r.EncodeNil()
				} else {
					yym202 := z.EncBinary()
					_ = yym202
					if false {
					} else if z.HasExtensions() && z.EncExt(x.OSBMetadata) {
					} else if !yym202 && z.IsJSONHandle() {
						z.EncJSONMarshal(x.OSBMetadata)
					} else {
						z.EncFallback(x.OSBMetadata)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("osbMetadata"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.OSBMetadata == nil {
					r.EncodeNil()
				} else {
					yym203 := z.EncBinary()
					_ = yym203
					if false {
					} else if z.HasExtensions() && z.EncExt(x.OSBMetadata) {
					} else if !yym203 && z.IsJSONHandle() {
						z.EncJSONMarshal(x.OSBMetadata)
					} else {
						z.EncFallback(x.OSBMetadata)
					}
				}
			}
			if yyr150 || yy2arr150 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ServiceClass) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym204 := z.DecBinary()
	_ = yym204
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct205 := r.ContainerType()
		if yyct205 == codecSelferValueTypeMap1234 {
			yyl205 := r.ReadMapStart()
			if yyl205 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl205, d)
			}
		} else if yyct205 == codecSelferValueTypeArray1234 {
			yyl205 := r.ReadArrayStart()
			if yyl205 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl205, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ServiceClass) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys206Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys206Slc
	var yyhl206 bool = l >= 0
	for yyj206 := 0; ; yyj206++ {
		if yyhl206 {
			if yyj206 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys206Slc = r.DecodeBytes(yys206Slc, true, true)
		yys206 := string(yys206Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys206 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv209 := &x.ObjectMeta
				yyv209.CodecDecodeSelf(d)
			}
		case "brokerName":
			if r.TryDecodeAsNil() {
				x.BrokerName = ""
			} else {
				x.BrokerName = string(r.DecodeString())
			}
		case "bindable":
			if r.TryDecodeAsNil() {
				x.Bindable = false
			} else {
				x.Bindable = bool(r.DecodeBool())
			}
		case "plans":
			if r.TryDecodeAsNil() {
				x.Plans = nil
			} else {
				yyv212 := &x.Plans
				yym213 := z.DecBinary()
				_ = yym213
				if false {
				} else {
					h.decSliceServicePlan((*[]ServicePlan)(yyv212), d)
				}
			}
		case "planUpdatable":
			if r.TryDecodeAsNil() {
				x.PlanUpdatable = false
			} else {
				x.PlanUpdatable = bool(r.DecodeBool())
			}
		case "osbGuid":
			if r.TryDecodeAsNil() {
				x.OSBGUID = ""
			} else {
				x.OSBGUID = string(r.DecodeString())
			}
		case "osbTags":
			if r.TryDecodeAsNil() {
				x.OSBTags = nil
			} else {
				yyv216 := &x.OSBTags
				yym217 := z.DecBinary()
				_ = yym217
				if false {
				} else {
					z.F.DecSliceStringX(yyv216, false, d)
				}
			}
		case "osbRequires":
			if r.TryDecodeAsNil() {
				x.OSBRequires = nil
			} else {
				yyv218 := &x.OSBRequires
				yym219 := z.DecBinary()
				_ = yym219
				if false {
				} else {
					z.F.DecSliceStringX(yyv218, false, d)
				}
			}
		case "osbMaxDBPerNode":
			if r.TryDecodeAsNil() {
				if x.OSBMaxDBPerNode != nil {
					x.OSBMaxDBPerNode = nil
				}
			} else {
				if x.OSBMaxDBPerNode == nil {
					x.OSBMaxDBPerNode = new(string)
				}
				yym221 := z.DecBinary()
				_ = yym221
				if false {
				} else {
					*((*string)(x.OSBMaxDBPerNode)) = r.DecodeString()
				}
			}
		case "osbDashboardOAuth2ClientID":
			if r.TryDecodeAsNil() {
				if x.OSBDashboardOAuth2ClientID != nil {
					x.OSBDashboardOAuth2ClientID = nil
				}
			} else {
				if x.OSBDashboardOAuth2ClientID == nil {
					x.OSBDashboardOAuth2ClientID = new(string)
				}
				yym223 := z.DecBinary()
				_ = yym223
				if false {
				} else {
					*((*string)(x.OSBDashboardOAuth2ClientID)) = r.DecodeString()
				}
			}
		case "osbDashboardSecret":
			if r.TryDecodeAsNil() {
				if x.OSBDashboardSecret != nil {
					x.OSBDashboardSecret = nil
				}
			} else {
				if x.OSBDashboardSecret == nil {
					x.OSBDashboardSecret = new(string)
				}
				yym225 := z.DecBinary()
				_ = yym225
				if false {
				} else {
					*((*string)(x.OSBDashboardSecret)) = r.DecodeString()
				}
			}
		case "osbDashboardRedirectURI":
			if r.TryDecodeAsNil() {
				if x.OSBDashboardRedirectURI != nil {
					x.OSBDashboardRedirectURI = nil
				}
			} else {
				if x.OSBDashboardRedirectURI == nil {
					x.OSBDashboardRedirectURI = new(string)
				}
				yym227 := z.DecBinary()
				_ = yym227
				if false {
				} else {
					*((*string)(x.OSBDashboardRedirectURI)) = r.DecodeString()
				}
			}
		case "osbMetadata":
			if r.TryDecodeAsNil() {
				if x.OSBMetadata != nil {
					x.OSBMetadata = nil
				}
			} else {
				if x.OSBMetadata == nil {
					x.OSBMetadata = new(pkg4_runtime.RawExtension)
				}
				yym229 := z.DecBinary()
				_ = yym229
				if false {
				} else if z.HasExtensions() && z.DecExt(x.OSBMetadata) {
				} else if !yym229 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(x.OSBMetadata)
				} else {
					z.DecFallback(x.OSBMetadata, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys206)
		} // end switch yys206
	} // end for yyj206
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ServiceClass) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj230 int
	var yyb230 bool
	var yyhl230 bool = l >= 0
	yyj230++
	if yyhl230 {
		yyb230 = yyj230 > l
	} else {
		yyb230 = r.CheckBreak()
	}
	if yyb230 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj230++
	if yyhl230 {
		yyb230 = yyj230 > l
	} else {
		yyb230 = r.CheckBreak()
	}
	if yyb230 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj230++
	if yyhl230 {
		yyb230 = yyj230 > l
	} else {
		yyb230 = r.CheckBreak()
	}
	if yyb230 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv233 := &x.ObjectMeta
		yyv233.CodecDecodeSelf(d)
	}
	yyj230++
	if yyhl230 {
		yyb230 = yyj230 > l
	} else {
		yyb230 = r.CheckBreak()
	}
	if yyb230 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.BrokerName = ""
	} else {
		x.BrokerName = string(r.DecodeString())
	}
	yyj230++
	if yyhl230 {
		yyb230 = yyj230 > l
	} else {
		yyb230 = r.CheckBreak()
	}
	if yyb230 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Bindable = false
	} else {
		x.Bindable = bool(r.DecodeBool())
	}
	yyj230++
	if yyhl230 {
		yyb230 = yyj230 > l
	} else {
		yyb230 = r.CheckBreak()
	}
	if yyb230 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Plans = nil
	} else {
		yyv236 := &x.Plans
		yym237 := z.DecBinary()
		_ = yym237
		if false {
		} else {
			h.decSliceServicePlan((*[]ServicePlan)(yyv236), d)
		}
	}
	yyj230++
	if yyhl230 {
		yyb230 = yyj230 > l
	} else {
		yyb230 = r.CheckBreak()
	}
	if yyb230 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.PlanUpdatable = false
	} else {
		x.PlanUpdatable = bool(r.DecodeBool())
	}
	yyj230++
	if yyhl230 {
		yyb230 = yyj230 > l
	} else {
		yyb230 = r.CheckBreak()
	}
	if yyb230 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.OSBGUID = ""
	} else {
		x.OSBGUID = string(r.DecodeString())
	}
	yyj230++
	if yyhl230 {
		yyb230 = yyj230 > l
	} else {
		yyb230 = r.CheckBreak()
	}
	if yyb230 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.OSBTags = nil
	} else {
		yyv240 := &x.OSBTags
		yym241 := z.DecBinary()
		_ = yym241
		if false {
		} else {
			z.F.DecSliceStringX(yyv240, false, d)
		}
	}
	yyj230++
	if yyhl230 {
		yyb230 = yyj230 > l
	} else {
		yyb230 = r.CheckBreak()
	}
	if yyb230 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.OSBRequires = nil
	} else {
		yyv242 := &x.OSBRequires
		yym243 := z.DecBinary()
		_ = yym243
		if false {
		} else {
			z.F.DecSliceStringX(yyv242, false, d)
		}
	}
	yyj230++
	if yyhl230 {
		yyb230 = yyj230 > l
	} else {
		yyb230 = r.CheckBreak()
	}
	if yyb230 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.OSBMaxDBPerNode != nil {
			x.OSBMaxDBPerNode = nil
		}
	} else {
		if x.OSBMaxDBPerNode == nil {
			x.OSBMaxDBPerNode = new(string)
		}
		yym245 := z.DecBinary()
		_ = yym245
		if false {
		} else {
			*((*string)(x.OSBMaxDBPerNode)) = r.DecodeString()
		}
	}
	yyj230++
	if yyhl230 {
		yyb230 = yyj230 > l
	} else {
		yyb230 = r.CheckBreak()
	}
	if yyb230 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.OSBDashboardOAuth2ClientID != nil {
			x.OSBDashboardOAuth2ClientID = nil
		}
	} else {
		if x.OSBDashboardOAuth2ClientID == nil {
			x.OSBDashboardOAuth2ClientID = new(string)
		}
		yym247 := z.DecBinary()
		_ = yym247
		if false {
		} else {
			*((*string)(x.OSBDashboardOAuth2ClientID)) = r.DecodeString()
		}
	}
	yyj230++
	if yyhl230 {
		yyb230 = yyj230 > l
	} else {
		yyb230 = r.CheckBreak()
	}
	if yyb230 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.OSBDashboardSecret != nil {
			x.OSBDashboardSecret = nil
		}
	} else {
		if x.OSBDashboardSecret == nil {
			x.OSBDashboardSecret = new(string)
		}
		yym249 := z.DecBinary()
		_ = yym249
		if false {
		} else {
			*((*string)(x.OSBDashboardSecret)) = r.DecodeString()
		}
	}
	yyj230++
	if yyhl230 {
		yyb230 = yyj230 > l
	} else {
		yyb230 = r.CheckBreak()
	}
	if yyb230 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.OSBDashboardRedirectURI != nil {
			x.OSBDashboardRedirectURI = nil
		}
	} else {
		if x.OSBDashboardRedirectURI == nil {
			x.OSBDashboardRedirectURI = new(string)
		}
		yym251 := z.DecBinary()
		_ = yym251
		if false {
		} else {
			*((*string)(x.OSBDashboardRedirectURI)) = r.DecodeString()
		}
	}
	yyj230++
	if yyhl230 {
		yyb230 = yyj230 > l
	} else {
		yyb230 = r.CheckBreak()
	}
	if yyb230 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.OSBMetadata != nil {
			x.OSBMetadata = nil
		}
	} else {
		if x.OSBMetadata == nil {
			x.OSBMetadata = new(pkg4_runtime.RawExtension)
		}
		yym253 := z.DecBinary()
		_ = yym253
		if false {
		} else if z.HasExtensions() && z.DecExt(x.OSBMetadata) {
		} else if !yym253 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.OSBMetadata)
		} else {
			z.DecFallback(x.OSBMetadata, false)
		}
	}
	for {
		yyj230++
		if yyhl230 {
			yyb230 = yyj230 > l
		} else {
			yyb230 = r.CheckBreak()
		}
		if yyb230 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj230-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ServicePlan) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym254 := z.EncBinary()
		_ = yym254
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep255 := !z.EncBinary()
			yy2arr255 := z.EncBasicHandle().StructToArray
			var yyq255 [5]bool
			_, _, _ = yysep255, yyq255, yy2arr255
			const yyr255 bool = false
			yyq255[1] = x.Description != nil
			var yynn255 int
			if yyr255 || yy2arr255 {
				r.EncodeArrayStart(5)
			} else {
				yynn255 = 4
				for _, b := range yyq255 {
					if b {
						yynn255++
					}
				}
				r.EncodeMapStart(yynn255)
				yynn255 = 0
			}
			if yyr255 || yy2arr255 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym257 := z.EncBinary()
				_ = yym257
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Name))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("name"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym258 := z.EncBinary()
				_ = yym258
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Name))
				}
			}
			if yyr255 || yy2arr255 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq255[1] {
					if x.Description == nil {
						r.EncodeNil()
					} else {
						yy260 := *x.Description
						yym261 := z.EncBinary()
						_ = yym261
						if false {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy260))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq255[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("description"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Description == nil {
						r.EncodeNil()
					} else {
						yy262 := *x.Description
						yym263 := z.EncBinary()
						_ = yym263
						if false {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy262))
						}
					}
				}
			}
			if yyr255 || yy2arr255 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym265 := z.EncBinary()
				_ = yym265
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.OSBGUID))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("osbGuid"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym266 := z.EncBinary()
				_ = yym266
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.OSBGUID))
				}
			}
			if yyr255 || yy2arr255 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym268 := z.EncBinary()
				_ = yym268
				if false {
				} else {
					r.EncodeBool(bool(x.OSBFree))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("osbFree"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym269 := z.EncBinary()
				_ = yym269
				if false {
				} else {
					r.EncodeBool(bool(x.OSBFree))
				}
			}
			if yyr255 || yy2arr255 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.OSBMetadata == nil {
					r.EncodeNil()
				} else {
					yym271 := z.EncBinary()
					_ = yym271
					if false {
					} else if z.HasExtensions() && z.EncExt(x.OSBMetadata) {
					} else if !yym271 && z.IsJSONHandle() {
						z.EncJSONMarshal(x.OSBMetadata)
					} else {
						z.EncFallback(x.OSBMetadata)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("osbMetadata"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.OSBMetadata == nil {
					r.EncodeNil()
				} else {
					yym272 := z.EncBinary()
					_ = yym272
					if false {
					} else if z.HasExtensions() && z.EncExt(x.OSBMetadata) {
					} else if !yym272 && z.IsJSONHandle() {
						z.EncJSONMarshal(x.OSBMetadata)
					} else {
						z.EncFallback(x.OSBMetadata)
					}
				}
			}
			if yyr255 || yy2arr255 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ServicePlan) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym273 := z.DecBinary()
	_ = yym273
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct274 := r.ContainerType()
		if yyct274 == codecSelferValueTypeMap1234 {
			yyl274 := r.ReadMapStart()
			if yyl274 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl274, d)
			}
		} else if yyct274 == codecSelferValueTypeArray1234 {
			yyl274 := r.ReadArrayStart()
			if yyl274 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl274, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ServicePlan) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys275Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys275Slc
	var yyhl275 bool = l >= 0
	for yyj275 := 0; ; yyj275++ {
		if yyhl275 {
			if yyj275 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys275Slc = r.DecodeBytes(yys275Slc, true, true)
		yys275 := string(yys275Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys275 {
		case "name":
			if r.TryDecodeAsNil() {
				x.Name = ""
			} else {
				x.Name = string(r.DecodeString())
			}
		case "description":
			if r.TryDecodeAsNil() {
				if x.Description != nil {
					x.Description = nil
				}
			} else {
				if x.Description == nil {
					x.Description = new(string)
				}
				yym278 := z.DecBinary()
				_ = yym278
				if false {
				} else {
					*((*string)(x.Description)) = r.DecodeString()
				}
			}
		case "osbGuid":
			if r.TryDecodeAsNil() {
				x.OSBGUID = ""
			} else {
				x.OSBGUID = string(r.DecodeString())
			}
		case "osbFree":
			if r.TryDecodeAsNil() {
				x.OSBFree = false
			} else {
				x.OSBFree = bool(r.DecodeBool())
			}
		case "osbMetadata":
			if r.TryDecodeAsNil() {
				if x.OSBMetadata != nil {
					x.OSBMetadata = nil
				}
			} else {
				if x.OSBMetadata == nil {
					x.OSBMetadata = new(pkg4_runtime.RawExtension)
				}
				yym282 := z.DecBinary()
				_ = yym282
				if false {
				} else if z.HasExtensions() && z.DecExt(x.OSBMetadata) {
				} else if !yym282 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(x.OSBMetadata)
				} else {
					z.DecFallback(x.OSBMetadata, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys275)
		} // end switch yys275
	} // end for yyj275
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ServicePlan) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj283 int
	var yyb283 bool
	var yyhl283 bool = l >= 0
	yyj283++
	if yyhl283 {
		yyb283 = yyj283 > l
	} else {
		yyb283 = r.CheckBreak()
	}
	if yyb283 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Name = ""
	} else {
		x.Name = string(r.DecodeString())
	}
	yyj283++
	if yyhl283 {
		yyb283 = yyj283 > l
	} else {
		yyb283 = r.CheckBreak()
	}
	if yyb283 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Description != nil {
			x.Description = nil
		}
	} else {
		if x.Description == nil {
			x.Description = new(string)
		}
		yym286 := z.DecBinary()
		_ = yym286
		if false {
		} else {
			*((*string)(x.Description)) = r.DecodeString()
		}
	}
	yyj283++
	if yyhl283 {
		yyb283 = yyj283 > l
	} else {
		yyb283 = r.CheckBreak()
	}
	if yyb283 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.OSBGUID = ""
	} else {
		x.OSBGUID = string(r.DecodeString())
	}
	yyj283++
	if yyhl283 {
		yyb283 = yyj283 > l
	} else {
		yyb283 = r.CheckBreak()
	}
	if yyb283 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.OSBFree = false
	} else {
		x.OSBFree = bool(r.DecodeBool())
	}
	yyj283++
	if yyhl283 {
		yyb283 = yyj283 > l
	} else {
		yyb283 = r.CheckBreak()
	}
	if yyb283 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.OSBMetadata != nil {
			x.OSBMetadata = nil
		}
	} else {
		if x.OSBMetadata == nil {
			x.OSBMetadata = new(pkg4_runtime.RawExtension)
		}
		yym290 := z.DecBinary()
		_ = yym290
		if false {
		} else if z.HasExtensions() && z.DecExt(x.OSBMetadata) {
		} else if !yym290 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.OSBMetadata)
		} else {
			z.DecFallback(x.OSBMetadata, false)
		}
	}
	for {
		yyj283++
		if yyhl283 {
			yyb283 = yyj283 > l
		} else {
			yyb283 = r.CheckBreak()
		}
		if yyb283 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj283-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *InstanceList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym291 := z.EncBinary()
		_ = yym291
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep292 := !z.EncBinary()
			yy2arr292 := z.EncBasicHandle().StructToArray
			var yyq292 [4]bool
			_, _, _ = yysep292, yyq292, yy2arr292
			const yyr292 bool = false
			yyq292[0] = x.Kind != ""
			yyq292[1] = x.APIVersion != ""
			yyq292[2] = true
			var yynn292 int
			if yyr292 || yy2arr292 {
				r.EncodeArrayStart(4)
			} else {
				yynn292 = 1
				for _, b := range yyq292 {
					if b {
						yynn292++
					}
				}
				r.EncodeMapStart(yynn292)
				yynn292 = 0
			}
			if yyr292 || yy2arr292 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq292[0] {
					yym294 := z.EncBinary()
					_ = yym294
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq292[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym295 := z.EncBinary()
					_ = yym295
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr292 || yy2arr292 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq292[1] {
					yym297 := z.EncBinary()
					_ = yym297
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq292[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym298 := z.EncBinary()
					_ = yym298
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr292 || yy2arr292 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq292[2] {
					yy300 := &x.ListMeta
					yym301 := z.EncBinary()
					_ = yym301
					if false {
					} else if z.HasExtensions() && z.EncExt(yy300) {
					} else {
						z.EncFallback(yy300)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq292[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy302 := &x.ListMeta
					yym303 := z.EncBinary()
					_ = yym303
					if false {
					} else if z.HasExtensions() && z.EncExt(yy302) {
					} else {
						z.EncFallback(yy302)
					}
				}
			}
			if yyr292 || yy2arr292 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym305 := z.EncBinary()
					_ = yym305
					if false {
					} else {
						h.encSliceInstance(([]Instance)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym306 := z.EncBinary()
					_ = yym306
					if false {
					} else {
						h.encSliceInstance(([]Instance)(x.Items), e)
					}
				}
			}
			if yyr292 || yy2arr292 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *InstanceList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym307 := z.DecBinary()
	_ = yym307
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct308 := r.ContainerType()
		if yyct308 == codecSelferValueTypeMap1234 {
			yyl308 := r.ReadMapStart()
			if yyl308 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl308, d)
			}
		} else if yyct308 == codecSelferValueTypeArray1234 {
			yyl308 := r.ReadArrayStart()
			if yyl308 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl308, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *InstanceList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys309Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys309Slc
	var yyhl309 bool = l >= 0
	for yyj309 := 0; ; yyj309++ {
		if yyhl309 {
			if yyj309 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys309Slc = r.DecodeBytes(yys309Slc, true, true)
		yys309 := string(yys309Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys309 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_v1.ListMeta{}
			} else {
				yyv312 := &x.ListMeta
				yym313 := z.DecBinary()
				_ = yym313
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv312) {
				} else {
					z.DecFallback(yyv312, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv314 := &x.Items
				yym315 := z.DecBinary()
				_ = yym315
				if false {
				} else {
					h.decSliceInstance((*[]Instance)(yyv314), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys309)
		} // end switch yys309
	} // end for yyj309
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *InstanceList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj316 int
	var yyb316 bool
	var yyhl316 bool = l >= 0
	yyj316++
	if yyhl316 {
		yyb316 = yyj316 > l
	} else {
		yyb316 = r.CheckBreak()
	}
	if yyb316 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj316++
	if yyhl316 {
		yyb316 = yyj316 > l
	} else {
		yyb316 = r.CheckBreak()
	}
	if yyb316 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj316++
	if yyhl316 {
		yyb316 = yyj316 > l
	} else {
		yyb316 = r.CheckBreak()
	}
	if yyb316 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_v1.ListMeta{}
	} else {
		yyv319 := &x.ListMeta
		yym320 := z.DecBinary()
		_ = yym320
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv319) {
		} else {
			z.DecFallback(yyv319, false)
		}
	}
	yyj316++
	if yyhl316 {
		yyb316 = yyj316 > l
	} else {
		yyb316 = r.CheckBreak()
	}
	if yyb316 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv321 := &x.Items
		yym322 := z.DecBinary()
		_ = yym322
		if false {
		} else {
			h.decSliceInstance((*[]Instance)(yyv321), d)
		}
	}
	for {
		yyj316++
		if yyhl316 {
			yyb316 = yyj316 > l
		} else {
			yyb316 = r.CheckBreak()
		}
		if yyb316 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj316-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *Instance) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym323 := z.EncBinary()
		_ = yym323
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep324 := !z.EncBinary()
			yy2arr324 := z.EncBasicHandle().StructToArray
			var yyq324 [5]bool
			_, _, _ = yysep324, yyq324, yy2arr324
			const yyr324 bool = false
			yyq324[0] = x.Kind != ""
			yyq324[1] = x.APIVersion != ""
			yyq324[2] = true
			var yynn324 int
			if yyr324 || yy2arr324 {
				r.EncodeArrayStart(5)
			} else {
				yynn324 = 2
				for _, b := range yyq324 {
					if b {
						yynn324++
					}
				}
				r.EncodeMapStart(yynn324)
				yynn324 = 0
			}
			if yyr324 || yy2arr324 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq324[0] {
					yym326 := z.EncBinary()
					_ = yym326
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq324[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym327 := z.EncBinary()
					_ = yym327
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr324 || yy2arr324 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq324[1] {
					yym329 := z.EncBinary()
					_ = yym329
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq324[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym330 := z.EncBinary()
					_ = yym330
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr324 || yy2arr324 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq324[2] {
					yy332 := &x.ObjectMeta
					yy332.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq324[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy333 := &x.ObjectMeta
					yy333.CodecEncodeSelf(e)
				}
			}
			if yyr324 || yy2arr324 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy335 := &x.Spec
				yy335.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("spec"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy336 := &x.Spec
				yy336.CodecEncodeSelf(e)
			}
			if yyr324 || yy2arr324 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy338 := &x.Status
				yy338.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("status"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy339 := &x.Status
				yy339.CodecEncodeSelf(e)
			}
			if yyr324 || yy2arr324 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *Instance) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym340 := z.DecBinary()
	_ = yym340
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct341 := r.ContainerType()
		if yyct341 == codecSelferValueTypeMap1234 {
			yyl341 := r.ReadMapStart()
			if yyl341 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl341, d)
			}
		} else if yyct341 == codecSelferValueTypeArray1234 {
			yyl341 := r.ReadArrayStart()
			if yyl341 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl341, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *Instance) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys342Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys342Slc
	var yyhl342 bool = l >= 0
	for yyj342 := 0; ; yyj342++ {
		if yyhl342 {
			if yyj342 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys342Slc = r.DecodeBytes(yys342Slc, true, true)
		yys342 := string(yys342Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys342 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv345 := &x.ObjectMeta
				yyv345.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = InstanceSpec{}
			} else {
				yyv346 := &x.Spec
				yyv346.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = InstanceStatus{}
			} else {
				yyv347 := &x.Status
				yyv347.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys342)
		} // end switch yys342
	} // end for yyj342
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *Instance) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj348 int
	var yyb348 bool
	var yyhl348 bool = l >= 0
	yyj348++
	if yyhl348 {
		yyb348 = yyj348 > l
	} else {
		yyb348 = r.CheckBreak()
	}
	if yyb348 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj348++
	if yyhl348 {
		yyb348 = yyj348 > l
	} else {
		yyb348 = r.CheckBreak()
	}
	if yyb348 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj348++
	if yyhl348 {
		yyb348 = yyj348 > l
	} else {
		yyb348 = r.CheckBreak()
	}
	if yyb348 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv351 := &x.ObjectMeta
		yyv351.CodecDecodeSelf(d)
	}
	yyj348++
	if yyhl348 {
		yyb348 = yyj348 > l
	} else {
		yyb348 = r.CheckBreak()
	}
	if yyb348 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = InstanceSpec{}
	} else {
		yyv352 := &x.Spec
		yyv352.CodecDecodeSelf(d)
	}
	yyj348++
	if yyhl348 {
		yyb348 = yyj348 > l
	} else {
		yyb348 = r.CheckBreak()
	}
	if yyb348 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = InstanceStatus{}
	} else {
		yyv353 := &x.Status
		yyv353.CodecDecodeSelf(d)
	}
	for {
		yyj348++
		if yyhl348 {
			yyb348 = yyj348 > l
		} else {
			yyb348 = r.CheckBreak()
		}
		if yyb348 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj348-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *InstanceSpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym354 := z.EncBinary()
		_ = yym354
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep355 := !z.EncBinary()
			yy2arr355 := z.EncBasicHandle().StructToArray
			var yyq355 [7]bool
			_, _, _ = yysep355, yyq355, yy2arr355
			const yyr355 bool = false
			yyq355[2] = x.Parameters != nil
			yyq355[4] = x.OSBDashboardURL != nil
			yyq355[5] = x.OSBLastOperation != nil
			yyq355[6] = x.Checksum != nil
			var yynn355 int
			if yyr355 || yy2arr355 {
				r.EncodeArrayStart(7)
			} else {
				yynn355 = 3
				for _, b := range yyq355 {
					if b {
						yynn355++
					}
				}
				r.EncodeMapStart(yynn355)
				yynn355 = 0
			}
			if yyr355 || yy2arr355 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym357 := z.EncBinary()
				_ = yym357
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.ServiceClassName))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("serviceClassName"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym358 := z.EncBinary()
				_ = yym358
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.ServiceClassName))
				}
			}
			if yyr355 || yy2arr355 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym360 := z.EncBinary()
				_ = yym360
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.PlanName))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("planName"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym361 := z.EncBinary()
				_ = yym361
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.PlanName))
				}
			}
			if yyr355 || yy2arr355 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq355[2] {
					if x.Parameters == nil {
						r.EncodeNil()
					} else {
						yym363 := z.EncBinary()
						_ = yym363
						if false {
						} else if z.HasExtensions() && z.EncExt(x.Parameters) {
						} else if !yym363 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.Parameters)
						} else {
							z.EncFallback(x.Parameters)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq355[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("parameters"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Parameters == nil {
						r.EncodeNil()
					} else {
						yym364 := z.EncBinary()
						_ = yym364
						if false {
						} else if z.HasExtensions() && z.EncExt(x.Parameters) {
						} else if !yym364 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.Parameters)
						} else {
							z.EncFallback(x.Parameters)
						}
					}
				}
			}
			if yyr355 || yy2arr355 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym366 := z.EncBinary()
				_ = yym366
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.OSBGUID))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("osbGuid"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym367 := z.EncBinary()
				_ = yym367
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.OSBGUID))
				}
			}
			if yyr355 || yy2arr355 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq355[4] {
					if x.OSBDashboardURL == nil {
						r.EncodeNil()
					} else {
						yy369 := *x.OSBDashboardURL
						yym370 := z.EncBinary()
						_ = yym370
						if false {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy369))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq355[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("osbDashboardURL"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.OSBDashboardURL == nil {
						r.EncodeNil()
					} else {
						yy371 := *x.OSBDashboardURL
						yym372 := z.EncBinary()
						_ = yym372
						if false {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy371))
						}
					}
				}
			}
			if yyr355 || yy2arr355 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq355[5] {
					if x.OSBLastOperation == nil {
						r.EncodeNil()
					} else {
						yy374 := *x.OSBLastOperation
						yym375 := z.EncBinary()
						_ = yym375
						if false {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy374))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq355[5] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("osbLastOperation"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.OSBLastOperation == nil {
						r.EncodeNil()
					} else {
						yy376 := *x.OSBLastOperation
						yym377 := z.EncBinary()
						_ = yym377
						if false {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy376))
						}
					}
				}
			}
			if yyr355 || yy2arr355 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq355[6] {
					if x.Checksum == nil {
						r.EncodeNil()
					} else {
						yy379 := *x.Checksum
						yym380 := z.EncBinary()
						_ = yym380
						if false {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy379))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq355[6] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("checksum"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Checksum == nil {
						r.EncodeNil()
					} else {
						yy381 := *x.Checksum
						yym382 := z.EncBinary()
						_ = yym382
						if false {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy381))
						}
					}
				}
			}
			if yyr355 || yy2arr355 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *InstanceSpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym383 := z.DecBinary()
	_ = yym383
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct384 := r.ContainerType()
		if yyct384 == codecSelferValueTypeMap1234 {
			yyl384 := r.ReadMapStart()
			if yyl384 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl384, d)
			}
		} else if yyct384 == codecSelferValueTypeArray1234 {
			yyl384 := r.ReadArrayStart()
			if yyl384 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl384, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *InstanceSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys385Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys385Slc
	var yyhl385 bool = l >= 0
	for yyj385 := 0; ; yyj385++ {
		if yyhl385 {
			if yyj385 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys385Slc = r.DecodeBytes(yys385Slc, true, true)
		yys385 := string(yys385Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys385 {
		case "serviceClassName":
			if r.TryDecodeAsNil() {
				x.ServiceClassName = ""
			} else {
				x.ServiceClassName = string(r.DecodeString())
			}
		case "planName":
			if r.TryDecodeAsNil() {
				x.PlanName = ""
			} else {
				x.PlanName = string(r.DecodeString())
			}
		case "parameters":
			if r.TryDecodeAsNil() {
				if x.Parameters != nil {
					x.Parameters = nil
				}
			} else {
				if x.Parameters == nil {
					x.Parameters = new(pkg4_runtime.RawExtension)
				}
				yym389 := z.DecBinary()
				_ = yym389
				if false {
				} else if z.HasExtensions() && z.DecExt(x.Parameters) {
				} else if !yym389 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(x.Parameters)
				} else {
					z.DecFallback(x.Parameters, false)
				}
			}
		case "osbGuid":
			if r.TryDecodeAsNil() {
				x.OSBGUID = ""
			} else {
				x.OSBGUID = string(r.DecodeString())
			}
		case "osbDashboardURL":
			if r.TryDecodeAsNil() {
				if x.OSBDashboardURL != nil {
					x.OSBDashboardURL = nil
				}
			} else {
				if x.OSBDashboardURL == nil {
					x.OSBDashboardURL = new(string)
				}
				yym392 := z.DecBinary()
				_ = yym392
				if false {
				} else {
					*((*string)(x.OSBDashboardURL)) = r.DecodeString()
				}
			}
		case "osbLastOperation":
			if r.TryDecodeAsNil() {
				if x.OSBLastOperation != nil {
					x.OSBLastOperation = nil
				}
			} else {
				if x.OSBLastOperation == nil {
					x.OSBLastOperation = new(string)
				}
				yym394 := z.DecBinary()
				_ = yym394
				if false {
				} else {
					*((*string)(x.OSBLastOperation)) = r.DecodeString()
				}
			}
		case "checksum":
			if r.TryDecodeAsNil() {
				if x.Checksum != nil {
					x.Checksum = nil
				}
			} else {
				if x.Checksum == nil {
					x.Checksum = new(string)
				}
				yym396 := z.DecBinary()
				_ = yym396
				if false {
				} else {
					*((*string)(x.Checksum)) = r.DecodeString()
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys385)
		} // end switch yys385
	} // end for yyj385
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *InstanceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj397 int
	var yyb397 bool
	var yyhl397 bool = l >= 0
	yyj397++
	if yyhl397 {
		yyb397 = yyj397 > l
	} else {
		yyb397 = r.CheckBreak()
	}
	if yyb397 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ServiceClassName = ""
	} else {
		x.ServiceClassName = string(r.DecodeString())
	}
	yyj397++
	if yyhl397 {
		yyb397 = yyj397 > l
	} else {
		yyb397 = r.CheckBreak()
	}
	if yyb397 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.PlanName = ""
	} else {
		x.PlanName = string(r.DecodeString())
	}
	yyj397++
	if yyhl397 {
		yyb397 = yyj397 > l
	} else {
		yyb397 = r.CheckBreak()
	}
	if yyb397 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Parameters != nil {
			x.Parameters = nil
		}
	} else {
		if x.Parameters == nil {
			x.Parameters = new(pkg4_runtime.RawExtension)
		}
		yym401 := z.DecBinary()
		_ = yym401
		if false {
		} else if z.HasExtensions() && z.DecExt(x.Parameters) {
		} else if !yym401 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.Parameters)
		} else {
			z.DecFallback(x.Parameters, false)
		}
	}
	yyj397++
	if yyhl397 {
		yyb397 = yyj397 > l
	} else {
		yyb397 = r.CheckBreak()
	}
	if yyb397 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.OSBGUID = ""
	} else {
		x.OSBGUID = string(r.DecodeString())
	}
	yyj397++
	if yyhl397 {
		yyb397 = yyj397 > l
	} else {
		yyb397 = r.CheckBreak()
	}
	if yyb397 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.OSBDashboardURL != nil {
			x.OSBDashboardURL = nil
		}
	} else {
		if x.OSBDashboardURL == nil {
			x.OSBDashboardURL = new(string)
		}
		yym404 := z.DecBinary()
		_ = yym404
		if false {
		} else {
			*((*string)(x.OSBDashboardURL)) = r.DecodeString()
		}
	}
	yyj397++
	if yyhl397 {
		yyb397 = yyj397 > l
	} else {
		yyb397 = r.CheckBreak()
	}
	if yyb397 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.OSBLastOperation != nil {
			x.OSBLastOperation = nil
		}
	} else {
		if x.OSBLastOperation == nil {
			x.OSBLastOperation = new(string)
		}
		yym406 := z.DecBinary()
		_ = yym406
		if false {
		} else {
			*((*string)(x.OSBLastOperation)) = r.DecodeString()
		}
	}
	yyj397++
	if yyhl397 {
		yyb397 = yyj397 > l
	} else {
		yyb397 = r.CheckBreak()
	}
	if yyb397 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Checksum != nil {
			x.Checksum = nil
		}
	} else {
		if x.Checksum == nil {
			x.Checksum = new(string)
		}
		yym408 := z.DecBinary()
		_ = yym408
		if false {
		} else {
			*((*string)(x.Checksum)) = r.DecodeString()
		}
	}
	for {
		yyj397++
		if yyhl397 {
			yyb397 = yyj397 > l
		} else {
			yyb397 = r.CheckBreak()
		}
		if yyb397 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj397-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *InstanceStatus) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym409 := z.EncBinary()
		_ = yym409
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep410 := !z.EncBinary()
			yy2arr410 := z.EncBasicHandle().StructToArray
			var yyq410 [1]bool
			_, _, _ = yysep410, yyq410, yy2arr410
			const yyr410 bool = false
			var yynn410 int
			if yyr410 || yy2arr410 {
				r.EncodeArrayStart(1)
			} else {
				yynn410 = 1
				for _, b := range yyq410 {
					if b {
						yynn410++
					}
				}
				r.EncodeMapStart(yynn410)
				yynn410 = 0
			}
			if yyr410 || yy2arr410 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Conditions == nil {
					r.EncodeNil()
				} else {
					yym412 := z.EncBinary()
					_ = yym412
					if false {
					} else {
						h.encSliceInstanceCondition(([]InstanceCondition)(x.Conditions), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("conditions"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Conditions == nil {
					r.EncodeNil()
				} else {
					yym413 := z.EncBinary()
					_ = yym413
					if false {
					} else {
						h.encSliceInstanceCondition(([]InstanceCondition)(x.Conditions), e)
					}
				}
			}
			if yyr410 || yy2arr410 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *InstanceStatus) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym414 := z.DecBinary()
	_ = yym414
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct415 := r.ContainerType()
		if yyct415 == codecSelferValueTypeMap1234 {
			yyl415 := r.ReadMapStart()
			if yyl415 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl415, d)
			}
		} else if yyct415 == codecSelferValueTypeArray1234 {
			yyl415 := r.ReadArrayStart()
			if yyl415 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl415, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *InstanceStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys416Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys416Slc
	var yyhl416 bool = l >= 0
	for yyj416 := 0; ; yyj416++ {
		if yyhl416 {
			if yyj416 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys416Slc = r.DecodeBytes(yys416Slc, true, true)
		yys416 := string(yys416Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys416 {
		case "conditions":
			if r.TryDecodeAsNil() {
				x.Conditions = nil
			} else {
				yyv417 := &x.Conditions
				yym418 := z.DecBinary()
				_ = yym418
				if false {
				} else {
					h.decSliceInstanceCondition((*[]InstanceCondition)(yyv417), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys416)
		} // end switch yys416
	} // end for yyj416
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *InstanceStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj419 int
	var yyb419 bool
	var yyhl419 bool = l >= 0
	yyj419++
	if yyhl419 {
		yyb419 = yyj419 > l
	} else {
		yyb419 = r.CheckBreak()
	}
	if yyb419 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Conditions = nil
	} else {
		yyv420 := &x.Conditions
		yym421 := z.DecBinary()
		_ = yym421
		if false {
		} else {
			h.decSliceInstanceCondition((*[]InstanceCondition)(yyv420), d)
		}
	}
	for {
		yyj419++
		if yyhl419 {
			yyb419 = yyj419 > l
		} else {
			yyb419 = r.CheckBreak()
		}
		if yyb419 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj419-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *InstanceCondition) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym422 := z.EncBinary()
		_ = yym422
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep423 := !z.EncBinary()
			yy2arr423 := z.EncBasicHandle().StructToArray
			var yyq423 [4]bool
			_, _, _ = yysep423, yyq423, yy2arr423
			const yyr423 bool = false
			var yynn423 int
			if yyr423 || yy2arr423 {
				r.EncodeArrayStart(4)
			} else {
				yynn423 = 4
				for _, b := range yyq423 {
					if b {
						yynn423++
					}
				}
				r.EncodeMapStart(yynn423)
				yynn423 = 0
			}
			if yyr423 || yy2arr423 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				x.Type.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("type"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				x.Type.CodecEncodeSelf(e)
			}
			if yyr423 || yy2arr423 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				x.Status.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("status"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				x.Status.CodecEncodeSelf(e)
			}
			if yyr423 || yy2arr423 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym427 := z.EncBinary()
				_ = yym427
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("reason"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym428 := z.EncBinary()
				_ = yym428
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
				}
			}
			if yyr423 || yy2arr423 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym430 := z.EncBinary()
				_ = yym430
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Message))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("message"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym431 := z.EncBinary()
				_ = yym431
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Message))
				}
			}
			if yyr423 || yy2arr423 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *InstanceCondition) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym432 := z.DecBinary()
	_ = yym432
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct433 := r.ContainerType()
		if yyct433 == codecSelferValueTypeMap1234 {
			yyl433 := r.ReadMapStart()
			if yyl433 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl433, d)
			}
		} else if yyct433 == codecSelferValueTypeArray1234 {
			yyl433 := r.ReadArrayStart()
			if yyl433 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl433, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *InstanceCondition) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys434Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys434Slc
	var yyhl434 bool = l >= 0
	for yyj434 := 0; ; yyj434++ {
		if yyhl434 {
			if yyj434 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys434Slc = r.DecodeBytes(yys434Slc, true, true)
		yys434 := string(yys434Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys434 {
		case "type":
			if r.TryDecodeAsNil() {
				x.Type = ""
			} else {
				x.Type = InstanceConditionType(r.DecodeString())
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = ""
			} else {
				x.Status = ConditionStatus(r.DecodeString())
			}
		case "reason":
			if r.TryDecodeAsNil() {
				x.Reason = ""
			} else {
				x.Reason = string(r.DecodeString())
			}
		case "message":
			if r.TryDecodeAsNil() {
				x.Message = ""
			} else {
				x.Message = string(r.DecodeString())
			}
		default:
			z.DecStructFieldNotFound(-1, yys434)
		} // end switch yys434
	} // end for yyj434
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *InstanceCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj439 int
	var yyb439 bool
	var yyhl439 bool = l >= 0
	yyj439++
	if yyhl439 {
		yyb439 = yyj439 > l
	} else {
		yyb439 = r.CheckBreak()
	}
	if yyb439 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		x.Type = InstanceConditionType(r.DecodeString())
	}
	yyj439++
	if yyhl439 {
		yyb439 = yyj439 > l
	} else {
		yyb439 = r.CheckBreak()
	}
	if yyb439 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = ""
	} else {
		x.Status = ConditionStatus(r.DecodeString())
	}
	yyj439++
	if yyhl439 {
		yyb439 = yyj439 > l
	} else {
		yyb439 = r.CheckBreak()
	}
	if yyb439 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Reason = ""
	} else {
		x.Reason = string(r.DecodeString())
	}
	yyj439++
	if yyhl439 {
		yyb439 = yyj439 > l
	} else {
		yyb439 = r.CheckBreak()
	}
	if yyb439 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Message = ""
	} else {
		x.Message = string(r.DecodeString())
	}
	for {
		yyj439++
		if yyhl439 {
			yyb439 = yyj439 > l
		} else {
			yyb439 = r.CheckBreak()
		}
		if yyb439 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj439-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x InstanceConditionType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym444 := z.EncBinary()
	_ = yym444
	if false {
	} else if z.HasExtensions() && z.EncExt(x) {
	} else {
		r.EncodeString(codecSelferC_UTF81234, string(x))
	}
}

func (x *InstanceConditionType) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym445 := z.DecBinary()
	_ = yym445
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		*((*string)(x)) = r.DecodeString()
	}
}

func (x *BindingList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym446 := z.EncBinary()
		_ = yym446
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep447 := !z.EncBinary()
			yy2arr447 := z.EncBasicHandle().StructToArray
			var yyq447 [4]bool
			_, _, _ = yysep447, yyq447, yy2arr447
			const yyr447 bool = false
			yyq447[0] = x.Kind != ""
			yyq447[1] = x.APIVersion != ""
			yyq447[2] = true
			var yynn447 int
			if yyr447 || yy2arr447 {
				r.EncodeArrayStart(4)
			} else {
				yynn447 = 1
				for _, b := range yyq447 {
					if b {
						yynn447++
					}
				}
				r.EncodeMapStart(yynn447)
				yynn447 = 0
			}
			if yyr447 || yy2arr447 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq447[0] {
					yym449 := z.EncBinary()
					_ = yym449
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq447[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym450 := z.EncBinary()
					_ = yym450
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr447 || yy2arr447 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq447[1] {
					yym452 := z.EncBinary()
					_ = yym452
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq447[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym453 := z.EncBinary()
					_ = yym453
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr447 || yy2arr447 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq447[2] {
					yy455 := &x.ListMeta
					yym456 := z.EncBinary()
					_ = yym456
					if false {
					} else if z.HasExtensions() && z.EncExt(yy455) {
					} else {
						z.EncFallback(yy455)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq447[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy457 := &x.ListMeta
					yym458 := z.EncBinary()
					_ = yym458
					if false {
					} else if z.HasExtensions() && z.EncExt(yy457) {
					} else {
						z.EncFallback(yy457)
					}
				}
			}
			if yyr447 || yy2arr447 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym460 := z.EncBinary()
					_ = yym460
					if false {
					} else {
						h.encSliceBinding(([]Binding)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym461 := z.EncBinary()
					_ = yym461
					if false {
					} else {
						h.encSliceBinding(([]Binding)(x.Items), e)
					}
				}
			}
			if yyr447 || yy2arr447 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *BindingList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym462 := z.DecBinary()
	_ = yym462
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct463 := r.ContainerType()
		if yyct463 == codecSelferValueTypeMap1234 {
			yyl463 := r.ReadMapStart()
			if yyl463 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl463, d)
			}
		} else if yyct463 == codecSelferValueTypeArray1234 {
			yyl463 := r.ReadArrayStart()
			if yyl463 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl463, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *BindingList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys464Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys464Slc
	var yyhl464 bool = l >= 0
	for yyj464 := 0; ; yyj464++ {
		if yyhl464 {
			if yyj464 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys464Slc = r.DecodeBytes(yys464Slc, true, true)
		yys464 := string(yys464Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys464 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_v1.ListMeta{}
			} else {
				yyv467 := &x.ListMeta
				yym468 := z.DecBinary()
				_ = yym468
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv467) {
				} else {
					z.DecFallback(yyv467, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv469 := &x.Items
				yym470 := z.DecBinary()
				_ = yym470
				if false {
				} else {
					h.decSliceBinding((*[]Binding)(yyv469), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys464)
		} // end switch yys464
	} // end for yyj464
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *BindingList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj471 int
	var yyb471 bool
	var yyhl471 bool = l >= 0
	yyj471++
	if yyhl471 {
		yyb471 = yyj471 > l
	} else {
		yyb471 = r.CheckBreak()
	}
	if yyb471 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj471++
	if yyhl471 {
		yyb471 = yyj471 > l
	} else {
		yyb471 = r.CheckBreak()
	}
	if yyb471 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj471++
	if yyhl471 {
		yyb471 = yyj471 > l
	} else {
		yyb471 = r.CheckBreak()
	}
	if yyb471 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_v1.ListMeta{}
	} else {
		yyv474 := &x.ListMeta
		yym475 := z.DecBinary()
		_ = yym475
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv474) {
		} else {
			z.DecFallback(yyv474, false)
		}
	}
	yyj471++
	if yyhl471 {
		yyb471 = yyj471 > l
	} else {
		yyb471 = r.CheckBreak()
	}
	if yyb471 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv476 := &x.Items
		yym477 := z.DecBinary()
		_ = yym477
		if false {
		} else {
			h.decSliceBinding((*[]Binding)(yyv476), d)
		}
	}
	for {
		yyj471++
		if yyhl471 {
			yyb471 = yyj471 > l
		} else {
			yyb471 = r.CheckBreak()
		}
		if yyb471 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj471-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *Binding) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym478 := z.EncBinary()
		_ = yym478
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep479 := !z.EncBinary()
			yy2arr479 := z.EncBasicHandle().StructToArray
			var yyq479 [5]bool
			_, _, _ = yysep479, yyq479, yy2arr479
			const yyr479 bool = false
			yyq479[0] = x.Kind != ""
			yyq479[1] = x.APIVersion != ""
			yyq479[2] = true
			var yynn479 int
			if yyr479 || yy2arr479 {
				r.EncodeArrayStart(5)
			} else {
				yynn479 = 2
				for _, b := range yyq479 {
					if b {
						yynn479++
					}
				}
				r.EncodeMapStart(yynn479)
				yynn479 = 0
			}
			if yyr479 || yy2arr479 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq479[0] {
					yym481 := z.EncBinary()
					_ = yym481
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq479[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym482 := z.EncBinary()
					_ = yym482
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr479 || yy2arr479 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq479[1] {
					yym484 := z.EncBinary()
					_ = yym484
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq479[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym485 := z.EncBinary()
					_ = yym485
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr479 || yy2arr479 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq479[2] {
					yy487 := &x.ObjectMeta
					yy487.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq479[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy488 := &x.ObjectMeta
					yy488.CodecEncodeSelf(e)
				}
			}
			if yyr479 || yy2arr479 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy490 := &x.Spec
				yy490.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("spec"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy491 := &x.Spec
				yy491.CodecEncodeSelf(e)
			}
			if yyr479 || yy2arr479 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy493 := &x.Status
				yy493.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("status"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy494 := &x.Status
				yy494.CodecEncodeSelf(e)
			}
			if yyr479 || yy2arr479 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *Binding) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym495 := z.DecBinary()
	_ = yym495
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct496 := r.ContainerType()
		if yyct496 == codecSelferValueTypeMap1234 {
			yyl496 := r.ReadMapStart()
			if yyl496 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl496, d)
			}
		} else if yyct496 == codecSelferValueTypeArray1234 {
			yyl496 := r.ReadArrayStart()
			if yyl496 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl496, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *Binding) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys497Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys497Slc
	var yyhl497 bool = l >= 0
	for yyj497 := 0; ; yyj497++ {
		if yyhl497 {
			if yyj497 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys497Slc = r.DecodeBytes(yys497Slc, true, true)
		yys497 := string(yys497Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys497 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv500 := &x.ObjectMeta
				yyv500.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = BindingSpec{}
			} else {
				yyv501 := &x.Spec
				yyv501.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = BindingStatus{}
			} else {
				yyv502 := &x.Status
				yyv502.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys497)
		} // end switch yys497
	} // end for yyj497
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *Binding) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj503 int
	var yyb503 bool
	var yyhl503 bool = l >= 0
	yyj503++
	if yyhl503 {
		yyb503 = yyj503 > l
	} else {
		yyb503 = r.CheckBreak()
	}
	if yyb503 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj503++
	if yyhl503 {
		yyb503 = yyj503 > l
	} else {
		yyb503 = r.CheckBreak()
	}
	if yyb503 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj503++
	if yyhl503 {
		yyb503 = yyj503 > l
	} else {
		yyb503 = r.CheckBreak()
	}
	if yyb503 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv506 := &x.ObjectMeta
		yyv506.CodecDecodeSelf(d)
	}
	yyj503++
	if yyhl503 {
		yyb503 = yyj503 > l
	} else {
		yyb503 = r.CheckBreak()
	}
	if yyb503 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = BindingSpec{}
	} else {
		yyv507 := &x.Spec
		yyv507.CodecDecodeSelf(d)
	}
	yyj503++
	if yyhl503 {
		yyb503 = yyj503 > l
	} else {
		yyb503 = r.CheckBreak()
	}
	if yyb503 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = BindingStatus{}
	} else {
		yyv508 := &x.Status
		yyv508.CodecDecodeSelf(d)
	}
	for {
		yyj503++
		if yyhl503 {
			yyb503 = yyj503 > l
		} else {
			yyb503 = r.CheckBreak()
		}
		if yyb503 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj503-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *BindingSpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym509 := z.EncBinary()
		_ = yym509
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep510 := !z.EncBinary()
			yy2arr510 := z.EncBasicHandle().StructToArray
			var yyq510 [5]bool
			_, _, _ = yysep510, yyq510, yy2arr510
			const yyr510 bool = false
			yyq510[1] = x.Parameters != nil
			yyq510[4] = x.Checksum != nil
			var yynn510 int
			if yyr510 || yy2arr510 {
				r.EncodeArrayStart(5)
			} else {
				yynn510 = 3
				for _, b := range yyq510 {
					if b {
						yynn510++
					}
				}
				r.EncodeMapStart(yynn510)
				yynn510 = 0
			}
			if yyr510 || yy2arr510 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy512 := &x.InstanceRef
				yy512.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("instanceRef"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy513 := &x.InstanceRef
				yy513.CodecEncodeSelf(e)
			}
			if yyr510 || yy2arr510 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq510[1] {
					if x.Parameters == nil {
						r.EncodeNil()
					} else {
						yym515 := z.EncBinary()
						_ = yym515
						if false {
						} else if z.HasExtensions() && z.EncExt(x.Parameters) {
						} else if !yym515 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.Parameters)
						} else {
							z.EncFallback(x.Parameters)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq510[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("parameters"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Parameters == nil {
						r.EncodeNil()
					} else {
						yym516 := z.EncBinary()
						_ = yym516
						if false {
						} else if z.HasExtensions() && z.EncExt(x.Parameters) {
						} else if !yym516 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.Parameters)
						} else {
							z.EncFallback(x.Parameters)
						}
					}
				}
			}
			if yyr510 || yy2arr510 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym518 := z.EncBinary()
				_ = yym518
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.SecretName))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("secretName"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym519 := z.EncBinary()
				_ = yym519
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.SecretName))
				}
			}
			if yyr510 || yy2arr510 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym521 := z.EncBinary()
				_ = yym521
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.OSBGUID))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("osbGuid"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym522 := z.EncBinary()
				_ = yym522
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.OSBGUID))
				}
			}
			if yyr510 || yy2arr510 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq510[4] {
					if x.Checksum == nil {
						r.EncodeNil()
					} else {
						yy524 := *x.Checksum
						yym525 := z.EncBinary()
						_ = yym525
						if false {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy524))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq510[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("checksum"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Checksum == nil {
						r.EncodeNil()
					} else {
						yy526 := *x.Checksum
						yym527 := z.EncBinary()
						_ = yym527
						if false {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy526))
						}
					}
				}
			}
			if yyr510 || yy2arr510 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *BindingSpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym528 := z.DecBinary()
	_ = yym528
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct529 := r.ContainerType()
		if yyct529 == codecSelferValueTypeMap1234 {
			yyl529 := r.ReadMapStart()
			if yyl529 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl529, d)
			}
		} else if yyct529 == codecSelferValueTypeArray1234 {
			yyl529 := r.ReadArrayStart()
			if yyl529 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl529, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *BindingSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys530Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys530Slc
	var yyhl530 bool = l >= 0
	for yyj530 := 0; ; yyj530++ {
		if yyhl530 {
			if yyj530 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys530Slc = r.DecodeBytes(yys530Slc, true, true)
		yys530 := string(yys530Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys530 {
		case "instanceRef":
			if r.TryDecodeAsNil() {
				x.InstanceRef = pkg2_v1.LocalObjectReference{}
			} else {
				yyv531 := &x.InstanceRef
				yyv531.CodecDecodeSelf(d)
			}
		case "parameters":
			if r.TryDecodeAsNil() {
				if x.Parameters != nil {
					x.Parameters = nil
				}
			} else {
				if x.Parameters == nil {
					x.Parameters = new(pkg4_runtime.RawExtension)
				}
				yym533 := z.DecBinary()
				_ = yym533
				if false {
				} else if z.HasExtensions() && z.DecExt(x.Parameters) {
				} else if !yym533 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(x.Parameters)
				} else {
					z.DecFallback(x.Parameters, false)
				}
			}
		case "secretName":
			if r.TryDecodeAsNil() {
				x.SecretName = ""
			} else {
				x.SecretName = string(r.DecodeString())
			}
		case "osbGuid":
			if r.TryDecodeAsNil() {
				x.OSBGUID = ""
			} else {
				x.OSBGUID = string(r.DecodeString())
			}
		case "checksum":
			if r.TryDecodeAsNil() {
				if x.Checksum != nil {
					x.Checksum = nil
				}
			} else {
				if x.Checksum == nil {
					x.Checksum = new(string)
				}
				yym537 := z.DecBinary()
				_ = yym537
				if false {
				} else {
					*((*string)(x.Checksum)) = r.DecodeString()
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys530)
		} // end switch yys530
	} // end for yyj530
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *BindingSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj538 int
	var yyb538 bool
	var yyhl538 bool = l >= 0
	yyj538++
	if yyhl538 {
		yyb538 = yyj538 > l
	} else {
		yyb538 = r.CheckBreak()
	}
	if yyb538 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.InstanceRef = pkg2_v1.LocalObjectReference{}
	} else {
		yyv539 := &x.InstanceRef
		yyv539.CodecDecodeSelf(d)
	}
	yyj538++
	if yyhl538 {
		yyb538 = yyj538 > l
	} else {
		yyb538 = r.CheckBreak()
	}
	if yyb538 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Parameters != nil {
			x.Parameters = nil
		}
	} else {
		if x.Parameters == nil {
			x.Parameters = new(pkg4_runtime.RawExtension)
		}
		yym541 := z.DecBinary()
		_ = yym541
		if false {
		} else if z.HasExtensions() && z.DecExt(x.Parameters) {
		} else if !yym541 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.Parameters)
		} else {
			z.DecFallback(x.Parameters, false)
		}
	}
	yyj538++
	if yyhl538 {
		yyb538 = yyj538 > l
	} else {
		yyb538 = r.CheckBreak()
	}
	if yyb538 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.SecretName = ""
	} else {
		x.SecretName = string(r.DecodeString())
	}
	yyj538++
	if yyhl538 {
		yyb538 = yyj538 > l
	} else {
		yyb538 = r.CheckBreak()
	}
	if yyb538 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.OSBGUID = ""
	} else {
		x.OSBGUID = string(r.DecodeString())
	}
	yyj538++
	if yyhl538 {
		yyb538 = yyj538 > l
	} else {
		yyb538 = r.CheckBreak()
	}
	if yyb538 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Checksum != nil {
			x.Checksum = nil
		}
	} else {
		if x.Checksum == nil {
			x.Checksum = new(string)
		}
		yym545 := z.DecBinary()
		_ = yym545
		if false {
		} else {
			*((*string)(x.Checksum)) = r.DecodeString()
		}
	}
	for {
		yyj538++
		if yyhl538 {
			yyb538 = yyj538 > l
		} else {
			yyb538 = r.CheckBreak()
		}
		if yyb538 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj538-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *BindingStatus) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym546 := z.EncBinary()
		_ = yym546
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep547 := !z.EncBinary()
			yy2arr547 := z.EncBasicHandle().StructToArray
			var yyq547 [1]bool
			_, _, _ = yysep547, yyq547, yy2arr547
			const yyr547 bool = false
			var yynn547 int
			if yyr547 || yy2arr547 {
				r.EncodeArrayStart(1)
			} else {
				yynn547 = 1
				for _, b := range yyq547 {
					if b {
						yynn547++
					}
				}
				r.EncodeMapStart(yynn547)
				yynn547 = 0
			}
			if yyr547 || yy2arr547 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Conditions == nil {
					r.EncodeNil()
				} else {
					yym549 := z.EncBinary()
					_ = yym549
					if false {
					} else {
						h.encSliceBindingCondition(([]BindingCondition)(x.Conditions), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("conditions"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Conditions == nil {
					r.EncodeNil()
				} else {
					yym550 := z.EncBinary()
					_ = yym550
					if false {
					} else {
						h.encSliceBindingCondition(([]BindingCondition)(x.Conditions), e)
					}
				}
			}
			if yyr547 || yy2arr547 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *BindingStatus) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym551 := z.DecBinary()
	_ = yym551
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct552 := r.ContainerType()
		if yyct552 == codecSelferValueTypeMap1234 {
			yyl552 := r.ReadMapStart()
			if yyl552 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl552, d)
			}
		} else if yyct552 == codecSelferValueTypeArray1234 {
			yyl552 := r.ReadArrayStart()
			if yyl552 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl552, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *BindingStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys553Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys553Slc
	var yyhl553 bool = l >= 0
	for yyj553 := 0; ; yyj553++ {
		if yyhl553 {
			if yyj553 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys553Slc = r.DecodeBytes(yys553Slc, true, true)
		yys553 := string(yys553Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys553 {
		case "conditions":
			if r.TryDecodeAsNil() {
				x.Conditions = nil
			} else {
				yyv554 := &x.Conditions
				yym555 := z.DecBinary()
				_ = yym555
				if false {
				} else {
					h.decSliceBindingCondition((*[]BindingCondition)(yyv554), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys553)
		} // end switch yys553
	} // end for yyj553
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *BindingStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj556 int
	var yyb556 bool
	var yyhl556 bool = l >= 0
	yyj556++
	if yyhl556 {
		yyb556 = yyj556 > l
	} else {
		yyb556 = r.CheckBreak()
	}
	if yyb556 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Conditions = nil
	} else {
		yyv557 := &x.Conditions
		yym558 := z.DecBinary()
		_ = yym558
		if false {
		} else {
			h.decSliceBindingCondition((*[]BindingCondition)(yyv557), d)
		}
	}
	for {
		yyj556++
		if yyhl556 {
			yyb556 = yyj556 > l
		} else {
			yyb556 = r.CheckBreak()
		}
		if yyb556 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj556-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *BindingCondition) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym559 := z.EncBinary()
		_ = yym559
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep560 := !z.EncBinary()
			yy2arr560 := z.EncBasicHandle().StructToArray
			var yyq560 [4]bool
			_, _, _ = yysep560, yyq560, yy2arr560
			const yyr560 bool = false
			var yynn560 int
			if yyr560 || yy2arr560 {
				r.EncodeArrayStart(4)
			} else {
				yynn560 = 4
				for _, b := range yyq560 {
					if b {
						yynn560++
					}
				}
				r.EncodeMapStart(yynn560)
				yynn560 = 0
			}
			if yyr560 || yy2arr560 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				x.Type.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("type"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				x.Type.CodecEncodeSelf(e)
			}
			if yyr560 || yy2arr560 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				x.Status.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("status"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				x.Status.CodecEncodeSelf(e)
			}
			if yyr560 || yy2arr560 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym564 := z.EncBinary()
				_ = yym564
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("reason"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym565 := z.EncBinary()
				_ = yym565
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
				}
			}
			if yyr560 || yy2arr560 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym567 := z.EncBinary()
				_ = yym567
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Message))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("message"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym568 := z.EncBinary()
				_ = yym568
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Message))
				}
			}
			if yyr560 || yy2arr560 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *BindingCondition) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym569 := z.DecBinary()
	_ = yym569
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct570 := r.ContainerType()
		if yyct570 == codecSelferValueTypeMap1234 {
			yyl570 := r.ReadMapStart()
			if yyl570 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl570, d)
			}
		} else if yyct570 == codecSelferValueTypeArray1234 {
			yyl570 := r.ReadArrayStart()
			if yyl570 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl570, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *BindingCondition) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys571Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys571Slc
	var yyhl571 bool = l >= 0
	for yyj571 := 0; ; yyj571++ {
		if yyhl571 {
			if yyj571 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys571Slc = r.DecodeBytes(yys571Slc, true, true)
		yys571 := string(yys571Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys571 {
		case "type":
			if r.TryDecodeAsNil() {
				x.Type = ""
			} else {
				x.Type = BindingConditionType(r.DecodeString())
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = ""
			} else {
				x.Status = ConditionStatus(r.DecodeString())
			}
		case "reason":
			if r.TryDecodeAsNil() {
				x.Reason = ""
			} else {
				x.Reason = string(r.DecodeString())
			}
		case "message":
			if r.TryDecodeAsNil() {
				x.Message = ""
			} else {
				x.Message = string(r.DecodeString())
			}
		default:
			z.DecStructFieldNotFound(-1, yys571)
		} // end switch yys571
	} // end for yyj571
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *BindingCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj576 int
	var yyb576 bool
	var yyhl576 bool = l >= 0
	yyj576++
	if yyhl576 {
		yyb576 = yyj576 > l
	} else {
		yyb576 = r.CheckBreak()
	}
	if yyb576 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		x.Type = BindingConditionType(r.DecodeString())
	}
	yyj576++
	if yyhl576 {
		yyb576 = yyj576 > l
	} else {
		yyb576 = r.CheckBreak()
	}
	if yyb576 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = ""
	} else {
		x.Status = ConditionStatus(r.DecodeString())
	}
	yyj576++
	if yyhl576 {
		yyb576 = yyj576 > l
	} else {
		yyb576 = r.CheckBreak()
	}
	if yyb576 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Reason = ""
	} else {
		x.Reason = string(r.DecodeString())
	}
	yyj576++
	if yyhl576 {
		yyb576 = yyj576 > l
	} else {
		yyb576 = r.CheckBreak()
	}
	if yyb576 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Message = ""
	} else {
		x.Message = string(r.DecodeString())
	}
	for {
		yyj576++
		if yyhl576 {
			yyb576 = yyj576 > l
		} else {
			yyb576 = r.CheckBreak()
		}
		if yyb576 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj576-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x BindingConditionType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym581 := z.EncBinary()
	_ = yym581
	if false {
	} else if z.HasExtensions() && z.EncExt(x) {
	} else {
		r.EncodeString(codecSelferC_UTF81234, string(x))
	}
}

func (x *BindingConditionType) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym582 := z.DecBinary()
	_ = yym582
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		*((*string)(x)) = r.DecodeString()
	}
}

func (x codecSelfer1234) encSliceBroker(v []Broker, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv583 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy584 := &yyv583
		yy584.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceBroker(v *[]Broker, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv585 := *v
	yyh585, yyl585 := z.DecSliceHelperStart()
	var yyc585 bool
	if yyl585 == 0 {
		if yyv585 == nil {
			yyv585 = []Broker{}
			yyc585 = true
		} else if len(yyv585) != 0 {
			yyv585 = yyv585[:0]
			yyc585 = true
		}
	} else if yyl585 > 0 {
		var yyrr585, yyrl585 int
		var yyrt585 bool
		if yyl585 > cap(yyv585) {

			yyrg585 := len(yyv585) > 0
			yyv2585 := yyv585
			yyrl585, yyrt585 = z.DecInferLen(yyl585, z.DecBasicHandle().MaxInitLen, 304)
			if yyrt585 {
				if yyrl585 <= cap(yyv585) {
					yyv585 = yyv585[:yyrl585]
				} else {
					yyv585 = make([]Broker, yyrl585)
				}
			} else {
				yyv585 = make([]Broker, yyrl585)
			}
			yyc585 = true
			yyrr585 = len(yyv585)
			if yyrg585 {
				copy(yyv585, yyv2585)
			}
		} else if yyl585 != len(yyv585) {
			yyv585 = yyv585[:yyl585]
			yyc585 = true
		}
		yyj585 := 0
		for ; yyj585 < yyrr585; yyj585++ {
			yyh585.ElemContainerState(yyj585)
			if r.TryDecodeAsNil() {
				yyv585[yyj585] = Broker{}
			} else {
				yyv586 := &yyv585[yyj585]
				yyv586.CodecDecodeSelf(d)
			}

		}
		if yyrt585 {
			for ; yyj585 < yyl585; yyj585++ {
				yyv585 = append(yyv585, Broker{})
				yyh585.ElemContainerState(yyj585)
				if r.TryDecodeAsNil() {
					yyv585[yyj585] = Broker{}
				} else {
					yyv587 := &yyv585[yyj585]
					yyv587.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj585 := 0
		for ; !r.CheckBreak(); yyj585++ {

			if yyj585 >= len(yyv585) {
				yyv585 = append(yyv585, Broker{}) // var yyz585 Broker
				yyc585 = true
			}
			yyh585.ElemContainerState(yyj585)
			if yyj585 < len(yyv585) {
				if r.TryDecodeAsNil() {
					yyv585[yyj585] = Broker{}
				} else {
					yyv588 := &yyv585[yyj585]
					yyv588.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj585 < len(yyv585) {
			yyv585 = yyv585[:yyj585]
			yyc585 = true
		} else if yyj585 == 0 && yyv585 == nil {
			yyv585 = []Broker{}
			yyc585 = true
		}
	}
	yyh585.End()
	if yyc585 {
		*v = yyv585
	}
}

func (x codecSelfer1234) encSliceBrokerCondition(v []BrokerCondition, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv589 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy590 := &yyv589
		yy590.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceBrokerCondition(v *[]BrokerCondition, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv591 := *v
	yyh591, yyl591 := z.DecSliceHelperStart()
	var yyc591 bool
	if yyl591 == 0 {
		if yyv591 == nil {
			yyv591 = []BrokerCondition{}
			yyc591 = true
		} else if len(yyv591) != 0 {
			yyv591 = yyv591[:0]
			yyc591 = true
		}
	} else if yyl591 > 0 {
		var yyrr591, yyrl591 int
		var yyrt591 bool
		if yyl591 > cap(yyv591) {

			yyrg591 := len(yyv591) > 0
			yyv2591 := yyv591
			yyrl591, yyrt591 = z.DecInferLen(yyl591, z.DecBasicHandle().MaxInitLen, 64)
			if yyrt591 {
				if yyrl591 <= cap(yyv591) {
					yyv591 = yyv591[:yyrl591]
				} else {
					yyv591 = make([]BrokerCondition, yyrl591)
				}
			} else {
				yyv591 = make([]BrokerCondition, yyrl591)
			}
			yyc591 = true
			yyrr591 = len(yyv591)
			if yyrg591 {
				copy(yyv591, yyv2591)
			}
		} else if yyl591 != len(yyv591) {
			yyv591 = yyv591[:yyl591]
			yyc591 = true
		}
		yyj591 := 0
		for ; yyj591 < yyrr591; yyj591++ {
			yyh591.ElemContainerState(yyj591)
			if r.TryDecodeAsNil() {
				yyv591[yyj591] = BrokerCondition{}
			} else {
				yyv592 := &yyv591[yyj591]
				yyv592.CodecDecodeSelf(d)
			}

		}
		if yyrt591 {
			for ; yyj591 < yyl591; yyj591++ {
				yyv591 = append(yyv591, BrokerCondition{})
				yyh591.ElemContainerState(yyj591)
				if r.TryDecodeAsNil() {
					yyv591[yyj591] = BrokerCondition{}
				} else {
					yyv593 := &yyv591[yyj591]
					yyv593.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj591 := 0
		for ; !r.CheckBreak(); yyj591++ {

			if yyj591 >= len(yyv591) {
				yyv591 = append(yyv591, BrokerCondition{}) // var yyz591 BrokerCondition
				yyc591 = true
			}
			yyh591.ElemContainerState(yyj591)
			if yyj591 < len(yyv591) {
				if r.TryDecodeAsNil() {
					yyv591[yyj591] = BrokerCondition{}
				} else {
					yyv594 := &yyv591[yyj591]
					yyv594.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj591 < len(yyv591) {
			yyv591 = yyv591[:yyj591]
			yyc591 = true
		} else if yyj591 == 0 && yyv591 == nil {
			yyv591 = []BrokerCondition{}
			yyc591 = true
		}
	}
	yyh591.End()
	if yyc591 {
		*v = yyv591
	}
}

func (x codecSelfer1234) encSliceServiceClass(v []ServiceClass, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv595 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy596 := &yyv595
		yy596.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceServiceClass(v *[]ServiceClass, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv597 := *v
	yyh597, yyl597 := z.DecSliceHelperStart()
	var yyc597 bool
	if yyl597 == 0 {
		if yyv597 == nil {
			yyv597 = []ServiceClass{}
			yyc597 = true
		} else if len(yyv597) != 0 {
			yyv597 = yyv597[:0]
			yyc597 = true
		}
	} else if yyl597 > 0 {
		var yyrr597, yyrl597 int
		var yyrt597 bool
		if yyl597 > cap(yyv597) {

			yyrg597 := len(yyv597) > 0
			yyv2597 := yyv597
			yyrl597, yyrt597 = z.DecInferLen(yyl597, z.DecBasicHandle().MaxInitLen, 416)
			if yyrt597 {
				if yyrl597 <= cap(yyv597) {
					yyv597 = yyv597[:yyrl597]
				} else {
					yyv597 = make([]ServiceClass, yyrl597)
				}
			} else {
				yyv597 = make([]ServiceClass, yyrl597)
			}
			yyc597 = true
			yyrr597 = len(yyv597)
			if yyrg597 {
				copy(yyv597, yyv2597)
			}
		} else if yyl597 != len(yyv597) {
			yyv597 = yyv597[:yyl597]
			yyc597 = true
		}
		yyj597 := 0
		for ; yyj597 < yyrr597; yyj597++ {
			yyh597.ElemContainerState(yyj597)
			if r.TryDecodeAsNil() {
				yyv597[yyj597] = ServiceClass{}
			} else {
				yyv598 := &yyv597[yyj597]
				yyv598.CodecDecodeSelf(d)
			}

		}
		if yyrt597 {
			for ; yyj597 < yyl597; yyj597++ {
				yyv597 = append(yyv597, ServiceClass{})
				yyh597.ElemContainerState(yyj597)
				if r.TryDecodeAsNil() {
					yyv597[yyj597] = ServiceClass{}
				} else {
					yyv599 := &yyv597[yyj597]
					yyv599.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj597 := 0
		for ; !r.CheckBreak(); yyj597++ {

			if yyj597 >= len(yyv597) {
				yyv597 = append(yyv597, ServiceClass{}) // var yyz597 ServiceClass
				yyc597 = true
			}
			yyh597.ElemContainerState(yyj597)
			if yyj597 < len(yyv597) {
				if r.TryDecodeAsNil() {
					yyv597[yyj597] = ServiceClass{}
				} else {
					yyv600 := &yyv597[yyj597]
					yyv600.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj597 < len(yyv597) {
			yyv597 = yyv597[:yyj597]
			yyc597 = true
		} else if yyj597 == 0 && yyv597 == nil {
			yyv597 = []ServiceClass{}
			yyc597 = true
		}
	}
	yyh597.End()
	if yyc597 {
		*v = yyv597
	}
}

func (x codecSelfer1234) encSliceServicePlan(v []ServicePlan, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv601 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy602 := &yyv601
		yy602.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceServicePlan(v *[]ServicePlan, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv603 := *v
	yyh603, yyl603 := z.DecSliceHelperStart()
	var yyc603 bool
	if yyl603 == 0 {
		if yyv603 == nil {
			yyv603 = []ServicePlan{}
			yyc603 = true
		} else if len(yyv603) != 0 {
			yyv603 = yyv603[:0]
			yyc603 = true
		}
	} else if yyl603 > 0 {
		var yyrr603, yyrl603 int
		var yyrt603 bool
		if yyl603 > cap(yyv603) {

			yyrg603 := len(yyv603) > 0
			yyv2603 := yyv603
			yyrl603, yyrt603 = z.DecInferLen(yyl603, z.DecBasicHandle().MaxInitLen, 56)
			if yyrt603 {
				if yyrl603 <= cap(yyv603) {
					yyv603 = yyv603[:yyrl603]
				} else {
					yyv603 = make([]ServicePlan, yyrl603)
				}
			} else {
				yyv603 = make([]ServicePlan, yyrl603)
			}
			yyc603 = true
			yyrr603 = len(yyv603)
			if yyrg603 {
				copy(yyv603, yyv2603)
			}
		} else if yyl603 != len(yyv603) {
			yyv603 = yyv603[:yyl603]
			yyc603 = true
		}
		yyj603 := 0
		for ; yyj603 < yyrr603; yyj603++ {
			yyh603.ElemContainerState(yyj603)
			if r.TryDecodeAsNil() {
				yyv603[yyj603] = ServicePlan{}
			} else {
				yyv604 := &yyv603[yyj603]
				yyv604.CodecDecodeSelf(d)
			}

		}
		if yyrt603 {
			for ; yyj603 < yyl603; yyj603++ {
				yyv603 = append(yyv603, ServicePlan{})
				yyh603.ElemContainerState(yyj603)
				if r.TryDecodeAsNil() {
					yyv603[yyj603] = ServicePlan{}
				} else {
					yyv605 := &yyv603[yyj603]
					yyv605.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj603 := 0
		for ; !r.CheckBreak(); yyj603++ {

			if yyj603 >= len(yyv603) {
				yyv603 = append(yyv603, ServicePlan{}) // var yyz603 ServicePlan
				yyc603 = true
			}
			yyh603.ElemContainerState(yyj603)
			if yyj603 < len(yyv603) {
				if r.TryDecodeAsNil() {
					yyv603[yyj603] = ServicePlan{}
				} else {
					yyv606 := &yyv603[yyj603]
					yyv606.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj603 < len(yyv603) {
			yyv603 = yyv603[:yyj603]
			yyc603 = true
		} else if yyj603 == 0 && yyv603 == nil {
			yyv603 = []ServicePlan{}
			yyc603 = true
		}
	}
	yyh603.End()
	if yyc603 {
		*v = yyv603
	}
}

func (x codecSelfer1234) encSliceInstance(v []Instance, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv607 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy608 := &yyv607
		yy608.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceInstance(v *[]Instance, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv609 := *v
	yyh609, yyl609 := z.DecSliceHelperStart()
	var yyc609 bool
	if yyl609 == 0 {
		if yyv609 == nil {
			yyv609 = []Instance{}
			yyc609 = true
		} else if len(yyv609) != 0 {
			yyv609 = yyv609[:0]
			yyc609 = true
		}
	} else if yyl609 > 0 {
		var yyrr609, yyrl609 int
		var yyrt609 bool
		if yyl609 > cap(yyv609) {

			yyrg609 := len(yyv609) > 0
			yyv2609 := yyv609
			yyrl609, yyrt609 = z.DecInferLen(yyl609, z.DecBasicHandle().MaxInitLen, 360)
			if yyrt609 {
				if yyrl609 <= cap(yyv609) {
					yyv609 = yyv609[:yyrl609]
				} else {
					yyv609 = make([]Instance, yyrl609)
				}
			} else {
				yyv609 = make([]Instance, yyrl609)
			}
			yyc609 = true
			yyrr609 = len(yyv609)
			if yyrg609 {
				copy(yyv609, yyv2609)
			}
		} else if yyl609 != len(yyv609) {
			yyv609 = yyv609[:yyl609]
			yyc609 = true
		}
		yyj609 := 0
		for ; yyj609 < yyrr609; yyj609++ {
			yyh609.ElemContainerState(yyj609)
			if r.TryDecodeAsNil() {
				yyv609[yyj609] = Instance{}
			} else {
				yyv610 := &yyv609[yyj609]
				yyv610.CodecDecodeSelf(d)
			}

		}
		if yyrt609 {
			for ; yyj609 < yyl609; yyj609++ {
				yyv609 = append(yyv609, Instance{})
				yyh609.ElemContainerState(yyj609)
				if r.TryDecodeAsNil() {
					yyv609[yyj609] = Instance{}
				} else {
					yyv611 := &yyv609[yyj609]
					yyv611.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj609 := 0
		for ; !r.CheckBreak(); yyj609++ {

			if yyj609 >= len(yyv609) {
				yyv609 = append(yyv609, Instance{}) // var yyz609 Instance
				yyc609 = true
			}
			yyh609.ElemContainerState(yyj609)
			if yyj609 < len(yyv609) {
				if r.TryDecodeAsNil() {
					yyv609[yyj609] = Instance{}
				} else {
					yyv612 := &yyv609[yyj609]
					yyv612.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj609 < len(yyv609) {
			yyv609 = yyv609[:yyj609]
			yyc609 = true
		} else if yyj609 == 0 && yyv609 == nil {
			yyv609 = []Instance{}
			yyc609 = true
		}
	}
	yyh609.End()
	if yyc609 {
		*v = yyv609
	}
}

func (x codecSelfer1234) encSliceInstanceCondition(v []InstanceCondition, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv613 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy614 := &yyv613
		yy614.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceInstanceCondition(v *[]InstanceCondition, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv615 := *v
	yyh615, yyl615 := z.DecSliceHelperStart()
	var yyc615 bool
	if yyl615 == 0 {
		if yyv615 == nil {
			yyv615 = []InstanceCondition{}
			yyc615 = true
		} else if len(yyv615) != 0 {
			yyv615 = yyv615[:0]
			yyc615 = true
		}
	} else if yyl615 > 0 {
		var yyrr615, yyrl615 int
		var yyrt615 bool
		if yyl615 > cap(yyv615) {

			yyrg615 := len(yyv615) > 0
			yyv2615 := yyv615
			yyrl615, yyrt615 = z.DecInferLen(yyl615, z.DecBasicHandle().MaxInitLen, 64)
			if yyrt615 {
				if yyrl615 <= cap(yyv615) {
					yyv615 = yyv615[:yyrl615]
				} else {
					yyv615 = make([]InstanceCondition, yyrl615)
				}
			} else {
				yyv615 = make([]InstanceCondition, yyrl615)
			}
			yyc615 = true
			yyrr615 = len(yyv615)
			if yyrg615 {
				copy(yyv615, yyv2615)
			}
		} else if yyl615 != len(yyv615) {
			yyv615 = yyv615[:yyl615]
			yyc615 = true
		}
		yyj615 := 0
		for ; yyj615 < yyrr615; yyj615++ {
			yyh615.ElemContainerState(yyj615)
			if r.TryDecodeAsNil() {
				yyv615[yyj615] = InstanceCondition{}
			} else {
				yyv616 := &yyv615[yyj615]
				yyv616.CodecDecodeSelf(d)
			}

		}
		if yyrt615 {
			for ; yyj615 < yyl615; yyj615++ {
				yyv615 = append(yyv615, InstanceCondition{})
				yyh615.ElemContainerState(yyj615)
				if r.TryDecodeAsNil() {
					yyv615[yyj615] = InstanceCondition{}
				} else {
					yyv617 := &yyv615[yyj615]
					yyv617.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj615 := 0
		for ; !r.CheckBreak(); yyj615++ {

			if yyj615 >= len(yyv615) {
				yyv615 = append(yyv615, InstanceCondition{}) // var yyz615 InstanceCondition
				yyc615 = true
			}
			yyh615.ElemContainerState(yyj615)
			if yyj615 < len(yyv615) {
				if r.TryDecodeAsNil() {
					yyv615[yyj615] = InstanceCondition{}
				} else {
					yyv618 := &yyv615[yyj615]
					yyv618.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj615 < len(yyv615) {
			yyv615 = yyv615[:yyj615]
			yyc615 = true
		} else if yyj615 == 0 && yyv615 == nil {
			yyv615 = []InstanceCondition{}
			yyc615 = true
		}
	}
	yyh615.End()
	if yyc615 {
		*v = yyv615
	}
}

func (x codecSelfer1234) encSliceBinding(v []Binding, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv619 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy620 := &yyv619
		yy620.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceBinding(v *[]Binding, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv621 := *v
	yyh621, yyl621 := z.DecSliceHelperStart()
	var yyc621 bool
	if yyl621 == 0 {
		if yyv621 == nil {
			yyv621 = []Binding{}
			yyc621 = true
		} else if len(yyv621) != 0 {
			yyv621 = yyv621[:0]
			yyc621 = true
		}
	} else if yyl621 > 0 {
		var yyrr621, yyrl621 int
		var yyrt621 bool
		if yyl621 > cap(yyv621) {

			yyrg621 := len(yyv621) > 0
			yyv2621 := yyv621
			yyrl621, yyrt621 = z.DecInferLen(yyl621, z.DecBasicHandle().MaxInitLen, 344)
			if yyrt621 {
				if yyrl621 <= cap(yyv621) {
					yyv621 = yyv621[:yyrl621]
				} else {
					yyv621 = make([]Binding, yyrl621)
				}
			} else {
				yyv621 = make([]Binding, yyrl621)
			}
			yyc621 = true
			yyrr621 = len(yyv621)
			if yyrg621 {
				copy(yyv621, yyv2621)
			}
		} else if yyl621 != len(yyv621) {
			yyv621 = yyv621[:yyl621]
			yyc621 = true
		}
		yyj621 := 0
		for ; yyj621 < yyrr621; yyj621++ {
			yyh621.ElemContainerState(yyj621)
			if r.TryDecodeAsNil() {
				yyv621[yyj621] = Binding{}
			} else {
				yyv622 := &yyv621[yyj621]
				yyv622.CodecDecodeSelf(d)
			}

		}
		if yyrt621 {
			for ; yyj621 < yyl621; yyj621++ {
				yyv621 = append(yyv621, Binding{})
				yyh621.ElemContainerState(yyj621)
				if r.TryDecodeAsNil() {
					yyv621[yyj621] = Binding{}
				} else {
					yyv623 := &yyv621[yyj621]
					yyv623.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj621 := 0
		for ; !r.CheckBreak(); yyj621++ {

			if yyj621 >= len(yyv621) {
				yyv621 = append(yyv621, Binding{}) // var yyz621 Binding
				yyc621 = true
			}
			yyh621.ElemContainerState(yyj621)
			if yyj621 < len(yyv621) {
				if r.TryDecodeAsNil() {
					yyv621[yyj621] = Binding{}
				} else {
					yyv624 := &yyv621[yyj621]
					yyv624.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj621 < len(yyv621) {
			yyv621 = yyv621[:yyj621]
			yyc621 = true
		} else if yyj621 == 0 && yyv621 == nil {
			yyv621 = []Binding{}
			yyc621 = true
		}
	}
	yyh621.End()
	if yyc621 {
		*v = yyv621
	}
}

func (x codecSelfer1234) encSliceBindingCondition(v []BindingCondition, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv625 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy626 := &yyv625
		yy626.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceBindingCondition(v *[]BindingCondition, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv627 := *v
	yyh627, yyl627 := z.DecSliceHelperStart()
	var yyc627 bool
	if yyl627 == 0 {
		if yyv627 == nil {
			yyv627 = []BindingCondition{}
			yyc627 = true
		} else if len(yyv627) != 0 {
			yyv627 = yyv627[:0]
			yyc627 = true
		}
	} else if yyl627 > 0 {
		var yyrr627, yyrl627 int
		var yyrt627 bool
		if yyl627 > cap(yyv627) {

			yyrg627 := len(yyv627) > 0
			yyv2627 := yyv627
			yyrl627, yyrt627 = z.DecInferLen(yyl627, z.DecBasicHandle().MaxInitLen, 64)
			if yyrt627 {
				if yyrl627 <= cap(yyv627) {
					yyv627 = yyv627[:yyrl627]
				} else {
					yyv627 = make([]BindingCondition, yyrl627)
				}
			} else {
				yyv627 = make([]BindingCondition, yyrl627)
			}
			yyc627 = true
			yyrr627 = len(yyv627)
			if yyrg627 {
				copy(yyv627, yyv2627)
			}
		} else if yyl627 != len(yyv627) {
			yyv627 = yyv627[:yyl627]
			yyc627 = true
		}
		yyj627 := 0
		for ; yyj627 < yyrr627; yyj627++ {
			yyh627.ElemContainerState(yyj627)
			if r.TryDecodeAsNil() {
				yyv627[yyj627] = BindingCondition{}
			} else {
				yyv628 := &yyv627[yyj627]
				yyv628.CodecDecodeSelf(d)
			}

		}
		if yyrt627 {
			for ; yyj627 < yyl627; yyj627++ {
				yyv627 = append(yyv627, BindingCondition{})
				yyh627.ElemContainerState(yyj627)
				if r.TryDecodeAsNil() {
					yyv627[yyj627] = BindingCondition{}
				} else {
					yyv629 := &yyv627[yyj627]
					yyv629.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj627 := 0
		for ; !r.CheckBreak(); yyj627++ {

			if yyj627 >= len(yyv627) {
				yyv627 = append(yyv627, BindingCondition{}) // var yyz627 BindingCondition
				yyc627 = true
			}
			yyh627.ElemContainerState(yyj627)
			if yyj627 < len(yyv627) {
				if r.TryDecodeAsNil() {
					yyv627[yyj627] = BindingCondition{}
				} else {
					yyv630 := &yyv627[yyj627]
					yyv630.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj627 < len(yyv627) {
			yyv627 = yyv627[:yyj627]
			yyc627 = true
		} else if yyj627 == 0 && yyv627 == nil {
			yyv627 = []BindingCondition{}
			yyc627 = true
		}
	}
	yyh627.End()
	if yyc627 {
		*v = yyv627
	}
}