cost-model/core/pkg/model/kubemodel/kubemodel_codecs.go

////////////////////////////////////////////////////////////////////////////////
//
//                             DO NOT MODIFY
//
//                          ┻━┻ ︵ヽ(`Д´)ﾉ︵ ┻━┻
//
//
//            This source file was automatically generated by bingen.
//
////////////////////////////////////////////////////////////////////////////////

package kubemodel

import (
	"cmp"
	"fmt"
	"io"
	"iter"
	"os"
	"reflect"
	"slices"
	"strings"
	"sync"
	"time"
	"unsafe"

	"github.com/opencost/opencost/core/pkg/model/shared"

	"github.com/opencost/opencost/core/pkg/util"
)

const (
	// GeneratorPackageName is the package the generator is targetting
	GeneratorPackageName string = "kubemodel"
	StringHeaderSize            = int64(unsafe.Sizeof(""))

	// BinaryTagStringTable is written and/or read prior to the existence of a string
	// table (where each index is encoded as a string entry in the resource
	BinaryTagStringTable string = "BGST"

	// DefaultCodecVersion is used for any resources listed in the Default version set
	DefaultCodecVersion uint8 = 2
)

//--------------------------------------------------------------------------
//  Configuration
//--------------------------------------------------------------------------

var (
	bingenConfigLock sync.RWMutex
	bingenConfig     *BingenConfiguration = DefaultBingenConfiguration()
)

// BingenConfiguration is used to set any custom configuration in the way files are encoded
// or decoded.
type BingenConfiguration struct {
	// FileBackedStringTableEnabled enables the use of file-backed string tables for streaming
	// bingen decoding.
	FileBackedStringTableEnabled bool

	// FileBackedStringTableDir is the directory to write the string table files for reading.
	FileBackedStringTableDir string

	// FileBackedStringTableMemoMaxBytes limits in-memory memoization for file-backed table lookups.
	// 0 disables memoization.
	FileBackedStringTableMemoMaxBytes int64
}

// DefaultBingenConfiguration creates the default implementation of the bingen configuration
// and returns it.
func DefaultBingenConfiguration() *BingenConfiguration {
	return &BingenConfiguration{
		FileBackedStringTableEnabled:      false,
		FileBackedStringTableDir:          os.TempDir(),
		FileBackedStringTableMemoMaxBytes: 0,
	}
}

// ConfigureBingen accepts a new *BingenConfiguration instance which updates the internal decoder
// and encoder behavior.
func ConfigureBingen(config *BingenConfiguration) {
	bingenConfigLock.Lock()
	defer bingenConfigLock.Unlock()

	if config == nil {
		config = DefaultBingenConfiguration()
	}
	bingenConfig = config
}

// IsBingenFileBackedStringTableEnabled accessor for file backed string table configuration
func IsBingenFileBackedStringTableEnabled() bool {
	bingenConfigLock.RLock()
	defer bingenConfigLock.RUnlock()

	return bingenConfig.FileBackedStringTableEnabled
}

// BingenFileBackedStringTableDir returns the directory configured for file backed string tables.
func BingenFileBackedStringTableDir() string {
	bingenConfigLock.RLock()
	defer bingenConfigLock.RUnlock()

	return bingenConfig.FileBackedStringTableDir
}

// BingenFileBackedStringTableMemoMaxBytes returns the maximum bytes used for file-backed memo cache.
func BingenFileBackedStringTableMemoMaxBytes() int64 {
	bingenConfigLock.RLock()
	defer bingenConfigLock.RUnlock()

	return bingenConfig.FileBackedStringTableMemoMaxBytes
}

//--------------------------------------------------------------------------
//  Type Map
//--------------------------------------------------------------------------

// Generated type map for resolving interface implementations to to concrete types
var typeMap map[string]reflect.Type = map[string]reflect.Type{
	"Cluster":                 reflect.TypeFor[Cluster](),
	"Container":               reflect.TypeFor[Container](),
	"CronJob":                 reflect.TypeFor[CronJob](),
	"DCGMContainer":           reflect.TypeFor[DCGMContainer](),
	"DCGMDevice":              reflect.TypeFor[DCGMDevice](),
	"DCGMPod":                 reflect.TypeFor[DCGMPod](),
	"DaemonSet":               reflect.TypeFor[DaemonSet](),
	"Deployment":              reflect.TypeFor[Deployment](),
	"Diagnostic":              reflect.TypeFor[Diagnostic](),
	"FileSystem":              reflect.TypeFor[FileSystem](),
	"Job":                     reflect.TypeFor[Job](),
	"KubeModelSet":            reflect.TypeFor[KubeModelSet](),
	"Metadata":                reflect.TypeFor[Metadata](),
	"Namespace":               reflect.TypeFor[Namespace](),
	"NetworkTrafficDetail":    reflect.TypeFor[NetworkTrafficDetail](),
	"Node":                    reflect.TypeFor[Node](),
	"Owner":                   reflect.TypeFor[Owner](),
	"PersistentVolume":        reflect.TypeFor[PersistentVolume](),
	"PersistentVolumeClaim":   reflect.TypeFor[PersistentVolumeClaim](),
	"Pod":                     reflect.TypeFor[Pod](),
	"PodPVCVolume":            reflect.TypeFor[PodPVCVolume](),
	"ReplicaSet":              reflect.TypeFor[ReplicaSet](),
	"ResourceQuantity":        reflect.TypeFor[ResourceQuantity](),
	"ResourceQuota":           reflect.TypeFor[ResourceQuota](),
	"ResourceQuotaSpec":       reflect.TypeFor[ResourceQuotaSpec](),
	"ResourceQuotaSpecHard":   reflect.TypeFor[ResourceQuotaSpecHard](),
	"ResourceQuotaStatus":     reflect.TypeFor[ResourceQuotaStatus](),
	"ResourceQuotaStatusUsed": reflect.TypeFor[ResourceQuotaStatusUsed](),
	"Service":                 reflect.TypeFor[Service](),
	"StatefulSet":             reflect.TypeFor[StatefulSet](),
	"Window":                  reflect.TypeFor[Window](),
}

//--------------------------------------------------------------------------
//  Type Helpers
//--------------------------------------------------------------------------

// isBinaryTag returns true when the first bytes in the provided binary matches the tag
func isBinaryTag(data []byte, tag string) bool {
	if len(data) < len(tag) {
		return false
	}

	return string(data[:len(tag)]) == tag
}

// isReaderBinaryTag is used to peek the header for an io.Reader Buffer
func isReaderBinaryTag(buff *util.Buffer, tag string) bool {
	data, err := buff.Peek(len(tag))
	if err != nil && err != io.EOF {
		panic(fmt.Sprintf("called Peek() on a non buffered reader: %s", err))
	}
	if len(data) < len(tag) {
		return false
	}

	return string(data[:len(tag)]) == tag
}

// typeToString determines the basic properties of the type, the qualifier, package path, and
// type name, and returns the qualified type
func typeToString(f interface{}) string {
	qual := ""
	t := reflect.TypeOf(f)
	if t.Kind() == reflect.Ptr {
		t = t.Elem()
		qual = "*"
	}

	return fmt.Sprintf("%s%s.%s", qual, t.PkgPath(), t.Name())
}

// resolveType uses the name of a type and returns the package, base type name, and whether
// or not it's a pointer.
func resolveType(t string) (pkg string, name string, isPtr bool) {
	isPtr = t[:1] == "*"
	if isPtr {
		t = t[1:]
	}

	slashIndex := strings.LastIndex(t, "/")
	if slashIndex >= 0 {
		t = t[slashIndex+1:]
	}
	parts := strings.Split(t, ".")
	if parts[0] == GeneratorPackageName {
		parts[0] = ""
	}

	pkg = parts[0]
	name = parts[1]
	return
}

//--------------------------------------------------------------------------
//  Stream Helpers
//--------------------------------------------------------------------------

// StreamFactoryFunc is an alias for a func that creates a BingenStream implementation.
type StreamFactoryFunc func(io.Reader) BingenStream

// Generated streamable factory map for finding the specific new stream methods
// by T type
var streamFactoryMap map[reflect.Type]StreamFactoryFunc = map[reflect.Type]StreamFactoryFunc{
	reflect.TypeFor[KubeModelSet](): NewKubeModelSetStream,
}

// NewStreamFor accepts an io.Reader, and returns a new BingenStream for the generic T
// type provided _if_ it is a registered bingen type that is annotated as 'streamable'. See
// the streamFactoryMap for generated type listings.
func NewStreamFor[T any](reader io.Reader) (BingenStream, error) {
	typeKey := reflect.TypeFor[T]()

	factory, ok := streamFactoryMap[typeKey]
	if !ok {
		return nil, fmt.Errorf("the type: %s is not a registered bingen streamable type", typeKey.Name())
	}

	return factory(reader), nil
}

// BingenStream is the stream interface for all streamable types
type BingenStream interface {
	// Stream returns the iterator which will stream each field of the target type and
	// return the field info as well as the value.
	Stream() iter.Seq2[BingenFieldInfo, *BingenValue]

	// Close will close any dynamic io.Reader used to stream in the fields
	Close()

	// Error returns an error if one occurred during the process of streaming the type's fields.
	// This can be checked after iterating through the Stream().
	Error() error
}

// BingenValue contains the value of a field as well as any index/key associated with that value.
type BingenValue struct {
	Value any
	Index any
}

// IsNil is just a method accessor way to check to see if the value returned was nil
func (bv *BingenValue) IsNil() bool {
	return bv == nil
}

// creates a single BingenValue instance without a key or index
func singleV(value any) *BingenValue {
	return &BingenValue{
		Value: value,
	}
}

// creates a pair of key/index and value.
func pairV(index any, value any) *BingenValue {
	return &BingenValue{
		Value: value,
		Index: index,
	}
}

// BingenFieldInfo contains the type of the field being streamed as well as the name of the field.
type BingenFieldInfo struct {
	Type reflect.Type
	Name string
}

//--------------------------------------------------------------------------
//  String Table Writer
//--------------------------------------------------------------------------

// StringTableWriter is the interface used to write the string table for encoding.
type StringTableWriter interface {
	// AddOrGet adds a string to the string table and returns the new index or
	// an existing index.
	AddOrGet(s string) int

	// WriteTo will write the StringTable data (with the header) to the provided
	// Buffer starting a the current write position
	WriteTo(b *util.Buffer)
}

// IndexedStringTableWriter maps strings to specific indices for encoding
type IndexedStringTableWriter struct {
	indices map[string]int
	next    int
}

// NewIndexedStringTableWriter Creates a new IndexedStringTableWriter instance.
func NewIndexedStringTableWriter() *IndexedStringTableWriter {
	return &IndexedStringTableWriter{
		indices: make(map[string]int),
		next:    0,
	}
}

// AddOrGet retrieves a string entry's index if it exists. Otherwise, it adds the entry and returns the new index.
func (st *IndexedStringTableWriter) AddOrGet(s string) int {
	if ind, ok := st.indices[s]; ok {
		return ind
	}

	current := st.next
	st.next++

	st.indices[s] = current
	return current
}

// ToSlice Converts the contents to a string array for encoding.
func (st *IndexedStringTableWriter) ToSlice() []string {
	if st.next == 0 {
		return []string{}
	}

	sl := make([]string, st.next)
	for s, i := range st.indices {
		sl[i] = s
	}
	return sl
}

// ToBytes Converts the contents to a binary encoded representation
func (st *IndexedStringTableWriter) ToBytes() []byte {
	buff := util.NewBuffer()
	st.WriteTo(buff)
	return buff.Bytes()
}

// WriteTo will write the StringTable data (with the header) to the provided
// Buffer starting a the current write position
func (st *IndexedStringTableWriter) WriteTo(buff *util.Buffer) {
	// bingen string table header
	buff.WriteBytes([]byte(BinaryTagStringTable))

	// get an ordered string slice to encode
	strs := st.ToSlice()

	buff.WriteInt(len(strs)) // table length
	for _, s := range strs {
		buff.WriteString(s)
	}
}

type indexed struct {
	s     string
	count uint64
	index int
}

func newIndexed(s string, index int) *indexed {
	return &indexed{
		s:     s,
		count: 1,
		index: index,
	}
}

// PrepassStringTableWriter maps strings to specific indices for encoding, sorted by the total
// number of times they're accessed
type PrepassStringTableWriter struct {
	prepass map[string]*indexed
	next    int
}

// NewPrepassStringTableWriter creates a new PrepassStringTableWriter instance.
func NewPrepassStringTableWriter() *PrepassStringTableWriter {
	return &PrepassStringTableWriter{
		prepass: make(map[string]*indexed),
	}
}

// AddOrGet retrieves a string entry's index if it exists. Otherwise, it adds the entry and returns the new index.
func (st *PrepassStringTableWriter) AddOrGet(s string) int {
	if ind, ok := st.prepass[s]; ok {
		ind.count += 1
		return ind.index
	}

	current := st.next
	st.next++

	st.prepass[s] = newIndexed(s, current)
	return current
}

// WriteSortedTo sorts the string table by the number of accesses, writes the table in that
// order, then returns a new StringTableWriter implementation that can be used for the new
// sorted order index lookups.
func (st *PrepassStringTableWriter) WriteSortedTo(buff *util.Buffer) StringTableWriter {
	sl := make([]*indexed, st.next)
	for _, ind := range st.prepass {
		sl[ind.index] = ind
	}

	slices.SortFunc(sl, func(a *indexed, b *indexed) int {
		return -cmp.Compare(a.count, b.count)
	})

	sti := NewIndexedStringTableWriter()
	for _, ind := range sl {
		sti.AddOrGet(ind.s)
	}

	sti.WriteTo(buff)
	return sti
}

// WriteTo will write the StringTable data (with the header) to the provided
// Buffer starting a the current write position
func (st *PrepassStringTableWriter) WriteTo(buff *util.Buffer) {
	panic("Prepass StringTableWriter cannot write directly")
}

//--------------------------------------------------------------------------
//  String Table Reader
//--------------------------------------------------------------------------

// StringTableReader is the interface used to read the string table from the decoding.
type StringTableReader interface {
	// At returns the string entry at a specific index, or panics on out of bounds.
	At(index int) string

	// Len returns the total number of strings loaded in the string table.
	Len() int

	// Close will clear the loaded table, and drop any external resources used.
	Close() error
}

// SliceStringTableReader is a basic pre-loaded []string that provides index-based access.
// The cost of this implementation is holding all strings in memory, which provides faster
// lookup performance at the expense of memory usage.
type SliceStringTableReader struct {
	table []string
}

// NewSliceStringTableReaderFrom creates a new SliceStringTableReader instance loading
// data directly from the buffer. The buffer's position should start at the table length.
func NewSliceStringTableReaderFrom(buffer *util.Buffer) StringTableReader {
	// table length
	tl := buffer.ReadInt()

	var table []string
	if tl > 0 {
		table = make([]string, tl)
		for i := range tl {
			table[i] = buffer.ReadString()
		}
	}

	return &SliceStringTableReader{
		table: table,
	}
}

// At returns the string entry at a specific index, or panics on out of bounds.
func (sstr *SliceStringTableReader) At(index int) string {
	if index < 0 || index >= len(sstr.table) {
		panic(fmt.Errorf("%s: string table index out of bounds: %d", GeneratorPackageName, index))
	}

	return sstr.table[index]
}

// Len returns the total number of strings loaded in the string table.
func (sstr *SliceStringTableReader) Len() int {
	if sstr == nil {
		return 0
	}

	return len(sstr.table)
}

// Close for the slice tables just nils out the slice and returns
func (sstr *SliceStringTableReader) Close() error {
	sstr.table = nil
	return nil
}

// fileStringRef maps a bingen string-table index to a payload stored in a temp file.
type fileStringRef struct {
	off    int64
	length int
}

// FileStringTableReader leverages a local file to write string table data for lookup. On
// memory focused systems, this allows a slower parse with a significant decrease in memory
// usage. This implementation is often pair with streaming readers for high throughput with
// reduced memory usage.
type FileStringTableReader struct {
	f    *os.File
	refs []fileStringRef
	memo []string
}

// NewFileStringTableFromBuffer reads exactly tl length-prefixed (uint16) string payloads from buffer
// and appends each payload to a new temp file. It does not retain full strings in memory.
func NewFileStringTableReaderFrom(buffer *util.Buffer, dir string, memoMaxBytes int64) StringTableReader {
	// helper func to cast a string in-place to a byte slice.
	// NOTE: Return value is READ-ONLY. DO NOT MODIFY!
	byteSliceFor := func(s string) []byte {
		return unsafe.Slice(unsafe.StringData(s), len(s))
	}

	err := os.MkdirAll(dir, 0755)
	if err != nil {
		panic(fmt.Errorf("%s: failed to create string table directory: %w", GeneratorPackageName, err))
	}

	f, err := os.CreateTemp(dir, fmt.Sprintf("%s-bgst-*", GeneratorPackageName))
	if err != nil {
		panic(fmt.Errorf("%s: failed to create string table file: %w", GeneratorPackageName, err))
	}

	var writeErr error
	defer func() {
		if writeErr != nil {
			_ = f.Close()
		}
	}()

	// table length
	tl := buffer.ReadInt()

	var refs []fileStringRef
	if tl > 0 {
		refs = make([]fileStringRef, tl)

		for i := range tl {
			payload := byteSliceFor(buffer.ReadString())

			var off int64
			if len(payload) > 0 {
				off, err = f.Seek(0, io.SeekEnd)
				if err != nil {
					writeErr = fmt.Errorf("%s: failed to seek string table file: %w", GeneratorPackageName, err)
					panic(writeErr)
				}
				if _, err := f.Write(payload); err != nil {
					writeErr = fmt.Errorf("%s: failed to write string table entry %d: %w", GeneratorPackageName, i, err)
					panic(writeErr)
				}
			}

			refs[i] = fileStringRef{
				off:    off,
				length: len(payload),
			}
		}
	}

	var memo []string

	// Pre-load cache with strings up to memoMaxBytes, respecting string boundaries
	if memoMaxBytes > 0 && len(refs) > 0 {
		memo = make([]string, len(refs))
		var cumulativeSize int64
		for i, ref := range refs {
			// Check if adding this string would exceed the limit
			if cumulativeSize+int64(ref.length)+StringHeaderSize > memoMaxBytes {
				// Would exceed limit, stop here
				break
			}

			// Read string from file and cache it
			if ref.length > 0 {
				b := make([]byte, ref.length)
				_, err := f.ReadAt(b, ref.off)
				if err != nil {
					// If we can't read, skip this entry but continue
					continue
				}

				// Cast the allocated bytes to a string in-place
				str := unsafe.String(unsafe.SliceData(b), len(b))
				memo[i] = str
				cumulativeSize += int64(ref.length) + StringHeaderSize
			}
		}
	}

	return &FileStringTableReader{
		f:    f,
		refs: refs,
		memo: memo,
	}
}

// At returns the string from the internal file using the reference's offset and length.
func (fstr *FileStringTableReader) At(index int) string {
	if fstr == nil || fstr.f == nil {
		panic(fmt.Errorf("%s: failed to read file string table data", GeneratorPackageName))
	}
	if index < 0 || index >= len(fstr.refs) {
		panic(fmt.Errorf("%s: string table index out of bounds: %d", GeneratorPackageName, index))
	}

	ref := fstr.refs[index]
	if ref.length == 0 {
		return ""
	}

	// Check cache first
	if fstr.memo != nil && len(fstr.memo) > index && fstr.memo[index] != "" {
		return fstr.memo[index]
	}

	// Cache miss - read from file
	b := make([]byte, ref.length)
	_, err := fstr.f.ReadAt(b, ref.off)
	if err != nil {
		return ""
	}

	// Cast the allocated bytes to a string in-place, as we were the ones that allocated the bytes
	return unsafe.String(unsafe.SliceData(b), len(b))
}

// Len returns the total number of strings loaded in the string table.
func (fstr *FileStringTableReader) Len() int {
	if fstr == nil {
		return 0
	}

	return len(fstr.refs)
}

// Close for the file string table reader closes the file and deletes it.
func (fstr *FileStringTableReader) Close() error {
	if fstr == nil || fstr.f == nil {
		return nil
	}

	path := fstr.f.Name()
	err := fstr.f.Close()
	fstr.f = nil
	fstr.refs = nil
	fstr.memo = nil

	if path != "" {
		_ = os.Remove(path)
	}

	return err
}

//--------------------------------------------------------------------------
//  Codec Context
//--------------------------------------------------------------------------

// EncodingContext is a context object passed to the encoders to ensure reuse of buffer
// and table data
type EncodingContext struct {
	Buffer *util.Buffer
	Table  StringTableWriter
}

// NewEncodingContext creates a new EncodingContext instance that will create a new []byte buffer
// for writing, and return the context
func NewEncodingContext(tableWriter StringTableWriter) *EncodingContext {
	return &EncodingContext{
		Buffer: util.NewBuffer(),
		Table:  tableWriter,
	}
}

// NewEncodingContextFromWriter creates a new EncodingContext instance that will create a new Buffer
// from the provided io.Writer and StringTableWriter.
func NewEncodingContextFromWriter(writer io.Writer, tableWriter StringTableWriter) *EncodingContext {
	return &EncodingContext{
		Buffer: util.NewBufferFromWriter(writer),
		Table:  tableWriter,
	}
}

// NewEncodingContextFromBuffer creates a new EncodingContext instance that will leverage an existing
// Buffer and StringTableWriter.
func NewEncodingContextFromBuffer(buffer *util.Buffer, tableWriter StringTableWriter) *EncodingContext {
	return &EncodingContext{
		Buffer: buffer,
		Table:  tableWriter,
	}
}

// ToBytes returns the encoded string table bytes (if applicable) combined with the encoded buffer bytes. If
// a string table is being used, the string table bytes will be written first to ensure correct ordering for
// decoding.
func (ec *EncodingContext) ToBytes() []byte {
	encBytes := ec.Buffer.Bytes()
	if ec.Table != nil {
		buff := util.NewBuffer()
		ec.Table.WriteTo(buff)
		buff.WriteBytes(encBytes)
		return buff.Bytes()
	}

	return encBytes
}

// IsStringTable returns true if the table is available
func (ec *EncodingContext) IsStringTable() bool {
	return ec.Table != nil
}

// DecodingContext is a context object passed to the decoders to ensure parent objects
// reuse as much data as possible
type DecodingContext struct {
	Buffer *util.Buffer
	Table  StringTableReader
}

// NewDecodingContextFromBytes creates a new DecodingContext instance using an byte slice
func NewDecodingContextFromBytes(data []byte) *DecodingContext {
	var table StringTableReader

	buff := util.NewBufferFromBytes(data)

	// string table header validation
	if isBinaryTag(data, BinaryTagStringTable) {
		buff.ReadBytes(len(BinaryTagStringTable)) // strip tag length

		// always use a slice string table with a byte array since the
		// data is already in memory
		table = NewSliceStringTableReaderFrom(buff)
	}

	return &DecodingContext{
		Buffer: buff,
		Table:  table,
	}
}

// NewDecodingContextFromReader creates a new DecodingContext instance using an io.Reader
// implementation
func NewDecodingContextFromReader(reader io.Reader) *DecodingContext {
	var table StringTableReader

	buff := util.NewBufferFromReader(reader)

	if isReaderBinaryTag(buff, BinaryTagStringTable) {
		buff.ReadBytes(len(BinaryTagStringTable)) // strip tag length

		// create correct string table implementation
		if IsBingenFileBackedStringTableEnabled() {
			table = NewFileStringTableReaderFrom(buff, BingenFileBackedStringTableDir(), BingenFileBackedStringTableMemoMaxBytes())
		} else {
			table = NewSliceStringTableReaderFrom(buff)
		}
	}

	return &DecodingContext{
		Buffer: buff,
		Table:  table,
	}
}

// IsStringTable returns true if the table is available
func (dc *DecodingContext) IsStringTable() bool {
	return dc.Table != nil && dc.Table.Len() > 0
}

// Close will ensure that any string table resources and buffer resources are
// cleaned up.
func (dc *DecodingContext) Close() {
	if dc.Table != nil {
		_ = dc.Table.Close()
		dc.Table = nil
	}
}

//--------------------------------------------------------------------------
//  Binary Codec
//--------------------------------------------------------------------------

// BinEncoder is an encoding interface which defines a context based marshal contract.
type BinEncoder interface {
	MarshalBinaryWithContext(*EncodingContext) error
}

// BinDecoder is a decoding interface which defines a context based unmarshal contract.
type BinDecoder interface {
	UnmarshalBinaryWithContext(*DecodingContext) error
}

//--------------------------------------------------------------------------
//  Cluster
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this Cluster instance
// into a byte array
func (target *Cluster) MarshalBinary() (data []byte, err error) {
	ctx := NewEncodingContext(nil)

	e := target.MarshalBinaryWithContext(ctx)
	if e != nil {
		return nil, e
	}

	return ctx.ToBytes(), nil
}

// MarshalBinary serializes the internal properties of this Cluster instance
// into an io.Writer.
func (target *Cluster) MarshalBinaryTo(writer io.Writer) error {
	buff := util.NewBufferFromWriter(writer)
	defer buff.Flush()

	ctx := NewEncodingContextFromBuffer(buff, nil)

	return target.MarshalBinaryWithContext(ctx)
}

// MarshalBinaryWithContext serializes the internal properties of this Cluster instance
// into a byte array leveraging a predefined context.
func (target *Cluster) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	buff.WriteUInt8(DefaultCodecVersion) // version

	if ctx.IsStringTable() {
		a := ctx.Table.AddOrGet(target.UID)
		buff.WriteInt(a) // write table index
	} else {
		buff.WriteString(target.UID) // write string
	}

	// --- [begin][write][alias](shared.Provider) ---

	if ctx.IsStringTable() {
		b := ctx.Table.AddOrGet(string(target.Provider))
		buff.WriteInt(b) // write table index
	} else {
		buff.WriteString(string(target.Provider)) // write string
	}

	// --- [end][write][alias](shared.Provider) ---

	if ctx.IsStringTable() {
		c := ctx.Table.AddOrGet(target.Account)
		buff.WriteInt(c) // write table index
	} else {
		buff.WriteString(target.Account) // write string
	}

	if ctx.IsStringTable() {
		d := ctx.Table.AddOrGet(target.Name)
		buff.WriteInt(d) // write table index
	} else {
		buff.WriteString(target.Name) // write string
	}

	if ctx.IsStringTable() {
		e := ctx.Table.AddOrGet(target.Region)
		buff.WriteInt(e) // write table index
	} else {
		buff.WriteString(target.Region) // write string
	}

	// --- [begin][write][reference](time.Time) ---
	f, errA := target.Start.MarshalBinary()
	if errA != nil {
		return errA
	}
	buff.WriteInt(len(f))
	buff.WriteBytes(f)
	// --- [end][write][reference](time.Time) ---

	// --- [begin][write][reference](time.Time) ---
	g, errB := target.End.MarshalBinary()
	if errB != nil {
		return errB
	}
	buff.WriteInt(len(g))
	buff.WriteBytes(g)
	// --- [end][write][reference](time.Time) ---

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the Cluster type
func (target *Cluster) UnmarshalBinary(data []byte) error {
	ctx := NewDecodingContextFromBytes(data)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryFromReader uses the io.Reader data to set all the internal properties of
// the Cluster type
func (target *Cluster) UnmarshalBinaryFromReader(reader io.Reader) error {
	ctx := NewDecodingContextFromReader(reader)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
// the Cluster type
func (target *Cluster) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	version := buff.ReadUInt8()

	if version > DefaultCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling Cluster. Expected %d or less, got %d", DefaultCodecVersion, version)
	}

	// field version check
	if uint8(1) <= version {

		var b string
		if ctx.IsStringTable() {
			c := buff.ReadInt() // read string index
			b = ctx.Table.At(c)
		} else {
			b = buff.ReadString() // read string
		}
		a := b
		target.UID = a

	} else {
		target.UID = "" // default
	}
	// field version check
	if uint8(1) <= version {
		// --- [begin][read][alias](shared.Provider) ---
		var d string
		var f string
		if ctx.IsStringTable() {
			g := buff.ReadInt() // read string index
			f = ctx.Table.At(g)
		} else {
			f = buff.ReadString() // read string
		}
		e := f
		d = e

		target.Provider = shared.Provider(d)
		// --- [end][read][alias](shared.Provider) ---

	} else {
	}
	// field version check
	if uint8(1) <= version {

		var l string
		if ctx.IsStringTable() {
			m := buff.ReadInt() // read string index
			l = ctx.Table.At(m)
		} else {
			l = buff.ReadString() // read string
		}
		h := l
		target.Account = h

	} else {
		target.Account = "" // default
	}
	// field version check
	if uint8(1) <= version {

		var o string
		if ctx.IsStringTable() {
			p := buff.ReadInt() // read string index
			o = ctx.Table.At(p)
		} else {
			o = buff.ReadString() // read string
		}
		n := o
		target.Name = n

	} else {
		target.Name = "" // default
	}
	// field version check
	if uint8(2) <= version {

		var r string
		if ctx.IsStringTable() {
			s := buff.ReadInt() // read string index
			r = ctx.Table.At(s)
		} else {
			r = buff.ReadString() // read string
		}
		q := r
		target.Region = q

	} else {
		target.Region = "" // default
	}
	// field version check
	if uint8(1) <= version {

		// --- [begin][read][reference](time.Time) ---
		t := new(time.Time)
		u := buff.ReadInt() // byte array length
		w := buff.ReadBytes(u)
		errA := t.UnmarshalBinary(w)
		if errA != nil {
			return errA
		}
		target.Start = *t
		// --- [end][read][reference](time.Time) ---

	} else {
	}
	// field version check
	if uint8(1) <= version {

		// --- [begin][read][reference](time.Time) ---
		x := new(time.Time)
		y := buff.ReadInt() // byte array length
		aa := buff.ReadBytes(y)
		errB := x.UnmarshalBinary(aa)
		if errB != nil {
			return errB
		}
		target.End = *x
		// --- [end][read][reference](time.Time) ---

	} else {
	}

	return nil
}

//--------------------------------------------------------------------------
//  Container
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this Container instance
// into a byte array
func (target *Container) MarshalBinary() (data []byte, err error) {
	ctx := NewEncodingContext(nil)

	e := target.MarshalBinaryWithContext(ctx)
	if e != nil {
		return nil, e
	}

	return ctx.ToBytes(), nil
}

// MarshalBinary serializes the internal properties of this Container instance
// into an io.Writer.
func (target *Container) MarshalBinaryTo(writer io.Writer) error {
	buff := util.NewBufferFromWriter(writer)
	defer buff.Flush()

	ctx := NewEncodingContextFromBuffer(buff, nil)

	return target.MarshalBinaryWithContext(ctx)
}

// MarshalBinaryWithContext serializes the internal properties of this Container instance
// into a byte array leveraging a predefined context.
func (target *Container) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	buff.WriteUInt8(DefaultCodecVersion) // version

	if ctx.IsStringTable() {
		a := ctx.Table.AddOrGet(target.PodUID)
		buff.WriteInt(a) // write table index
	} else {
		buff.WriteString(target.PodUID) // write string
	}

	if ctx.IsStringTable() {
		b := ctx.Table.AddOrGet(target.Name)
		buff.WriteInt(b) // write table index
	} else {
		buff.WriteString(target.Name) // write string
	}

	// --- [begin][write][alias](ResourceQuantities) ---
	if map[Resource]ResourceQuantity(target.ResourceRequests) == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[Resource]ResourceQuantity) ---
		buff.WriteInt(len(map[Resource]ResourceQuantity(target.ResourceRequests))) // map length
		for v, z := range map[Resource]ResourceQuantity(target.ResourceRequests) {
			// --- [begin][write][alias](Resource) ---

			if ctx.IsStringTable() {
				c := ctx.Table.AddOrGet(string(v))
				buff.WriteInt(c) // write table index
			} else {
				buff.WriteString(string(v)) // write string
			}

			// --- [end][write][alias](Resource) ---
			// --- [begin][write][struct](ResourceQuantity) ---
			buff.WriteInt(0) // [compatibility, unused]
			errA := z.MarshalBinaryWithContext(ctx)
			if errA != nil {
				return errA
			}
			// --- [end][write][struct](ResourceQuantity) ---

		}
		// --- [end][write][map](map[Resource]ResourceQuantity) ---

	}
	// --- [end][write][alias](ResourceQuantities) ---

	// --- [begin][write][alias](ResourceQuantities) ---
	if map[Resource]ResourceQuantity(target.ResourceLimits) == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[Resource]ResourceQuantity) ---
		buff.WriteInt(len(map[Resource]ResourceQuantity(target.ResourceLimits))) // map length
		for vv, zz := range map[Resource]ResourceQuantity(target.ResourceLimits) {
			// --- [begin][write][alias](Resource) ---

			if ctx.IsStringTable() {
				d := ctx.Table.AddOrGet(string(vv))
				buff.WriteInt(d) // write table index
			} else {
				buff.WriteString(string(vv)) // write string
			}

			// --- [end][write][alias](Resource) ---
			// --- [begin][write][struct](ResourceQuantity) ---
			buff.WriteInt(0) // [compatibility, unused]
			errB := zz.MarshalBinaryWithContext(ctx)
			if errB != nil {
				return errB
			}
			// --- [end][write][struct](ResourceQuantity) ---

		}
		// --- [end][write][map](map[Resource]ResourceQuantity) ---

	}
	// --- [end][write][alias](ResourceQuantities) ---

	buff.WriteFloat64(target.CPUCoresAllocated) // write float64

	buff.WriteFloat64(target.CPUCoreUsageAvg) // write float64

	buff.WriteFloat64(target.CPUCoreUsageMax) // write float64

	buff.WriteFloat64(target.RAMBytesAllocated) // write float64

	buff.WriteFloat64(target.RAMBytesUsageAvg) // write float64

	buff.WriteFloat64(target.RAMBytesUsageMax) // write float64

	// --- [begin][write][reference](time.Time) ---
	e, errC := target.Start.MarshalBinary()
	if errC != nil {
		return errC
	}
	buff.WriteInt(len(e))
	buff.WriteBytes(e)
	// --- [end][write][reference](time.Time) ---

	// --- [begin][write][reference](time.Time) ---
	f, errD := target.End.MarshalBinary()
	if errD != nil {
		return errD
	}
	buff.WriteInt(len(f))
	buff.WriteBytes(f)
	// --- [end][write][reference](time.Time) ---

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the Container type
func (target *Container) UnmarshalBinary(data []byte) error {
	ctx := NewDecodingContextFromBytes(data)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryFromReader uses the io.Reader data to set all the internal properties of
// the Container type
func (target *Container) UnmarshalBinaryFromReader(reader io.Reader) error {
	ctx := NewDecodingContextFromReader(reader)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
// the Container type
func (target *Container) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	version := buff.ReadUInt8()

	if version > DefaultCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling Container. Expected %d or less, got %d", DefaultCodecVersion, version)
	}

	var b string
	if ctx.IsStringTable() {
		c := buff.ReadInt() // read string index
		b = ctx.Table.At(c)
	} else {
		b = buff.ReadString() // read string
	}
	a := b
	target.PodUID = a

	var e string
	if ctx.IsStringTable() {
		f := buff.ReadInt() // read string index
		e = ctx.Table.At(f)
	} else {
		e = buff.ReadString() // read string
	}
	d := e
	target.Name = d

	// --- [begin][read][alias](ResourceQuantities) ---
	var g map[Resource]ResourceQuantity
	if buff.ReadUInt8() == uint8(0) {
		g = nil
	} else {
		// --- [begin][read][map](map[Resource]ResourceQuantity) ---
		l := buff.ReadInt() // map len
		h := make(map[Resource]ResourceQuantity, l)
		for range l {
			// --- [begin][read][alias](Resource) ---
			var m string
			var o string
			if ctx.IsStringTable() {
				p := buff.ReadInt() // read string index
				o = ctx.Table.At(p)
			} else {
				o = buff.ReadString() // read string
			}
			n := o
			m = n

			v := Resource(m)
			// --- [end][read][alias](Resource) ---

			// --- [begin][read][struct](ResourceQuantity) ---
			q := new(ResourceQuantity)
			buff.ReadInt() // [compatibility, unused]
			errA := q.UnmarshalBinaryWithContext(ctx)
			if errA != nil {
				return errA
			}
			z := *q
			// --- [end][read][struct](ResourceQuantity) ---

			h[v] = z
		}
		g = h
		// --- [end][read][map](map[Resource]ResourceQuantity) ---

	}

	target.ResourceRequests = ResourceQuantities(g)
	// --- [end][read][alias](ResourceQuantities) ---

	// --- [begin][read][alias](ResourceQuantities) ---
	var r map[Resource]ResourceQuantity
	if buff.ReadUInt8() == uint8(0) {
		r = nil
	} else {
		// --- [begin][read][map](map[Resource]ResourceQuantity) ---
		t := buff.ReadInt() // map len
		s := make(map[Resource]ResourceQuantity, t)
		for range t {
			// --- [begin][read][alias](Resource) ---
			var u string
			var x string
			if ctx.IsStringTable() {
				y := buff.ReadInt() // read string index
				x = ctx.Table.At(y)
			} else {
				x = buff.ReadString() // read string
			}
			w := x
			u = w

			vv := Resource(u)
			// --- [end][read][alias](Resource) ---

			// --- [begin][read][struct](ResourceQuantity) ---
			aa := new(ResourceQuantity)
			buff.ReadInt() // [compatibility, unused]
			errB := aa.UnmarshalBinaryWithContext(ctx)
			if errB != nil {
				return errB
			}
			zz := *aa
			// --- [end][read][struct](ResourceQuantity) ---

			s[vv] = zz
		}
		r = s
		// --- [end][read][map](map[Resource]ResourceQuantity) ---

	}

	target.ResourceLimits = ResourceQuantities(r)
	// --- [end][read][alias](ResourceQuantities) ---

	bb := buff.ReadFloat64() // read float64
	target.CPUCoresAllocated = bb

	cc := buff.ReadFloat64() // read float64
	target.CPUCoreUsageAvg = cc

	dd := buff.ReadFloat64() // read float64
	target.CPUCoreUsageMax = dd

	ee := buff.ReadFloat64() // read float64
	target.RAMBytesAllocated = ee

	ff := buff.ReadFloat64() // read float64
	target.RAMBytesUsageAvg = ff

	gg := buff.ReadFloat64() // read float64
	target.RAMBytesUsageMax = gg

	// --- [begin][read][reference](time.Time) ---
	hh := new(time.Time)
	ll := buff.ReadInt() // byte array length
	mm := buff.ReadBytes(ll)
	errC := hh.UnmarshalBinary(mm)
	if errC != nil {
		return errC
	}
	target.Start = *hh
	// --- [end][read][reference](time.Time) ---

	// --- [begin][read][reference](time.Time) ---
	nn := new(time.Time)
	oo := buff.ReadInt() // byte array length
	pp := buff.ReadBytes(oo)
	errD := nn.UnmarshalBinary(pp)
	if errD != nil {
		return errD
	}
	target.End = *nn
	// --- [end][read][reference](time.Time) ---

	return nil
}

//--------------------------------------------------------------------------
//  CronJob
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this CronJob instance
// into a byte array
func (target *CronJob) MarshalBinary() (data []byte, err error) {
	ctx := NewEncodingContext(nil)

	e := target.MarshalBinaryWithContext(ctx)
	if e != nil {
		return nil, e
	}

	return ctx.ToBytes(), nil
}

// MarshalBinary serializes the internal properties of this CronJob instance
// into an io.Writer.
func (target *CronJob) MarshalBinaryTo(writer io.Writer) error {
	buff := util.NewBufferFromWriter(writer)
	defer buff.Flush()

	ctx := NewEncodingContextFromBuffer(buff, nil)

	return target.MarshalBinaryWithContext(ctx)
}

// MarshalBinaryWithContext serializes the internal properties of this CronJob instance
// into a byte array leveraging a predefined context.
func (target *CronJob) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	buff.WriteUInt8(DefaultCodecVersion) // version

	if ctx.IsStringTable() {
		a := ctx.Table.AddOrGet(target.UID)
		buff.WriteInt(a) // write table index
	} else {
		buff.WriteString(target.UID) // write string
	}

	if ctx.IsStringTable() {
		b := ctx.Table.AddOrGet(target.NamespaceUID)
		buff.WriteInt(b) // write table index
	} else {
		buff.WriteString(target.NamespaceUID) // write string
	}

	if ctx.IsStringTable() {
		c := ctx.Table.AddOrGet(target.Name)
		buff.WriteInt(c) // write table index
	} else {
		buff.WriteString(target.Name) // write string
	}

	if target.Labels == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]string) ---
		buff.WriteInt(len(target.Labels)) // map length
		for v, z := range target.Labels {
			if ctx.IsStringTable() {
				d := ctx.Table.AddOrGet(v)
				buff.WriteInt(d) // write table index
			} else {
				buff.WriteString(v) // write string
			}

			if ctx.IsStringTable() {
				e := ctx.Table.AddOrGet(z)
				buff.WriteInt(e) // write table index
			} else {
				buff.WriteString(z) // write string
			}

		}
		// --- [end][write][map](map[string]string) ---

	}
	if target.Annotations == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]string) ---
		buff.WriteInt(len(target.Annotations)) // map length
		for vv, zz := range target.Annotations {
			if ctx.IsStringTable() {
				f := ctx.Table.AddOrGet(vv)
				buff.WriteInt(f) // write table index
			} else {
				buff.WriteString(vv) // write string
			}

			if ctx.IsStringTable() {
				g := ctx.Table.AddOrGet(zz)
				buff.WriteInt(g) // write table index
			} else {
				buff.WriteString(zz) // write string
			}

		}
		// --- [end][write][map](map[string]string) ---

	}

	// --- [begin][write][reference](time.Time) ---
	h, errA := target.Start.MarshalBinary()
	if errA != nil {
		return errA
	}
	buff.WriteInt(len(h))
	buff.WriteBytes(h)
	// --- [end][write][reference](time.Time) ---

	// --- [begin][write][reference](time.Time) ---
	l, errB := target.End.MarshalBinary()
	if errB != nil {
		return errB
	}
	buff.WriteInt(len(l))
	buff.WriteBytes(l)
	// --- [end][write][reference](time.Time) ---

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the CronJob type
func (target *CronJob) UnmarshalBinary(data []byte) error {
	ctx := NewDecodingContextFromBytes(data)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryFromReader uses the io.Reader data to set all the internal properties of
// the CronJob type
func (target *CronJob) UnmarshalBinaryFromReader(reader io.Reader) error {
	ctx := NewDecodingContextFromReader(reader)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
// the CronJob type
func (target *CronJob) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	version := buff.ReadUInt8()

	if version > DefaultCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling CronJob. Expected %d or less, got %d", DefaultCodecVersion, version)
	}

	var b string
	if ctx.IsStringTable() {
		c := buff.ReadInt() // read string index
		b = ctx.Table.At(c)
	} else {
		b = buff.ReadString() // read string
	}
	a := b
	target.UID = a

	var e string
	if ctx.IsStringTable() {
		f := buff.ReadInt() // read string index
		e = ctx.Table.At(f)
	} else {
		e = buff.ReadString() // read string
	}
	d := e
	target.NamespaceUID = d

	var h string
	if ctx.IsStringTable() {
		l := buff.ReadInt() // read string index
		h = ctx.Table.At(l)
	} else {
		h = buff.ReadString() // read string
	}
	g := h
	target.Name = g

	if buff.ReadUInt8() == uint8(0) {
		target.Labels = nil
	} else {
		// --- [begin][read][map](map[string]string) ---
		n := buff.ReadInt() // map len
		m := make(map[string]string, n)
		for range n {
			var v string
			var p string
			if ctx.IsStringTable() {
				q := buff.ReadInt() // read string index
				p = ctx.Table.At(q)
			} else {
				p = buff.ReadString() // read string
			}
			o := p
			v = o

			var z string
			var s string
			if ctx.IsStringTable() {
				t := buff.ReadInt() // read string index
				s = ctx.Table.At(t)
			} else {
				s = buff.ReadString() // read string
			}
			r := s
			z = r

			m[v] = z
		}
		target.Labels = m
		// --- [end][read][map](map[string]string) ---

	}

	if buff.ReadUInt8() == uint8(0) {
		target.Annotations = nil
	} else {
		// --- [begin][read][map](map[string]string) ---
		w := buff.ReadInt() // map len
		u := make(map[string]string, w)
		for range w {
			var vv string
			var y string
			if ctx.IsStringTable() {
				aa := buff.ReadInt() // read string index
				y = ctx.Table.At(aa)
			} else {
				y = buff.ReadString() // read string
			}
			x := y
			vv = x

			var zz string
			var cc string
			if ctx.IsStringTable() {
				dd := buff.ReadInt() // read string index
				cc = ctx.Table.At(dd)
			} else {
				cc = buff.ReadString() // read string
			}
			bb := cc
			zz = bb

			u[vv] = zz
		}
		target.Annotations = u
		// --- [end][read][map](map[string]string) ---

	}

	// --- [begin][read][reference](time.Time) ---
	ee := new(time.Time)
	ff := buff.ReadInt() // byte array length
	gg := buff.ReadBytes(ff)
	errA := ee.UnmarshalBinary(gg)
	if errA != nil {
		return errA
	}
	target.Start = *ee
	// --- [end][read][reference](time.Time) ---

	// --- [begin][read][reference](time.Time) ---
	hh := new(time.Time)
	ll := buff.ReadInt() // byte array length
	mm := buff.ReadBytes(ll)
	errB := hh.UnmarshalBinary(mm)
	if errB != nil {
		return errB
	}
	target.End = *hh
	// --- [end][read][reference](time.Time) ---

	return nil
}

//--------------------------------------------------------------------------
//  DCGMContainer
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this DCGMContainer instance
// into a byte array
func (target *DCGMContainer) MarshalBinary() (data []byte, err error) {
	ctx := NewEncodingContext(nil)

	e := target.MarshalBinaryWithContext(ctx)
	if e != nil {
		return nil, e
	}

	return ctx.ToBytes(), nil
}

// MarshalBinary serializes the internal properties of this DCGMContainer instance
// into an io.Writer.
func (target *DCGMContainer) MarshalBinaryTo(writer io.Writer) error {
	buff := util.NewBufferFromWriter(writer)
	defer buff.Flush()

	ctx := NewEncodingContextFromBuffer(buff, nil)

	return target.MarshalBinaryWithContext(ctx)
}

// MarshalBinaryWithContext serializes the internal properties of this DCGMContainer instance
// into a byte array leveraging a predefined context.
func (target *DCGMContainer) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	buff.WriteUInt8(DefaultCodecVersion) // version

	buff.WriteFloat64(target.UsageAvg) // write float64

	buff.WriteFloat64(target.UsageMax) // write float64

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the DCGMContainer type
func (target *DCGMContainer) UnmarshalBinary(data []byte) error {
	ctx := NewDecodingContextFromBytes(data)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryFromReader uses the io.Reader data to set all the internal properties of
// the DCGMContainer type
func (target *DCGMContainer) UnmarshalBinaryFromReader(reader io.Reader) error {
	ctx := NewDecodingContextFromReader(reader)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
// the DCGMContainer type
func (target *DCGMContainer) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	version := buff.ReadUInt8()

	if version > DefaultCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling DCGMContainer. Expected %d or less, got %d", DefaultCodecVersion, version)
	}

	a := buff.ReadFloat64() // read float64
	target.UsageAvg = a

	b := buff.ReadFloat64() // read float64
	target.UsageMax = b

	return nil
}

//--------------------------------------------------------------------------
//  DCGMDevice
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this DCGMDevice instance
// into a byte array
func (target *DCGMDevice) MarshalBinary() (data []byte, err error) {
	ctx := NewEncodingContext(nil)

	e := target.MarshalBinaryWithContext(ctx)
	if e != nil {
		return nil, e
	}

	return ctx.ToBytes(), nil
}

// MarshalBinary serializes the internal properties of this DCGMDevice instance
// into an io.Writer.
func (target *DCGMDevice) MarshalBinaryTo(writer io.Writer) error {
	buff := util.NewBufferFromWriter(writer)
	defer buff.Flush()

	ctx := NewEncodingContextFromBuffer(buff, nil)

	return target.MarshalBinaryWithContext(ctx)
}

// MarshalBinaryWithContext serializes the internal properties of this DCGMDevice instance
// into a byte array leveraging a predefined context.
func (target *DCGMDevice) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	buff.WriteUInt8(DefaultCodecVersion) // version

	if ctx.IsStringTable() {
		a := ctx.Table.AddOrGet(target.UUID)
		buff.WriteInt(a) // write table index
	} else {
		buff.WriteString(target.UUID) // write string
	}

	// --- [begin][write][reference](time.Time) ---
	b, errA := target.Start.MarshalBinary()
	if errA != nil {
		return errA
	}
	buff.WriteInt(len(b))
	buff.WriteBytes(b)
	// --- [end][write][reference](time.Time) ---

	// --- [begin][write][reference](time.Time) ---
	c, errB := target.End.MarshalBinary()
	if errB != nil {
		return errB
	}
	buff.WriteInt(len(c))
	buff.WriteBytes(c)
	// --- [end][write][reference](time.Time) ---

	if ctx.IsStringTable() {
		d := ctx.Table.AddOrGet(target.Device)
		buff.WriteInt(d) // write table index
	} else {
		buff.WriteString(target.Device) // write string
	}

	if ctx.IsStringTable() {
		e := ctx.Table.AddOrGet(target.ModelName)
		buff.WriteInt(e) // write table index
	} else {
		buff.WriteString(target.ModelName) // write string
	}

	if target.PodUsages == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]DCGMPod) ---
		buff.WriteInt(len(target.PodUsages)) // map length
		for v, z := range target.PodUsages {
			if ctx.IsStringTable() {
				f := ctx.Table.AddOrGet(v)
				buff.WriteInt(f) // write table index
			} else {
				buff.WriteString(v) // write string
			}

			// --- [begin][write][struct](DCGMPod) ---
			buff.WriteInt(0) // [compatibility, unused]
			errC := z.MarshalBinaryWithContext(ctx)
			if errC != nil {
				return errC
			}
			// --- [end][write][struct](DCGMPod) ---

		}
		// --- [end][write][map](map[string]DCGMPod) ---

	}

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the DCGMDevice type
func (target *DCGMDevice) UnmarshalBinary(data []byte) error {
	ctx := NewDecodingContextFromBytes(data)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryFromReader uses the io.Reader data to set all the internal properties of
// the DCGMDevice type
func (target *DCGMDevice) UnmarshalBinaryFromReader(reader io.Reader) error {
	ctx := NewDecodingContextFromReader(reader)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
// the DCGMDevice type
func (target *DCGMDevice) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	version := buff.ReadUInt8()

	if version > DefaultCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling DCGMDevice. Expected %d or less, got %d", DefaultCodecVersion, version)
	}

	var b string
	if ctx.IsStringTable() {
		c := buff.ReadInt() // read string index
		b = ctx.Table.At(c)
	} else {
		b = buff.ReadString() // read string
	}
	a := b
	target.UUID = a

	// --- [begin][read][reference](time.Time) ---
	d := new(time.Time)
	e := buff.ReadInt() // byte array length
	f := buff.ReadBytes(e)
	errA := d.UnmarshalBinary(f)
	if errA != nil {
		return errA
	}
	target.Start = *d
	// --- [end][read][reference](time.Time) ---

	// --- [begin][read][reference](time.Time) ---
	g := new(time.Time)
	h := buff.ReadInt() // byte array length
	l := buff.ReadBytes(h)
	errB := g.UnmarshalBinary(l)
	if errB != nil {
		return errB
	}
	target.End = *g
	// --- [end][read][reference](time.Time) ---

	var n string
	if ctx.IsStringTable() {
		o := buff.ReadInt() // read string index
		n = ctx.Table.At(o)
	} else {
		n = buff.ReadString() // read string
	}
	m := n
	target.Device = m

	var q string
	if ctx.IsStringTable() {
		r := buff.ReadInt() // read string index
		q = ctx.Table.At(r)
	} else {
		q = buff.ReadString() // read string
	}
	p := q
	target.ModelName = p

	if buff.ReadUInt8() == uint8(0) {
		target.PodUsages = nil
	} else {
		// --- [begin][read][map](map[string]DCGMPod) ---
		t := buff.ReadInt() // map len
		s := make(map[string]DCGMPod, t)
		for range t {
			var v string
			var w string
			if ctx.IsStringTable() {
				x := buff.ReadInt() // read string index
				w = ctx.Table.At(x)
			} else {
				w = buff.ReadString() // read string
			}
			u := w
			v = u

			// --- [begin][read][struct](DCGMPod) ---
			y := new(DCGMPod)
			buff.ReadInt() // [compatibility, unused]
			errC := y.UnmarshalBinaryWithContext(ctx)
			if errC != nil {
				return errC
			}
			z := *y
			// --- [end][read][struct](DCGMPod) ---

			s[v] = z
		}
		target.PodUsages = s
		// --- [end][read][map](map[string]DCGMPod) ---

	}

	return nil
}

//--------------------------------------------------------------------------
//  DCGMPod
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this DCGMPod instance
// into a byte array
func (target *DCGMPod) MarshalBinary() (data []byte, err error) {
	ctx := NewEncodingContext(nil)

	e := target.MarshalBinaryWithContext(ctx)
	if e != nil {
		return nil, e
	}

	return ctx.ToBytes(), nil
}

// MarshalBinary serializes the internal properties of this DCGMPod instance
// into an io.Writer.
func (target *DCGMPod) MarshalBinaryTo(writer io.Writer) error {
	buff := util.NewBufferFromWriter(writer)
	defer buff.Flush()

	ctx := NewEncodingContextFromBuffer(buff, nil)

	return target.MarshalBinaryWithContext(ctx)
}

// MarshalBinaryWithContext serializes the internal properties of this DCGMPod instance
// into a byte array leveraging a predefined context.
func (target *DCGMPod) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	buff.WriteUInt8(DefaultCodecVersion) // version

	if target.ContainerUsages == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]DCGMContainer) ---
		buff.WriteInt(len(target.ContainerUsages)) // map length
		for v, z := range target.ContainerUsages {
			if ctx.IsStringTable() {
				a := ctx.Table.AddOrGet(v)
				buff.WriteInt(a) // write table index
			} else {
				buff.WriteString(v) // write string
			}

			// --- [begin][write][struct](DCGMContainer) ---
			buff.WriteInt(0) // [compatibility, unused]
			errA := z.MarshalBinaryWithContext(ctx)
			if errA != nil {
				return errA
			}
			// --- [end][write][struct](DCGMContainer) ---

		}
		// --- [end][write][map](map[string]DCGMContainer) ---

	}

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the DCGMPod type
func (target *DCGMPod) UnmarshalBinary(data []byte) error {
	ctx := NewDecodingContextFromBytes(data)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryFromReader uses the io.Reader data to set all the internal properties of
// the DCGMPod type
func (target *DCGMPod) UnmarshalBinaryFromReader(reader io.Reader) error {
	ctx := NewDecodingContextFromReader(reader)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
// the DCGMPod type
func (target *DCGMPod) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	version := buff.ReadUInt8()

	if version > DefaultCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling DCGMPod. Expected %d or less, got %d", DefaultCodecVersion, version)
	}

	if buff.ReadUInt8() == uint8(0) {
		target.ContainerUsages = nil
	} else {
		// --- [begin][read][map](map[string]DCGMContainer) ---
		b := buff.ReadInt() // map len
		a := make(map[string]DCGMContainer, b)
		for range b {
			var v string
			var d string
			if ctx.IsStringTable() {
				e := buff.ReadInt() // read string index
				d = ctx.Table.At(e)
			} else {
				d = buff.ReadString() // read string
			}
			c := d
			v = c

			// --- [begin][read][struct](DCGMContainer) ---
			f := new(DCGMContainer)
			buff.ReadInt() // [compatibility, unused]
			errA := f.UnmarshalBinaryWithContext(ctx)
			if errA != nil {
				return errA
			}
			z := *f
			// --- [end][read][struct](DCGMContainer) ---

			a[v] = z
		}
		target.ContainerUsages = a
		// --- [end][read][map](map[string]DCGMContainer) ---

	}

	return nil
}

//--------------------------------------------------------------------------
//  DaemonSet
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this DaemonSet instance
// into a byte array
func (target *DaemonSet) MarshalBinary() (data []byte, err error) {
	ctx := NewEncodingContext(nil)

	e := target.MarshalBinaryWithContext(ctx)
	if e != nil {
		return nil, e
	}

	return ctx.ToBytes(), nil
}

// MarshalBinary serializes the internal properties of this DaemonSet instance
// into an io.Writer.
func (target *DaemonSet) MarshalBinaryTo(writer io.Writer) error {
	buff := util.NewBufferFromWriter(writer)
	defer buff.Flush()

	ctx := NewEncodingContextFromBuffer(buff, nil)

	return target.MarshalBinaryWithContext(ctx)
}

// MarshalBinaryWithContext serializes the internal properties of this DaemonSet instance
// into a byte array leveraging a predefined context.
func (target *DaemonSet) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	buff.WriteUInt8(DefaultCodecVersion) // version

	if ctx.IsStringTable() {
		a := ctx.Table.AddOrGet(target.UID)
		buff.WriteInt(a) // write table index
	} else {
		buff.WriteString(target.UID) // write string
	}

	if ctx.IsStringTable() {
		b := ctx.Table.AddOrGet(target.NamespaceUID)
		buff.WriteInt(b) // write table index
	} else {
		buff.WriteString(target.NamespaceUID) // write string
	}

	if ctx.IsStringTable() {
		c := ctx.Table.AddOrGet(target.Name)
		buff.WriteInt(c) // write table index
	} else {
		buff.WriteString(target.Name) // write string
	}

	if target.Labels == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]string) ---
		buff.WriteInt(len(target.Labels)) // map length
		for v, z := range target.Labels {
			if ctx.IsStringTable() {
				d := ctx.Table.AddOrGet(v)
				buff.WriteInt(d) // write table index
			} else {
				buff.WriteString(v) // write string
			}

			if ctx.IsStringTable() {
				e := ctx.Table.AddOrGet(z)
				buff.WriteInt(e) // write table index
			} else {
				buff.WriteString(z) // write string
			}

		}
		// --- [end][write][map](map[string]string) ---

	}
	if target.Annotations == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]string) ---
		buff.WriteInt(len(target.Annotations)) // map length
		for vv, zz := range target.Annotations {
			if ctx.IsStringTable() {
				f := ctx.Table.AddOrGet(vv)
				buff.WriteInt(f) // write table index
			} else {
				buff.WriteString(vv) // write string
			}

			if ctx.IsStringTable() {
				g := ctx.Table.AddOrGet(zz)
				buff.WriteInt(g) // write table index
			} else {
				buff.WriteString(zz) // write string
			}

		}
		// --- [end][write][map](map[string]string) ---

	}
	if target.DevicePluginInfo == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]string) ---
		buff.WriteInt(len(target.DevicePluginInfo)) // map length
		for vvv, zzz := range target.DevicePluginInfo {
			if ctx.IsStringTable() {
				h := ctx.Table.AddOrGet(vvv)
				buff.WriteInt(h) // write table index
			} else {
				buff.WriteString(vvv) // write string
			}

			if ctx.IsStringTable() {
				l := ctx.Table.AddOrGet(zzz)
				buff.WriteInt(l) // write table index
			} else {
				buff.WriteString(zzz) // write string
			}

		}
		// --- [end][write][map](map[string]string) ---

	}

	// --- [begin][write][reference](time.Time) ---
	m, errA := target.Start.MarshalBinary()
	if errA != nil {
		return errA
	}
	buff.WriteInt(len(m))
	buff.WriteBytes(m)
	// --- [end][write][reference](time.Time) ---

	// --- [begin][write][reference](time.Time) ---
	n, errB := target.End.MarshalBinary()
	if errB != nil {
		return errB
	}
	buff.WriteInt(len(n))
	buff.WriteBytes(n)
	// --- [end][write][reference](time.Time) ---

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the DaemonSet type
func (target *DaemonSet) UnmarshalBinary(data []byte) error {
	ctx := NewDecodingContextFromBytes(data)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryFromReader uses the io.Reader data to set all the internal properties of
// the DaemonSet type
func (target *DaemonSet) UnmarshalBinaryFromReader(reader io.Reader) error {
	ctx := NewDecodingContextFromReader(reader)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
// the DaemonSet type
func (target *DaemonSet) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	version := buff.ReadUInt8()

	if version > DefaultCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling DaemonSet. Expected %d or less, got %d", DefaultCodecVersion, version)
	}

	var b string
	if ctx.IsStringTable() {
		c := buff.ReadInt() // read string index
		b = ctx.Table.At(c)
	} else {
		b = buff.ReadString() // read string
	}
	a := b
	target.UID = a

	var e string
	if ctx.IsStringTable() {
		f := buff.ReadInt() // read string index
		e = ctx.Table.At(f)
	} else {
		e = buff.ReadString() // read string
	}
	d := e
	target.NamespaceUID = d

	var h string
	if ctx.IsStringTable() {
		l := buff.ReadInt() // read string index
		h = ctx.Table.At(l)
	} else {
		h = buff.ReadString() // read string
	}
	g := h
	target.Name = g

	if buff.ReadUInt8() == uint8(0) {
		target.Labels = nil
	} else {
		// --- [begin][read][map](map[string]string) ---
		n := buff.ReadInt() // map len
		m := make(map[string]string, n)
		for range n {
			var v string
			var p string
			if ctx.IsStringTable() {
				q := buff.ReadInt() // read string index
				p = ctx.Table.At(q)
			} else {
				p = buff.ReadString() // read string
			}
			o := p
			v = o

			var z string
			var s string
			if ctx.IsStringTable() {
				t := buff.ReadInt() // read string index
				s = ctx.Table.At(t)
			} else {
				s = buff.ReadString() // read string
			}
			r := s
			z = r

			m[v] = z
		}
		target.Labels = m
		// --- [end][read][map](map[string]string) ---

	}

	if buff.ReadUInt8() == uint8(0) {
		target.Annotations = nil
	} else {
		// --- [begin][read][map](map[string]string) ---
		w := buff.ReadInt() // map len
		u := make(map[string]string, w)
		for range w {
			var vv string
			var y string
			if ctx.IsStringTable() {
				aa := buff.ReadInt() // read string index
				y = ctx.Table.At(aa)
			} else {
				y = buff.ReadString() // read string
			}
			x := y
			vv = x

			var zz string
			var cc string
			if ctx.IsStringTable() {
				dd := buff.ReadInt() // read string index
				cc = ctx.Table.At(dd)
			} else {
				cc = buff.ReadString() // read string
			}
			bb := cc
			zz = bb

			u[vv] = zz
		}
		target.Annotations = u
		// --- [end][read][map](map[string]string) ---

	}

	if buff.ReadUInt8() == uint8(0) {
		target.DevicePluginInfo = nil
	} else {
		// --- [begin][read][map](map[string]string) ---
		ff := buff.ReadInt() // map len
		ee := make(map[string]string, ff)
		for range ff {
			var vvv string
			var hh string
			if ctx.IsStringTable() {
				ll := buff.ReadInt() // read string index
				hh = ctx.Table.At(ll)
			} else {
				hh = buff.ReadString() // read string
			}
			gg := hh
			vvv = gg

			var zzz string
			var nn string
			if ctx.IsStringTable() {
				oo := buff.ReadInt() // read string index
				nn = ctx.Table.At(oo)
			} else {
				nn = buff.ReadString() // read string
			}
			mm := nn
			zzz = mm

			ee[vvv] = zzz
		}
		target.DevicePluginInfo = ee
		// --- [end][read][map](map[string]string) ---

	}

	// --- [begin][read][reference](time.Time) ---
	pp := new(time.Time)
	qq := buff.ReadInt() // byte array length
	rr := buff.ReadBytes(qq)
	errA := pp.UnmarshalBinary(rr)
	if errA != nil {
		return errA
	}
	target.Start = *pp
	// --- [end][read][reference](time.Time) ---

	// --- [begin][read][reference](time.Time) ---
	ss := new(time.Time)
	tt := buff.ReadInt() // byte array length
	uu := buff.ReadBytes(tt)
	errB := ss.UnmarshalBinary(uu)
	if errB != nil {
		return errB
	}
	target.End = *ss
	// --- [end][read][reference](time.Time) ---

	return nil
}

//--------------------------------------------------------------------------
//  Deployment
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this Deployment instance
// into a byte array
func (target *Deployment) MarshalBinary() (data []byte, err error) {
	ctx := NewEncodingContext(nil)

	e := target.MarshalBinaryWithContext(ctx)
	if e != nil {
		return nil, e
	}

	return ctx.ToBytes(), nil
}

// MarshalBinary serializes the internal properties of this Deployment instance
// into an io.Writer.
func (target *Deployment) MarshalBinaryTo(writer io.Writer) error {
	buff := util.NewBufferFromWriter(writer)
	defer buff.Flush()

	ctx := NewEncodingContextFromBuffer(buff, nil)

	return target.MarshalBinaryWithContext(ctx)
}

// MarshalBinaryWithContext serializes the internal properties of this Deployment instance
// into a byte array leveraging a predefined context.
func (target *Deployment) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	buff.WriteUInt8(DefaultCodecVersion) // version

	if ctx.IsStringTable() {
		a := ctx.Table.AddOrGet(target.UID)
		buff.WriteInt(a) // write table index
	} else {
		buff.WriteString(target.UID) // write string
	}

	if ctx.IsStringTable() {
		b := ctx.Table.AddOrGet(target.NamespaceUID)
		buff.WriteInt(b) // write table index
	} else {
		buff.WriteString(target.NamespaceUID) // write string
	}

	if ctx.IsStringTable() {
		c := ctx.Table.AddOrGet(target.Name)
		buff.WriteInt(c) // write table index
	} else {
		buff.WriteString(target.Name) // write string
	}

	if target.Labels == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]string) ---
		buff.WriteInt(len(target.Labels)) // map length
		for v, z := range target.Labels {
			if ctx.IsStringTable() {
				d := ctx.Table.AddOrGet(v)
				buff.WriteInt(d) // write table index
			} else {
				buff.WriteString(v) // write string
			}

			if ctx.IsStringTable() {
				e := ctx.Table.AddOrGet(z)
				buff.WriteInt(e) // write table index
			} else {
				buff.WriteString(z) // write string
			}

		}
		// --- [end][write][map](map[string]string) ---

	}
	if target.Annotations == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]string) ---
		buff.WriteInt(len(target.Annotations)) // map length
		for vv, zz := range target.Annotations {
			if ctx.IsStringTable() {
				f := ctx.Table.AddOrGet(vv)
				buff.WriteInt(f) // write table index
			} else {
				buff.WriteString(vv) // write string
			}

			if ctx.IsStringTable() {
				g := ctx.Table.AddOrGet(zz)
				buff.WriteInt(g) // write table index
			} else {
				buff.WriteString(zz) // write string
			}

		}
		// --- [end][write][map](map[string]string) ---

	}
	if target.MatchLabels == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]string) ---
		buff.WriteInt(len(target.MatchLabels)) // map length
		for vvv, zzz := range target.MatchLabels {
			if ctx.IsStringTable() {
				h := ctx.Table.AddOrGet(vvv)
				buff.WriteInt(h) // write table index
			} else {
				buff.WriteString(vvv) // write string
			}

			if ctx.IsStringTable() {
				l := ctx.Table.AddOrGet(zzz)
				buff.WriteInt(l) // write table index
			} else {
				buff.WriteString(zzz) // write string
			}

		}
		// --- [end][write][map](map[string]string) ---

	}

	// --- [begin][write][reference](time.Time) ---
	m, errA := target.Start.MarshalBinary()
	if errA != nil {
		return errA
	}
	buff.WriteInt(len(m))
	buff.WriteBytes(m)
	// --- [end][write][reference](time.Time) ---

	// --- [begin][write][reference](time.Time) ---
	n, errB := target.End.MarshalBinary()
	if errB != nil {
		return errB
	}
	buff.WriteInt(len(n))
	buff.WriteBytes(n)
	// --- [end][write][reference](time.Time) ---

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the Deployment type
func (target *Deployment) UnmarshalBinary(data []byte) error {
	ctx := NewDecodingContextFromBytes(data)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryFromReader uses the io.Reader data to set all the internal properties of
// the Deployment type
func (target *Deployment) UnmarshalBinaryFromReader(reader io.Reader) error {
	ctx := NewDecodingContextFromReader(reader)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
// the Deployment type
func (target *Deployment) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	version := buff.ReadUInt8()

	if version > DefaultCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling Deployment. Expected %d or less, got %d", DefaultCodecVersion, version)
	}

	var b string
	if ctx.IsStringTable() {
		c := buff.ReadInt() // read string index
		b = ctx.Table.At(c)
	} else {
		b = buff.ReadString() // read string
	}
	a := b
	target.UID = a

	var e string
	if ctx.IsStringTable() {
		f := buff.ReadInt() // read string index
		e = ctx.Table.At(f)
	} else {
		e = buff.ReadString() // read string
	}
	d := e
	target.NamespaceUID = d

	var h string
	if ctx.IsStringTable() {
		l := buff.ReadInt() // read string index
		h = ctx.Table.At(l)
	} else {
		h = buff.ReadString() // read string
	}
	g := h
	target.Name = g

	if buff.ReadUInt8() == uint8(0) {
		target.Labels = nil
	} else {
		// --- [begin][read][map](map[string]string) ---
		n := buff.ReadInt() // map len
		m := make(map[string]string, n)
		for range n {
			var v string
			var p string
			if ctx.IsStringTable() {
				q := buff.ReadInt() // read string index
				p = ctx.Table.At(q)
			} else {
				p = buff.ReadString() // read string
			}
			o := p
			v = o

			var z string
			var s string
			if ctx.IsStringTable() {
				t := buff.ReadInt() // read string index
				s = ctx.Table.At(t)
			} else {
				s = buff.ReadString() // read string
			}
			r := s
			z = r

			m[v] = z
		}
		target.Labels = m
		// --- [end][read][map](map[string]string) ---

	}

	if buff.ReadUInt8() == uint8(0) {
		target.Annotations = nil
	} else {
		// --- [begin][read][map](map[string]string) ---
		w := buff.ReadInt() // map len
		u := make(map[string]string, w)
		for range w {
			var vv string
			var y string
			if ctx.IsStringTable() {
				aa := buff.ReadInt() // read string index
				y = ctx.Table.At(aa)
			} else {
				y = buff.ReadString() // read string
			}
			x := y
			vv = x

			var zz string
			var cc string
			if ctx.IsStringTable() {
				dd := buff.ReadInt() // read string index
				cc = ctx.Table.At(dd)
			} else {
				cc = buff.ReadString() // read string
			}
			bb := cc
			zz = bb

			u[vv] = zz
		}
		target.Annotations = u
		// --- [end][read][map](map[string]string) ---

	}

	if buff.ReadUInt8() == uint8(0) {
		target.MatchLabels = nil
	} else {
		// --- [begin][read][map](map[string]string) ---
		ff := buff.ReadInt() // map len
		ee := make(map[string]string, ff)
		for range ff {
			var vvv string
			var hh string
			if ctx.IsStringTable() {
				ll := buff.ReadInt() // read string index
				hh = ctx.Table.At(ll)
			} else {
				hh = buff.ReadString() // read string
			}
			gg := hh
			vvv = gg

			var zzz string
			var nn string
			if ctx.IsStringTable() {
				oo := buff.ReadInt() // read string index
				nn = ctx.Table.At(oo)
			} else {
				nn = buff.ReadString() // read string
			}
			mm := nn
			zzz = mm

			ee[vvv] = zzz
		}
		target.MatchLabels = ee
		// --- [end][read][map](map[string]string) ---

	}

	// --- [begin][read][reference](time.Time) ---
	pp := new(time.Time)
	qq := buff.ReadInt() // byte array length
	rr := buff.ReadBytes(qq)
	errA := pp.UnmarshalBinary(rr)
	if errA != nil {
		return errA
	}
	target.Start = *pp
	// --- [end][read][reference](time.Time) ---

	// --- [begin][read][reference](time.Time) ---
	ss := new(time.Time)
	tt := buff.ReadInt() // byte array length
	uu := buff.ReadBytes(tt)
	errB := ss.UnmarshalBinary(uu)
	if errB != nil {
		return errB
	}
	target.End = *ss
	// --- [end][read][reference](time.Time) ---

	return nil
}

//--------------------------------------------------------------------------
//  Diagnostic
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this Diagnostic instance
// into a byte array
func (target *Diagnostic) MarshalBinary() (data []byte, err error) {
	ctx := NewEncodingContext(nil)

	e := target.MarshalBinaryWithContext(ctx)
	if e != nil {
		return nil, e
	}

	return ctx.ToBytes(), nil
}

// MarshalBinary serializes the internal properties of this Diagnostic instance
// into an io.Writer.
func (target *Diagnostic) MarshalBinaryTo(writer io.Writer) error {
	buff := util.NewBufferFromWriter(writer)
	defer buff.Flush()

	ctx := NewEncodingContextFromBuffer(buff, nil)

	return target.MarshalBinaryWithContext(ctx)
}

// MarshalBinaryWithContext serializes the internal properties of this Diagnostic instance
// into a byte array leveraging a predefined context.
func (target *Diagnostic) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	buff.WriteUInt8(DefaultCodecVersion) // version

	// --- [begin][write][reference](time.Time) ---
	a, errA := target.Timestamp.MarshalBinary()
	if errA != nil {
		return errA
	}
	buff.WriteInt(len(a))
	buff.WriteBytes(a)
	// --- [end][write][reference](time.Time) ---

	// --- [begin][write][alias](DiagnosticLevel) ---

	buff.WriteInt(int(target.Level)) // write int

	// --- [end][write][alias](DiagnosticLevel) ---

	if ctx.IsStringTable() {
		b := ctx.Table.AddOrGet(target.Message)
		buff.WriteInt(b) // write table index
	} else {
		buff.WriteString(target.Message) // write string
	}

	if target.Details == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]string) ---
		buff.WriteInt(len(target.Details)) // map length
		for v, z := range target.Details {
			if ctx.IsStringTable() {
				c := ctx.Table.AddOrGet(v)
				buff.WriteInt(c) // write table index
			} else {
				buff.WriteString(v) // write string
			}

			if ctx.IsStringTable() {
				d := ctx.Table.AddOrGet(z)
				buff.WriteInt(d) // write table index
			} else {
				buff.WriteString(z) // write string
			}

		}
		// --- [end][write][map](map[string]string) ---

	}

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the Diagnostic type
func (target *Diagnostic) UnmarshalBinary(data []byte) error {
	ctx := NewDecodingContextFromBytes(data)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryFromReader uses the io.Reader data to set all the internal properties of
// the Diagnostic type
func (target *Diagnostic) UnmarshalBinaryFromReader(reader io.Reader) error {
	ctx := NewDecodingContextFromReader(reader)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
// the Diagnostic type
func (target *Diagnostic) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	version := buff.ReadUInt8()

	if version > DefaultCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling Diagnostic. Expected %d or less, got %d", DefaultCodecVersion, version)
	}

	// field version check
	if uint8(1) <= version {

		// --- [begin][read][reference](time.Time) ---
		a := new(time.Time)
		b := buff.ReadInt() // byte array length
		c := buff.ReadBytes(b)
		errA := a.UnmarshalBinary(c)
		if errA != nil {
			return errA
		}
		target.Timestamp = *a
		// --- [end][read][reference](time.Time) ---

	} else {
	}
	// field version check
	if uint8(1) <= version {
		// --- [begin][read][alias](DiagnosticLevel) ---
		var d int
		e := buff.ReadInt() // read int
		d = e

		target.Level = DiagnosticLevel(d)
		// --- [end][read][alias](DiagnosticLevel) ---

	} else {
	}
	// field version check
	if uint8(1) <= version {

		var g string
		if ctx.IsStringTable() {
			h := buff.ReadInt() // read string index
			g = ctx.Table.At(h)
		} else {
			g = buff.ReadString() // read string
		}
		f := g
		target.Message = f

	} else {
		target.Message = "" // default
	}
	// field version check
	if uint8(1) <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.Details = nil
		} else {
			// --- [begin][read][map](map[string]string) ---
			m := buff.ReadInt() // map len
			l := make(map[string]string, m)
			for range m {
				var v string
				var o string
				if ctx.IsStringTable() {
					p := buff.ReadInt() // read string index
					o = ctx.Table.At(p)
				} else {
					o = buff.ReadString() // read string
				}
				n := o
				v = n

				var z string
				var r string
				if ctx.IsStringTable() {
					s := buff.ReadInt() // read string index
					r = ctx.Table.At(s)
				} else {
					r = buff.ReadString() // read string
				}
				q := r
				z = q

				l[v] = z
			}
			target.Details = l
			// --- [end][read][map](map[string]string) ---

		}

	} else {
		target.Details = nil
	}

	return nil
}

//--------------------------------------------------------------------------
//  FileSystem
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this FileSystem instance
// into a byte array
func (target *FileSystem) MarshalBinary() (data []byte, err error) {
	ctx := NewEncodingContext(nil)

	e := target.MarshalBinaryWithContext(ctx)
	if e != nil {
		return nil, e
	}

	return ctx.ToBytes(), nil
}

// MarshalBinary serializes the internal properties of this FileSystem instance
// into an io.Writer.
func (target *FileSystem) MarshalBinaryTo(writer io.Writer) error {
	buff := util.NewBufferFromWriter(writer)
	defer buff.Flush()

	ctx := NewEncodingContextFromBuffer(buff, nil)

	return target.MarshalBinaryWithContext(ctx)
}

// MarshalBinaryWithContext serializes the internal properties of this FileSystem instance
// into a byte array leveraging a predefined context.
func (target *FileSystem) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	buff.WriteUInt8(DefaultCodecVersion) // version

	buff.WriteFloat64(target.CapacityBytes) // write float64

	buff.WriteFloat64(target.UsageByteAvg) // write float64

	buff.WriteFloat64(target.UsageByteMax) // write float64

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the FileSystem type
func (target *FileSystem) UnmarshalBinary(data []byte) error {
	ctx := NewDecodingContextFromBytes(data)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryFromReader uses the io.Reader data to set all the internal properties of
// the FileSystem type
func (target *FileSystem) UnmarshalBinaryFromReader(reader io.Reader) error {
	ctx := NewDecodingContextFromReader(reader)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
// the FileSystem type
func (target *FileSystem) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	version := buff.ReadUInt8()

	if version > DefaultCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling FileSystem. Expected %d or less, got %d", DefaultCodecVersion, version)
	}

	a := buff.ReadFloat64() // read float64
	target.CapacityBytes = a

	b := buff.ReadFloat64() // read float64
	target.UsageByteAvg = b

	c := buff.ReadFloat64() // read float64
	target.UsageByteMax = c

	return nil
}

//--------------------------------------------------------------------------
//  Job
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this Job instance
// into a byte array
func (target *Job) MarshalBinary() (data []byte, err error) {
	ctx := NewEncodingContext(nil)

	e := target.MarshalBinaryWithContext(ctx)
	if e != nil {
		return nil, e
	}

	return ctx.ToBytes(), nil
}

// MarshalBinary serializes the internal properties of this Job instance
// into an io.Writer.
func (target *Job) MarshalBinaryTo(writer io.Writer) error {
	buff := util.NewBufferFromWriter(writer)
	defer buff.Flush()

	ctx := NewEncodingContextFromBuffer(buff, nil)

	return target.MarshalBinaryWithContext(ctx)
}

// MarshalBinaryWithContext serializes the internal properties of this Job instance
// into a byte array leveraging a predefined context.
func (target *Job) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	buff.WriteUInt8(DefaultCodecVersion) // version

	if ctx.IsStringTable() {
		a := ctx.Table.AddOrGet(target.UID)
		buff.WriteInt(a) // write table index
	} else {
		buff.WriteString(target.UID) // write string
	}

	if ctx.IsStringTable() {
		b := ctx.Table.AddOrGet(target.NamespaceUID)
		buff.WriteInt(b) // write table index
	} else {
		buff.WriteString(target.NamespaceUID) // write string
	}

	if ctx.IsStringTable() {
		c := ctx.Table.AddOrGet(target.Name)
		buff.WriteInt(c) // write table index
	} else {
		buff.WriteString(target.Name) // write string
	}

	if target.Labels == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]string) ---
		buff.WriteInt(len(target.Labels)) // map length
		for v, z := range target.Labels {
			if ctx.IsStringTable() {
				d := ctx.Table.AddOrGet(v)
				buff.WriteInt(d) // write table index
			} else {
				buff.WriteString(v) // write string
			}

			if ctx.IsStringTable() {
				e := ctx.Table.AddOrGet(z)
				buff.WriteInt(e) // write table index
			} else {
				buff.WriteString(z) // write string
			}

		}
		// --- [end][write][map](map[string]string) ---

	}
	if target.Annotations == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]string) ---
		buff.WriteInt(len(target.Annotations)) // map length
		for vv, zz := range target.Annotations {
			if ctx.IsStringTable() {
				f := ctx.Table.AddOrGet(vv)
				buff.WriteInt(f) // write table index
			} else {
				buff.WriteString(vv) // write string
			}

			if ctx.IsStringTable() {
				g := ctx.Table.AddOrGet(zz)
				buff.WriteInt(g) // write table index
			} else {
				buff.WriteString(zz) // write string
			}

		}
		// --- [end][write][map](map[string]string) ---

	}

	// --- [begin][write][reference](time.Time) ---
	h, errA := target.Start.MarshalBinary()
	if errA != nil {
		return errA
	}
	buff.WriteInt(len(h))
	buff.WriteBytes(h)
	// --- [end][write][reference](time.Time) ---

	// --- [begin][write][reference](time.Time) ---
	l, errB := target.End.MarshalBinary()
	if errB != nil {
		return errB
	}
	buff.WriteInt(len(l))
	buff.WriteBytes(l)
	// --- [end][write][reference](time.Time) ---

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the Job type
func (target *Job) UnmarshalBinary(data []byte) error {
	ctx := NewDecodingContextFromBytes(data)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryFromReader uses the io.Reader data to set all the internal properties of
// the Job type
func (target *Job) UnmarshalBinaryFromReader(reader io.Reader) error {
	ctx := NewDecodingContextFromReader(reader)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
// the Job type
func (target *Job) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	version := buff.ReadUInt8()

	if version > DefaultCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling Job. Expected %d or less, got %d", DefaultCodecVersion, version)
	}

	var b string
	if ctx.IsStringTable() {
		c := buff.ReadInt() // read string index
		b = ctx.Table.At(c)
	} else {
		b = buff.ReadString() // read string
	}
	a := b
	target.UID = a

	var e string
	if ctx.IsStringTable() {
		f := buff.ReadInt() // read string index
		e = ctx.Table.At(f)
	} else {
		e = buff.ReadString() // read string
	}
	d := e
	target.NamespaceUID = d

	var h string
	if ctx.IsStringTable() {
		l := buff.ReadInt() // read string index
		h = ctx.Table.At(l)
	} else {
		h = buff.ReadString() // read string
	}
	g := h
	target.Name = g

	if buff.ReadUInt8() == uint8(0) {
		target.Labels = nil
	} else {
		// --- [begin][read][map](map[string]string) ---
		n := buff.ReadInt() // map len
		m := make(map[string]string, n)
		for range n {
			var v string
			var p string
			if ctx.IsStringTable() {
				q := buff.ReadInt() // read string index
				p = ctx.Table.At(q)
			} else {
				p = buff.ReadString() // read string
			}
			o := p
			v = o

			var z string
			var s string
			if ctx.IsStringTable() {
				t := buff.ReadInt() // read string index
				s = ctx.Table.At(t)
			} else {
				s = buff.ReadString() // read string
			}
			r := s
			z = r

			m[v] = z
		}
		target.Labels = m
		// --- [end][read][map](map[string]string) ---

	}

	if buff.ReadUInt8() == uint8(0) {
		target.Annotations = nil
	} else {
		// --- [begin][read][map](map[string]string) ---
		w := buff.ReadInt() // map len
		u := make(map[string]string, w)
		for range w {
			var vv string
			var y string
			if ctx.IsStringTable() {
				aa := buff.ReadInt() // read string index
				y = ctx.Table.At(aa)
			} else {
				y = buff.ReadString() // read string
			}
			x := y
			vv = x

			var zz string
			var cc string
			if ctx.IsStringTable() {
				dd := buff.ReadInt() // read string index
				cc = ctx.Table.At(dd)
			} else {
				cc = buff.ReadString() // read string
			}
			bb := cc
			zz = bb

			u[vv] = zz
		}
		target.Annotations = u
		// --- [end][read][map](map[string]string) ---

	}

	// --- [begin][read][reference](time.Time) ---
	ee := new(time.Time)
	ff := buff.ReadInt() // byte array length
	gg := buff.ReadBytes(ff)
	errA := ee.UnmarshalBinary(gg)
	if errA != nil {
		return errA
	}
	target.Start = *ee
	// --- [end][read][reference](time.Time) ---

	// --- [begin][read][reference](time.Time) ---
	hh := new(time.Time)
	ll := buff.ReadInt() // byte array length
	mm := buff.ReadBytes(ll)
	errB := hh.UnmarshalBinary(mm)
	if errB != nil {
		return errB
	}
	target.End = *hh
	// --- [end][read][reference](time.Time) ---

	return nil
}

//--------------------------------------------------------------------------
//  KubeModelSet
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this KubeModelSet instance
// into a byte array
func (target *KubeModelSet) MarshalBinary() (data []byte, err error) {
	ctx := NewEncodingContext(NewIndexedStringTableWriter())

	e := target.MarshalBinaryWithContext(ctx)
	if e != nil {
		return nil, e
	}

	return ctx.ToBytes(), nil
}

// MarshalBinary serializes the internal properties of this KubeModelSet instance
// into an io.Writer.
func (target *KubeModelSet) MarshalBinaryTo(writer io.Writer) error {
	buff := util.NewBufferFromWriter(writer)
	defer buff.Flush()

	// run a pre-pass to collect all strings into the string table and discard all writes to the main
	// buffer. Then, we write the string table, sorted by number of repeated uses (descending), to the
	// main buffer, and use the resulting table as part of the context for the main pass.
	prepass := NewPrepassStringTableWriter()
	prepassCtx := NewEncodingContextFromWriter(io.Discard, prepass)

	e := target.MarshalBinaryWithContext(prepassCtx)
	if e != nil {
		return e
	}

	tableWriter := prepass.WriteSortedTo(buff)
	ctx := NewEncodingContextFromBuffer(buff, tableWriter)

	return target.MarshalBinaryWithContext(ctx)
}

// MarshalBinaryWithContext serializes the internal properties of this KubeModelSet instance
// into a byte array leveraging a predefined context.
func (target *KubeModelSet) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	buff.WriteUInt8(DefaultCodecVersion) // version

	if target.Metadata == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][struct](Metadata) ---
		buff.WriteInt(0) // [compatibility, unused]
		errA := target.Metadata.MarshalBinaryWithContext(ctx)
		if errA != nil {
			return errA
		}
		// --- [end][write][struct](Metadata) ---

	}

	// --- [begin][write][struct](Window) ---
	buff.WriteInt(0) // [compatibility, unused]
	errB := target.Window.MarshalBinaryWithContext(ctx)
	if errB != nil {
		return errB
	}
	// --- [end][write][struct](Window) ---

	if target.Cluster == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][struct](Cluster) ---
		buff.WriteInt(0) // [compatibility, unused]
		errC := target.Cluster.MarshalBinaryWithContext(ctx)
		if errC != nil {
			return errC
		}
		// --- [end][write][struct](Cluster) ---

	}
	if target.Namespaces == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]*Namespace) ---
		buff.WriteInt(len(target.Namespaces)) // map length
		for v, z := range target.Namespaces {
			if ctx.IsStringTable() {
				a := ctx.Table.AddOrGet(v)
				buff.WriteInt(a) // write table index
			} else {
				buff.WriteString(v) // write string
			}
			if z == nil {
				buff.WriteUInt8(uint8(0)) // write nil byte
			} else {
				buff.WriteUInt8(uint8(1)) // write non-nil byte

				// --- [begin][write][struct](Namespace) ---
				buff.WriteInt(0) // [compatibility, unused]
				errD := z.MarshalBinaryWithContext(ctx)
				if errD != nil {
					return errD
				}
				// --- [end][write][struct](Namespace) ---

			}
		}
		// --- [end][write][map](map[string]*Namespace) ---

	}
	if target.ResourceQuotas == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]*ResourceQuota) ---
		buff.WriteInt(len(target.ResourceQuotas)) // map length
		for vv, zz := range target.ResourceQuotas {
			if ctx.IsStringTable() {
				b := ctx.Table.AddOrGet(vv)
				buff.WriteInt(b) // write table index
			} else {
				buff.WriteString(vv) // write string
			}
			if zz == nil {
				buff.WriteUInt8(uint8(0)) // write nil byte
			} else {
				buff.WriteUInt8(uint8(1)) // write non-nil byte

				// --- [begin][write][struct](ResourceQuota) ---
				buff.WriteInt(0) // [compatibility, unused]
				errE := zz.MarshalBinaryWithContext(ctx)
				if errE != nil {
					return errE
				}
				// --- [end][write][struct](ResourceQuota) ---

			}
		}
		// --- [end][write][map](map[string]*ResourceQuota) ---

	}
	if target.Services == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]*Service) ---
		buff.WriteInt(len(target.Services)) // map length
		for vvv, zzz := range target.Services {
			if ctx.IsStringTable() {
				c := ctx.Table.AddOrGet(vvv)
				buff.WriteInt(c) // write table index
			} else {
				buff.WriteString(vvv) // write string
			}
			if zzz == nil {
				buff.WriteUInt8(uint8(0)) // write nil byte
			} else {
				buff.WriteUInt8(uint8(1)) // write non-nil byte

				// --- [begin][write][struct](Service) ---
				buff.WriteInt(0) // [compatibility, unused]
				errF := zzz.MarshalBinaryWithContext(ctx)
				if errF != nil {
					return errF
				}
				// --- [end][write][struct](Service) ---

			}
		}
		// --- [end][write][map](map[string]*Service) ---

	}
	if target.Deployments == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]*Deployment) ---
		buff.WriteInt(len(target.Deployments)) // map length
		for vvvv, zzzz := range target.Deployments {
			if ctx.IsStringTable() {
				d := ctx.Table.AddOrGet(vvvv)
				buff.WriteInt(d) // write table index
			} else {
				buff.WriteString(vvvv) // write string
			}
			if zzzz == nil {
				buff.WriteUInt8(uint8(0)) // write nil byte
			} else {
				buff.WriteUInt8(uint8(1)) // write non-nil byte

				// --- [begin][write][struct](Deployment) ---
				buff.WriteInt(0) // [compatibility, unused]
				errG := zzzz.MarshalBinaryWithContext(ctx)
				if errG != nil {
					return errG
				}
				// --- [end][write][struct](Deployment) ---

			}
		}
		// --- [end][write][map](map[string]*Deployment) ---

	}
	if target.StatefulSets == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]*StatefulSet) ---
		buff.WriteInt(len(target.StatefulSets)) // map length
		for vvvvv, zzzzz := range target.StatefulSets {
			if ctx.IsStringTable() {
				e := ctx.Table.AddOrGet(vvvvv)
				buff.WriteInt(e) // write table index
			} else {
				buff.WriteString(vvvvv) // write string
			}
			if zzzzz == nil {
				buff.WriteUInt8(uint8(0)) // write nil byte
			} else {
				buff.WriteUInt8(uint8(1)) // write non-nil byte

				// --- [begin][write][struct](StatefulSet) ---
				buff.WriteInt(0) // [compatibility, unused]
				errH := zzzzz.MarshalBinaryWithContext(ctx)
				if errH != nil {
					return errH
				}
				// --- [end][write][struct](StatefulSet) ---

			}
		}
		// --- [end][write][map](map[string]*StatefulSet) ---

	}
	if target.DaemonSets == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]*DaemonSet) ---
		buff.WriteInt(len(target.DaemonSets)) // map length
		for vvvvvv, zzzzzz := range target.DaemonSets {
			if ctx.IsStringTable() {
				f := ctx.Table.AddOrGet(vvvvvv)
				buff.WriteInt(f) // write table index
			} else {
				buff.WriteString(vvvvvv) // write string
			}
			if zzzzzz == nil {
				buff.WriteUInt8(uint8(0)) // write nil byte
			} else {
				buff.WriteUInt8(uint8(1)) // write non-nil byte

				// --- [begin][write][struct](DaemonSet) ---
				buff.WriteInt(0) // [compatibility, unused]
				errI := zzzzzz.MarshalBinaryWithContext(ctx)
				if errI != nil {
					return errI
				}
				// --- [end][write][struct](DaemonSet) ---

			}
		}
		// --- [end][write][map](map[string]*DaemonSet) ---

	}
	if target.Jobs == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]*Job) ---
		buff.WriteInt(len(target.Jobs)) // map length
		for vvvvvvv, zzzzzzz := range target.Jobs {
			if ctx.IsStringTable() {
				g := ctx.Table.AddOrGet(vvvvvvv)
				buff.WriteInt(g) // write table index
			} else {
				buff.WriteString(vvvvvvv) // write string
			}
			if zzzzzzz == nil {
				buff.WriteUInt8(uint8(0)) // write nil byte
			} else {
				buff.WriteUInt8(uint8(1)) // write non-nil byte

				// --- [begin][write][struct](Job) ---
				buff.WriteInt(0) // [compatibility, unused]
				errJ := zzzzzzz.MarshalBinaryWithContext(ctx)
				if errJ != nil {
					return errJ
				}
				// --- [end][write][struct](Job) ---

			}
		}
		// --- [end][write][map](map[string]*Job) ---

	}
	if target.CronJobs == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]*CronJob) ---
		buff.WriteInt(len(target.CronJobs)) // map length
		for vvvvvvvv, zzzzzzzz := range target.CronJobs {
			if ctx.IsStringTable() {
				h := ctx.Table.AddOrGet(vvvvvvvv)
				buff.WriteInt(h) // write table index
			} else {
				buff.WriteString(vvvvvvvv) // write string
			}
			if zzzzzzzz == nil {
				buff.WriteUInt8(uint8(0)) // write nil byte
			} else {
				buff.WriteUInt8(uint8(1)) // write non-nil byte

				// --- [begin][write][struct](CronJob) ---
				buff.WriteInt(0) // [compatibility, unused]
				errK := zzzzzzzz.MarshalBinaryWithContext(ctx)
				if errK != nil {
					return errK
				}
				// --- [end][write][struct](CronJob) ---

			}
		}
		// --- [end][write][map](map[string]*CronJob) ---

	}
	if target.ReplicaSets == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]*ReplicaSet) ---
		buff.WriteInt(len(target.ReplicaSets)) // map length
		for vvvvvvvvv, zzzzzzzzz := range target.ReplicaSets {
			if ctx.IsStringTable() {
				l := ctx.Table.AddOrGet(vvvvvvvvv)
				buff.WriteInt(l) // write table index
			} else {
				buff.WriteString(vvvvvvvvv) // write string
			}
			if zzzzzzzzz == nil {
				buff.WriteUInt8(uint8(0)) // write nil byte
			} else {
				buff.WriteUInt8(uint8(1)) // write non-nil byte

				// --- [begin][write][struct](ReplicaSet) ---
				buff.WriteInt(0) // [compatibility, unused]
				errL := zzzzzzzzz.MarshalBinaryWithContext(ctx)
				if errL != nil {
					return errL
				}
				// --- [end][write][struct](ReplicaSet) ---

			}
		}
		// --- [end][write][map](map[string]*ReplicaSet) ---

	}
	if target.Nodes == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]*Node) ---
		buff.WriteInt(len(target.Nodes)) // map length
		for vvvvvvvvvv, zzzzzzzzzz := range target.Nodes {
			if ctx.IsStringTable() {
				m := ctx.Table.AddOrGet(vvvvvvvvvv)
				buff.WriteInt(m) // write table index
			} else {
				buff.WriteString(vvvvvvvvvv) // write string
			}
			if zzzzzzzzzz == nil {
				buff.WriteUInt8(uint8(0)) // write nil byte
			} else {
				buff.WriteUInt8(uint8(1)) // write non-nil byte

				// --- [begin][write][struct](Node) ---
				buff.WriteInt(0) // [compatibility, unused]
				errM := zzzzzzzzzz.MarshalBinaryWithContext(ctx)
				if errM != nil {
					return errM
				}
				// --- [end][write][struct](Node) ---

			}
		}
		// --- [end][write][map](map[string]*Node) ---

	}
	if target.PersistentVolumes == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]*PersistentVolume) ---
		buff.WriteInt(len(target.PersistentVolumes)) // map length
		for vvvvvvvvvvv, zzzzzzzzzzz := range target.PersistentVolumes {
			if ctx.IsStringTable() {
				n := ctx.Table.AddOrGet(vvvvvvvvvvv)
				buff.WriteInt(n) // write table index
			} else {
				buff.WriteString(vvvvvvvvvvv) // write string
			}
			if zzzzzzzzzzz == nil {
				buff.WriteUInt8(uint8(0)) // write nil byte
			} else {
				buff.WriteUInt8(uint8(1)) // write non-nil byte

				// --- [begin][write][struct](PersistentVolume) ---
				buff.WriteInt(0) // [compatibility, unused]
				errN := zzzzzzzzzzz.MarshalBinaryWithContext(ctx)
				if errN != nil {
					return errN
				}
				// --- [end][write][struct](PersistentVolume) ---

			}
		}
		// --- [end][write][map](map[string]*PersistentVolume) ---

	}
	if target.PersistentVolumeClaims == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]*PersistentVolumeClaim) ---
		buff.WriteInt(len(target.PersistentVolumeClaims)) // map length
		for vvvvvvvvvvvv, zzzzzzzzzzzz := range target.PersistentVolumeClaims {
			if ctx.IsStringTable() {
				o := ctx.Table.AddOrGet(vvvvvvvvvvvv)
				buff.WriteInt(o) // write table index
			} else {
				buff.WriteString(vvvvvvvvvvvv) // write string
			}
			if zzzzzzzzzzzz == nil {
				buff.WriteUInt8(uint8(0)) // write nil byte
			} else {
				buff.WriteUInt8(uint8(1)) // write non-nil byte

				// --- [begin][write][struct](PersistentVolumeClaim) ---
				buff.WriteInt(0) // [compatibility, unused]
				errO := zzzzzzzzzzzz.MarshalBinaryWithContext(ctx)
				if errO != nil {
					return errO
				}
				// --- [end][write][struct](PersistentVolumeClaim) ---

			}
		}
		// --- [end][write][map](map[string]*PersistentVolumeClaim) ---

	}
	if target.Pods == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]*Pod) ---
		buff.WriteInt(len(target.Pods)) // map length
		for vvvvvvvvvvvvv, zzzzzzzzzzzzz := range target.Pods {
			if ctx.IsStringTable() {
				p := ctx.Table.AddOrGet(vvvvvvvvvvvvv)
				buff.WriteInt(p) // write table index
			} else {
				buff.WriteString(vvvvvvvvvvvvv) // write string
			}
			if zzzzzzzzzzzzz == nil {
				buff.WriteUInt8(uint8(0)) // write nil byte
			} else {
				buff.WriteUInt8(uint8(1)) // write non-nil byte

				// --- [begin][write][struct](Pod) ---
				buff.WriteInt(0) // [compatibility, unused]
				errP := zzzzzzzzzzzzz.MarshalBinaryWithContext(ctx)
				if errP != nil {
					return errP
				}
				// --- [end][write][struct](Pod) ---

			}
		}
		// --- [end][write][map](map[string]*Pod) ---

	}
	if target.Containers == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]*Container) ---
		buff.WriteInt(len(target.Containers)) // map length
		for vvvvvvvvvvvvvv, zzzzzzzzzzzzzz := range target.Containers {
			if ctx.IsStringTable() {
				q := ctx.Table.AddOrGet(vvvvvvvvvvvvvv)
				buff.WriteInt(q) // write table index
			} else {
				buff.WriteString(vvvvvvvvvvvvvv) // write string
			}
			if zzzzzzzzzzzzzz == nil {
				buff.WriteUInt8(uint8(0)) // write nil byte
			} else {
				buff.WriteUInt8(uint8(1)) // write non-nil byte

				// --- [begin][write][struct](Container) ---
				buff.WriteInt(0) // [compatibility, unused]
				errQ := zzzzzzzzzzzzzz.MarshalBinaryWithContext(ctx)
				if errQ != nil {
					return errQ
				}
				// --- [end][write][struct](Container) ---

			}
		}
		// --- [end][write][map](map[string]*Container) ---

	}
	if target.DCGMDevices == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]*DCGMDevice) ---
		buff.WriteInt(len(target.DCGMDevices)) // map length
		for vvvvvvvvvvvvvvv, zzzzzzzzzzzzzzz := range target.DCGMDevices {
			if ctx.IsStringTable() {
				r := ctx.Table.AddOrGet(vvvvvvvvvvvvvvv)
				buff.WriteInt(r) // write table index
			} else {
				buff.WriteString(vvvvvvvvvvvvvvv) // write string
			}
			if zzzzzzzzzzzzzzz == nil {
				buff.WriteUInt8(uint8(0)) // write nil byte
			} else {
				buff.WriteUInt8(uint8(1)) // write non-nil byte

				// --- [begin][write][struct](DCGMDevice) ---
				buff.WriteInt(0) // [compatibility, unused]
				errR := zzzzzzzzzzzzzzz.MarshalBinaryWithContext(ctx)
				if errR != nil {
					return errR
				}
				// --- [end][write][struct](DCGMDevice) ---

			}
		}
		// --- [end][write][map](map[string]*DCGMDevice) ---

	}

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the KubeModelSet type
func (target *KubeModelSet) UnmarshalBinary(data []byte) error {
	ctx := NewDecodingContextFromBytes(data)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryFromReader uses the io.Reader data to set all the internal properties of
// the KubeModelSet type
func (target *KubeModelSet) UnmarshalBinaryFromReader(reader io.Reader) error {
	ctx := NewDecodingContextFromReader(reader)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
// the KubeModelSet type
func (target *KubeModelSet) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	version := buff.ReadUInt8()

	if version > DefaultCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling KubeModelSet. Expected %d or less, got %d", DefaultCodecVersion, version)
	}

	// field version check
	if uint8(1) <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.Metadata = nil
		} else {
			// --- [begin][read][struct](Metadata) ---
			a := new(Metadata)
			buff.ReadInt() // [compatibility, unused]
			errA := a.UnmarshalBinaryWithContext(ctx)
			if errA != nil {
				return errA
			}
			target.Metadata = a
			// --- [end][read][struct](Metadata) ---

		}

	} else {
		target.Metadata = nil
	}
	// field version check
	if uint8(1) <= version {

		// --- [begin][read][struct](Window) ---
		b := new(Window)
		buff.ReadInt() // [compatibility, unused]
		errB := b.UnmarshalBinaryWithContext(ctx)
		if errB != nil {
			return errB
		}
		target.Window = *b
		// --- [end][read][struct](Window) ---

	} else {
	}
	// field version check
	if uint8(1) <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.Cluster = nil
		} else {
			// --- [begin][read][struct](Cluster) ---
			c := new(Cluster)
			buff.ReadInt() // [compatibility, unused]
			errC := c.UnmarshalBinaryWithContext(ctx)
			if errC != nil {
				return errC
			}
			target.Cluster = c
			// --- [end][read][struct](Cluster) ---

		}

	} else {
		target.Cluster = nil
	}
	// field version check
	if uint8(1) <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.Namespaces = nil
		} else {
			// --- [begin][read][map](map[string]*Namespace) ---
			e := buff.ReadInt() // map len
			d := make(map[string]*Namespace, e)
			for range e {
				var v string
				var g string
				if ctx.IsStringTable() {
					h := buff.ReadInt() // read string index
					g = ctx.Table.At(h)
				} else {
					g = buff.ReadString() // read string
				}
				f := g
				v = f

				var z *Namespace
				if buff.ReadUInt8() == uint8(0) {
					z = nil
				} else {
					// --- [begin][read][struct](Namespace) ---
					l := new(Namespace)
					buff.ReadInt() // [compatibility, unused]
					errD := l.UnmarshalBinaryWithContext(ctx)
					if errD != nil {
						return errD
					}
					z = l
					// --- [end][read][struct](Namespace) ---

				}
				d[v] = z
			}
			target.Namespaces = d
			// --- [end][read][map](map[string]*Namespace) ---

		}

	} else {
		target.Namespaces = nil
	}
	// field version check
	if uint8(1) <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.ResourceQuotas = nil
		} else {
			// --- [begin][read][map](map[string]*ResourceQuota) ---
			n := buff.ReadInt() // map len
			m := make(map[string]*ResourceQuota, n)
			for range n {
				var vv string
				var p string
				if ctx.IsStringTable() {
					q := buff.ReadInt() // read string index
					p = ctx.Table.At(q)
				} else {
					p = buff.ReadString() // read string
				}
				o := p
				vv = o

				var zz *ResourceQuota
				if buff.ReadUInt8() == uint8(0) {
					zz = nil
				} else {
					// --- [begin][read][struct](ResourceQuota) ---
					r := new(ResourceQuota)
					buff.ReadInt() // [compatibility, unused]
					errE := r.UnmarshalBinaryWithContext(ctx)
					if errE != nil {
						return errE
					}
					zz = r
					// --- [end][read][struct](ResourceQuota) ---

				}
				m[vv] = zz
			}
			target.ResourceQuotas = m
			// --- [end][read][map](map[string]*ResourceQuota) ---

		}

	} else {
		target.ResourceQuotas = nil
	}
	// field version check
	if uint8(2) <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.Services = nil
		} else {
			// --- [begin][read][map](map[string]*Service) ---
			t := buff.ReadInt() // map len
			s := make(map[string]*Service, t)
			for range t {
				var vvv string
				var w string
				if ctx.IsStringTable() {
					x := buff.ReadInt() // read string index
					w = ctx.Table.At(x)
				} else {
					w = buff.ReadString() // read string
				}
				u := w
				vvv = u

				var zzz *Service
				if buff.ReadUInt8() == uint8(0) {
					zzz = nil
				} else {
					// --- [begin][read][struct](Service) ---
					y := new(Service)
					buff.ReadInt() // [compatibility, unused]
					errF := y.UnmarshalBinaryWithContext(ctx)
					if errF != nil {
						return errF
					}
					zzz = y
					// --- [end][read][struct](Service) ---

				}
				s[vvv] = zzz
			}
			target.Services = s
			// --- [end][read][map](map[string]*Service) ---

		}

	} else {
		target.Services = nil
	}
	// field version check
	if uint8(2) <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.Deployments = nil
		} else {
			// --- [begin][read][map](map[string]*Deployment) ---
			bb := buff.ReadInt() // map len
			aa := make(map[string]*Deployment, bb)
			for range bb {
				var vvvv string
				var dd string
				if ctx.IsStringTable() {
					ee := buff.ReadInt() // read string index
					dd = ctx.Table.At(ee)
				} else {
					dd = buff.ReadString() // read string
				}
				cc := dd
				vvvv = cc

				var zzzz *Deployment
				if buff.ReadUInt8() == uint8(0) {
					zzzz = nil
				} else {
					// --- [begin][read][struct](Deployment) ---
					ff := new(Deployment)
					buff.ReadInt() // [compatibility, unused]
					errG := ff.UnmarshalBinaryWithContext(ctx)
					if errG != nil {
						return errG
					}
					zzzz = ff
					// --- [end][read][struct](Deployment) ---

				}
				aa[vvvv] = zzzz
			}
			target.Deployments = aa
			// --- [end][read][map](map[string]*Deployment) ---

		}

	} else {
		target.Deployments = nil
	}
	// field version check
	if uint8(2) <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.StatefulSets = nil
		} else {
			// --- [begin][read][map](map[string]*StatefulSet) ---
			hh := buff.ReadInt() // map len
			gg := make(map[string]*StatefulSet, hh)
			for range hh {
				var vvvvv string
				var mm string
				if ctx.IsStringTable() {
					nn := buff.ReadInt() // read string index
					mm = ctx.Table.At(nn)
				} else {
					mm = buff.ReadString() // read string
				}
				ll := mm
				vvvvv = ll

				var zzzzz *StatefulSet
				if buff.ReadUInt8() == uint8(0) {
					zzzzz = nil
				} else {
					// --- [begin][read][struct](StatefulSet) ---
					oo := new(StatefulSet)
					buff.ReadInt() // [compatibility, unused]
					errH := oo.UnmarshalBinaryWithContext(ctx)
					if errH != nil {
						return errH
					}
					zzzzz = oo
					// --- [end][read][struct](StatefulSet) ---

				}
				gg[vvvvv] = zzzzz
			}
			target.StatefulSets = gg
			// --- [end][read][map](map[string]*StatefulSet) ---

		}

	} else {
		target.StatefulSets = nil
	}
	// field version check
	if uint8(2) <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.DaemonSets = nil
		} else {
			// --- [begin][read][map](map[string]*DaemonSet) ---
			qq := buff.ReadInt() // map len
			pp := make(map[string]*DaemonSet, qq)
			for range qq {
				var vvvvvv string
				var ss string
				if ctx.IsStringTable() {
					tt := buff.ReadInt() // read string index
					ss = ctx.Table.At(tt)
				} else {
					ss = buff.ReadString() // read string
				}
				rr := ss
				vvvvvv = rr

				var zzzzzz *DaemonSet
				if buff.ReadUInt8() == uint8(0) {
					zzzzzz = nil
				} else {

					// --- [begin][read][struct](DaemonSet) ---
					uu := new(DaemonSet)
					buff.ReadInt() // [compatibility, unused]
					errI := uu.UnmarshalBinaryWithContext(ctx)
					if errI != nil {
						return errI
					}
					zzzzzz = uu
					// --- [end][read][struct](DaemonSet) ---

				}
				pp[vvvvvv] = zzzzzz
			}
			target.DaemonSets = pp
			// --- [end][read][map](map[string]*DaemonSet) ---

		}

	} else {
		target.DaemonSets = nil
	}
	// field version check
	if uint8(2) <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.Jobs = nil
		} else {
			// --- [begin][read][map](map[string]*Job) ---
			xx := buff.ReadInt() // map len
			ww := make(map[string]*Job, xx)
			for range xx {
				var vvvvvvv string
				var aaa string
				if ctx.IsStringTable() {
					bbb := buff.ReadInt() // read string index
					aaa = ctx.Table.At(bbb)
				} else {
					aaa = buff.ReadString() // read string
				}
				yy := aaa
				vvvvvvv = yy

				var zzzzzzz *Job
				if buff.ReadUInt8() == uint8(0) {
					zzzzzzz = nil
				} else {
					// --- [begin][read][struct](Job) ---
					ccc := new(Job)
					buff.ReadInt() // [compatibility, unused]
					errJ := ccc.UnmarshalBinaryWithContext(ctx)
					if errJ != nil {
						return errJ
					}
					zzzzzzz = ccc
					// --- [end][read][struct](Job) ---

				}
				ww[vvvvvvv] = zzzzzzz
			}
			target.Jobs = ww
			// --- [end][read][map](map[string]*Job) ---

		}

	} else {
		target.Jobs = nil
	}
	// field version check
	if uint8(2) <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.CronJobs = nil
		} else {
			// --- [begin][read][map](map[string]*CronJob) ---
			eee := buff.ReadInt() // map len
			ddd := make(map[string]*CronJob, eee)
			for range eee {
				var vvvvvvvv string
				var ggg string
				if ctx.IsStringTable() {
					hhh := buff.ReadInt() // read string index
					ggg = ctx.Table.At(hhh)
				} else {
					ggg = buff.ReadString() // read string
				}
				fff := ggg
				vvvvvvvv = fff

				var zzzzzzzz *CronJob
				if buff.ReadUInt8() == uint8(0) {
					zzzzzzzz = nil
				} else {
					// --- [begin][read][struct](CronJob) ---
					lll := new(CronJob)
					buff.ReadInt() // [compatibility, unused]
					errK := lll.UnmarshalBinaryWithContext(ctx)
					if errK != nil {
						return errK
					}
					zzzzzzzz = lll
					// --- [end][read][struct](CronJob) ---

				}
				ddd[vvvvvvvv] = zzzzzzzz
			}
			target.CronJobs = ddd
			// --- [end][read][map](map[string]*CronJob) ---

		}

	} else {
		target.CronJobs = nil
	}
	// field version check
	if uint8(2) <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.ReplicaSets = nil
		} else {
			// --- [begin][read][map](map[string]*ReplicaSet) ---
			nnn := buff.ReadInt() // map len
			mmm := make(map[string]*ReplicaSet, nnn)
			for range nnn {
				var vvvvvvvvv string
				var ppp string
				if ctx.IsStringTable() {
					qqq := buff.ReadInt() // read string index
					ppp = ctx.Table.At(qqq)
				} else {
					ppp = buff.ReadString() // read string
				}
				ooo := ppp
				vvvvvvvvv = ooo

				var zzzzzzzzz *ReplicaSet
				if buff.ReadUInt8() == uint8(0) {
					zzzzzzzzz = nil
				} else {
					// --- [begin][read][struct](ReplicaSet) ---
					rrr := new(ReplicaSet)
					buff.ReadInt() // [compatibility, unused]
					errL := rrr.UnmarshalBinaryWithContext(ctx)
					if errL != nil {
						return errL
					}
					zzzzzzzzz = rrr
					// --- [end][read][struct](ReplicaSet) ---

				}
				mmm[vvvvvvvvv] = zzzzzzzzz
			}
			target.ReplicaSets = mmm
			// --- [end][read][map](map[string]*ReplicaSet) ---

		}

	} else {
		target.ReplicaSets = nil
	}
	// field version check
	if uint8(2) <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.Nodes = nil
		} else {
			// --- [begin][read][map](map[string]*Node) ---
			ttt := buff.ReadInt() // map len
			sss := make(map[string]*Node, ttt)
			for range ttt {
				var vvvvvvvvvv string
				var www string
				if ctx.IsStringTable() {
					xxx := buff.ReadInt() // read string index
					www = ctx.Table.At(xxx)
				} else {
					www = buff.ReadString() // read string
				}
				uuu := www
				vvvvvvvvvv = uuu

				var zzzzzzzzzz *Node
				if buff.ReadUInt8() == uint8(0) {
					zzzzzzzzzz = nil
				} else {
					// --- [begin][read][struct](Node) ---
					yyy := new(Node)
					buff.ReadInt() // [compatibility, unused]
					errM := yyy.UnmarshalBinaryWithContext(ctx)
					if errM != nil {
						return errM
					}
					zzzzzzzzzz = yyy
					// --- [end][read][struct](Node) ---

				}
				sss[vvvvvvvvvv] = zzzzzzzzzz
			}
			target.Nodes = sss
			// --- [end][read][map](map[string]*Node) ---

		}

	} else {
		target.Nodes = nil
	}
	// field version check
	if uint8(2) <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.PersistentVolumes = nil
		} else {
			// --- [begin][read][map](map[string]*PersistentVolume) ---
			bbbb := buff.ReadInt() // map len
			aaaa := make(map[string]*PersistentVolume, bbbb)
			for range bbbb {
				var vvvvvvvvvvv string
				var dddd string
				if ctx.IsStringTable() {
					eeee := buff.ReadInt() // read string index
					dddd = ctx.Table.At(eeee)
				} else {
					dddd = buff.ReadString() // read string
				}
				cccc := dddd
				vvvvvvvvvvv = cccc

				var zzzzzzzzzzz *PersistentVolume
				if buff.ReadUInt8() == uint8(0) {
					zzzzzzzzzzz = nil
				} else {

					// --- [begin][read][struct](PersistentVolume) ---
					ffff := new(PersistentVolume)
					buff.ReadInt() // [compatibility, unused]
					errN := ffff.UnmarshalBinaryWithContext(ctx)
					if errN != nil {
						return errN
					}
					zzzzzzzzzzz = ffff
					// --- [end][read][struct](PersistentVolume) ---

				}
				aaaa[vvvvvvvvvvv] = zzzzzzzzzzz
			}
			target.PersistentVolumes = aaaa
			// --- [end][read][map](map[string]*PersistentVolume) ---

		}

	} else {
		target.PersistentVolumes = nil
	}
	// field version check
	if uint8(2) <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.PersistentVolumeClaims = nil
		} else {
			// --- [begin][read][map](map[string]*PersistentVolumeClaim) ---
			hhhh := buff.ReadInt() // map len
			gggg := make(map[string]*PersistentVolumeClaim, hhhh)
			for range hhhh {
				var vvvvvvvvvvvv string
				var mmmm string
				if ctx.IsStringTable() {
					nnnn := buff.ReadInt() // read string index
					mmmm = ctx.Table.At(nnnn)
				} else {
					mmmm = buff.ReadString() // read string
				}
				llll := mmmm
				vvvvvvvvvvvv = llll

				var zzzzzzzzzzzz *PersistentVolumeClaim
				if buff.ReadUInt8() == uint8(0) {
					zzzzzzzzzzzz = nil
				} else {
					// --- [begin][read][struct](PersistentVolumeClaim) ---
					oooo := new(PersistentVolumeClaim)
					buff.ReadInt() // [compatibility, unused]
					errO := oooo.UnmarshalBinaryWithContext(ctx)
					if errO != nil {
						return errO
					}
					zzzzzzzzzzzz = oooo
					// --- [end][read][struct](PersistentVolumeClaim) ---

				}
				gggg[vvvvvvvvvvvv] = zzzzzzzzzzzz
			}
			target.PersistentVolumeClaims = gggg
			// --- [end][read][map](map[string]*PersistentVolumeClaim) ---

		}

	} else {
		target.PersistentVolumeClaims = nil
	}
	// field version check
	if uint8(2) <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.Pods = nil
		} else {
			// --- [begin][read][map](map[string]*Pod) ---
			qqqq := buff.ReadInt() // map len
			pppp := make(map[string]*Pod, qqqq)
			for range qqqq {
				var vvvvvvvvvvvvv string
				var ssss string
				if ctx.IsStringTable() {
					tttt := buff.ReadInt() // read string index
					ssss = ctx.Table.At(tttt)
				} else {
					ssss = buff.ReadString() // read string
				}
				rrrr := ssss
				vvvvvvvvvvvvv = rrrr

				var zzzzzzzzzzzzz *Pod
				if buff.ReadUInt8() == uint8(0) {
					zzzzzzzzzzzzz = nil
				} else {
					// --- [begin][read][struct](Pod) ---
					uuuu := new(Pod)
					buff.ReadInt() // [compatibility, unused]
					errP := uuuu.UnmarshalBinaryWithContext(ctx)
					if errP != nil {
						return errP
					}
					zzzzzzzzzzzzz = uuuu
					// --- [end][read][struct](Pod) ---

				}
				pppp[vvvvvvvvvvvvv] = zzzzzzzzzzzzz
			}
			target.Pods = pppp
			// --- [end][read][map](map[string]*Pod) ---

		}

	} else {
		target.Pods = nil
	}
	// field version check
	if uint8(2) <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.Containers = nil
		} else {
			// --- [begin][read][map](map[string]*Container) ---
			xxxx := buff.ReadInt() // map len
			wwww := make(map[string]*Container, xxxx)
			for range xxxx {
				var vvvvvvvvvvvvvv string
				var aaaaa string
				if ctx.IsStringTable() {
					bbbbb := buff.ReadInt() // read string index
					aaaaa = ctx.Table.At(bbbbb)
				} else {
					aaaaa = buff.ReadString() // read string
				}
				yyyy := aaaaa
				vvvvvvvvvvvvvv = yyyy

				var zzzzzzzzzzzzzz *Container
				if buff.ReadUInt8() == uint8(0) {
					zzzzzzzzzzzzzz = nil
				} else {

					// --- [begin][read][struct](Container) ---
					ccccc := new(Container)
					buff.ReadInt() // [compatibility, unused]
					errQ := ccccc.UnmarshalBinaryWithContext(ctx)
					if errQ != nil {
						return errQ
					}
					zzzzzzzzzzzzzz = ccccc
					// --- [end][read][struct](Container) ---

				}
				wwww[vvvvvvvvvvvvvv] = zzzzzzzzzzzzzz
			}
			target.Containers = wwww
			// --- [end][read][map](map[string]*Container) ---

		}

	} else {
		target.Containers = nil
	}
	// field version check
	if uint8(2) <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.DCGMDevices = nil
		} else {
			// --- [begin][read][map](map[string]*DCGMDevice) ---
			eeeee := buff.ReadInt() // map len
			ddddd := make(map[string]*DCGMDevice, eeeee)
			for range eeeee {
				var vvvvvvvvvvvvvvv string
				var ggggg string
				if ctx.IsStringTable() {
					hhhhh := buff.ReadInt() // read string index
					ggggg = ctx.Table.At(hhhhh)
				} else {
					ggggg = buff.ReadString() // read string
				}
				fffff := ggggg
				vvvvvvvvvvvvvvv = fffff

				var zzzzzzzzzzzzzzz *DCGMDevice
				if buff.ReadUInt8() == uint8(0) {
					zzzzzzzzzzzzzzz = nil
				} else {

					// --- [begin][read][struct](DCGMDevice) ---
					lllll := new(DCGMDevice)
					buff.ReadInt() // [compatibility, unused]
					errR := lllll.UnmarshalBinaryWithContext(ctx)
					if errR != nil {
						return errR
					}
					zzzzzzzzzzzzzzz = lllll
					// --- [end][read][struct](DCGMDevice) ---

				}
				ddddd[vvvvvvvvvvvvvvv] = zzzzzzzzzzzzzzz
			}
			target.DCGMDevices = ddddd
			// --- [end][read][map](map[string]*DCGMDevice) ---

		}

	} else {
		target.DCGMDevices = nil
	}

	return nil
}

//--------------------------------------------------------------------------
//  KubeModelSetStream
//--------------------------------------------------------------------------

// KubeModelSetStream is a single use field stream for the contents of an KubeModelSet instance. Instead of creating an instance and populating
// the fields on that instance, we provide a streaming iterator which yields (BingenFieldInfo, *BingenValue) tuples for each
// streamable element. All slices and maps will be flattened one depth and each element streamed individually.
type KubeModelSetStream struct {
	reader io.Reader
	ctx    *DecodingContext
	err    error
}

// Closes closes the internal io.Reader used to read and parse the KubeModelSet fields.
// This should be called once the stream is no longer needed.
func (stream *KubeModelSetStream) Close() {
	if closer, ok := stream.reader.(io.Closer); ok {
		closer.Close()
	}
	stream.ctx.Close()
}

// Error returns an error if one occurred during the process of streaming the KubeModelSet
// This can be checked after iterating through the Stream().
func (stream *KubeModelSetStream) Error() error {
	return stream.err
}

// NewKubeModelSetStream creates a new KubeModelSetStream, which uses the io.Reader data to stream all internal fields of an KubeModelSet instance
func NewKubeModelSetStream(reader io.Reader) BingenStream {
	ctx := NewDecodingContextFromReader(reader)

	return &KubeModelSetStream{
		ctx:    ctx,
		reader: reader,
	}
}

// Stream returns the iterator which will stream each field of the target type.
func (stream *KubeModelSetStream) Stream() iter.Seq2[BingenFieldInfo, *BingenValue] {
	return func(yield func(BingenFieldInfo, *BingenValue) bool) {
		var fi BingenFieldInfo

		ctx := stream.ctx
		buff := ctx.Buffer
		version := buff.ReadUInt8()

		if version > DefaultCodecVersion {
			stream.err = fmt.Errorf("Invalid Version Unmarshalling KubeModelSet. Expected %d or less, got %d", DefaultCodecVersion, version)
			return
		}

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[*Metadata](),
			Name: "Metadata",
		}
		// field version check
		if uint8(1) <= version {

			if buff.ReadUInt8() == uint8(0) {
				if !yield(fi, nil) {
					return
				}
			} else {

				// --- [begin][read][struct](Metadata) ---
				b := new(Metadata)
				buff.ReadInt() // [compatibility, unused]
				errA := b.UnmarshalBinaryWithContext(ctx)
				if errA != nil {
					stream.err = errA
					return

				}
				a := b
				// --- [end][read][struct](Metadata) ---
				if !yield(fi, singleV(a)) {
					return
				}

			}

		} else {

			if !yield(fi, nil) {
				return
			}
		}

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[Window](),
			Name: "Window",
		}
		// field version check
		if uint8(1) <= version {

			// --- [begin][read][struct](Window) ---
			d := new(Window)
			buff.ReadInt() // [compatibility, unused]
			errB := d.UnmarshalBinaryWithContext(ctx)
			if errB != nil {
				stream.err = errB
				return

			}
			c := *d
			// --- [end][read][struct](Window) ---
			if !yield(fi, singleV(c)) {
				return
			}

		} else {

		}

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[*Cluster](),
			Name: "Cluster",
		}
		// field version check
		if uint8(1) <= version {

			if buff.ReadUInt8() == uint8(0) {
				if !yield(fi, nil) {
					return
				}
			} else {

				// --- [begin][read][struct](Cluster) ---
				f := new(Cluster)
				buff.ReadInt() // [compatibility, unused]
				errC := f.UnmarshalBinaryWithContext(ctx)
				if errC != nil {
					stream.err = errC
					return

				}
				e := f
				// --- [end][read][struct](Cluster) ---
				if !yield(fi, singleV(e)) {
					return
				}

			}

		} else {

			if !yield(fi, nil) {
				return
			}
		}

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[map[string]*Namespace](),
			Name: "Namespaces",
		}
		// field version check
		if uint8(1) <= version {

			if buff.ReadUInt8() == uint8(0) {
				if !yield(fi, nil) {
					return
				}
			} else {
				// --- [begin][read][streaming-map](map[string]*Namespace) ---
				g := buff.ReadInt() // map len
				for range g {
					var v string
					var l string
					if ctx.IsStringTable() {
						m := buff.ReadInt() // read string index
						l = ctx.Table.At(m)
					} else {
						l = buff.ReadString() // read string
					}
					h := l
					v = h

					var z *Namespace
					if buff.ReadUInt8() == uint8(0) {
						z = nil
					} else {
						// --- [begin][read][struct](Namespace) ---
						n := new(Namespace)
						buff.ReadInt() // [compatibility, unused]
						errD := n.UnmarshalBinaryWithContext(ctx)
						if errD != nil {
							stream.err = errD
							return

						}
						z = n
						// --- [end][read][struct](Namespace) ---

					}

					if !yield(fi, pairV(v, z)) {
						return
					}
				}
				// --- [end][read][streaming-map](map[string]*Namespace) ---

			}

		} else {

			if !yield(fi, nil) {
				return
			}
		}

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[map[string]*ResourceQuota](),
			Name: "ResourceQuotas",
		}
		// field version check
		if uint8(1) <= version {

			if buff.ReadUInt8() == uint8(0) {
				if !yield(fi, nil) {
					return
				}
			} else {
				// --- [begin][read][streaming-map](map[string]*ResourceQuota) ---
				o := buff.ReadInt() // map len
				for range o {
					var vv string
					var q string
					if ctx.IsStringTable() {
						r := buff.ReadInt() // read string index
						q = ctx.Table.At(r)
					} else {
						q = buff.ReadString() // read string
					}
					p := q
					vv = p

					var zz *ResourceQuota
					if buff.ReadUInt8() == uint8(0) {
						zz = nil
					} else {
						// --- [begin][read][struct](ResourceQuota) ---
						s := new(ResourceQuota)
						buff.ReadInt() // [compatibility, unused]
						errE := s.UnmarshalBinaryWithContext(ctx)
						if errE != nil {
							stream.err = errE
							return

						}
						zz = s
						// --- [end][read][struct](ResourceQuota) ---

					}

					if !yield(fi, pairV(vv, zz)) {
						return
					}
				}
				// --- [end][read][streaming-map](map[string]*ResourceQuota) ---

			}

		} else {

			if !yield(fi, nil) {
				return
			}
		}

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[map[string]*Service](),
			Name: "Services",
		}
		// field version check
		if uint8(2) <= version {

			if buff.ReadUInt8() == uint8(0) {
				if !yield(fi, nil) {
					return
				}
			} else {
				// --- [begin][read][streaming-map](map[string]*Service) ---
				t := buff.ReadInt() // map len
				for range t {
					var vvv string
					var w string
					if ctx.IsStringTable() {
						x := buff.ReadInt() // read string index
						w = ctx.Table.At(x)
					} else {
						w = buff.ReadString() // read string
					}
					u := w
					vvv = u

					var zzz *Service
					if buff.ReadUInt8() == uint8(0) {
						zzz = nil
					} else {
						// --- [begin][read][struct](Service) ---
						y := new(Service)
						buff.ReadInt() // [compatibility, unused]
						errF := y.UnmarshalBinaryWithContext(ctx)
						if errF != nil {
							stream.err = errF
							return

						}
						zzz = y
						// --- [end][read][struct](Service) ---

					}

					if !yield(fi, pairV(vvv, zzz)) {
						return
					}
				}
				// --- [end][read][streaming-map](map[string]*Service) ---

			}

		} else {

			if !yield(fi, nil) {
				return
			}
		}

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[map[string]*Deployment](),
			Name: "Deployments",
		}
		// field version check
		if uint8(2) <= version {

			if buff.ReadUInt8() == uint8(0) {
				if !yield(fi, nil) {
					return
				}
			} else {
				// --- [begin][read][streaming-map](map[string]*Deployment) ---
				aa := buff.ReadInt() // map len
				for range aa {
					var vvvv string
					var cc string
					if ctx.IsStringTable() {
						dd := buff.ReadInt() // read string index
						cc = ctx.Table.At(dd)
					} else {
						cc = buff.ReadString() // read string
					}
					bb := cc
					vvvv = bb

					var zzzz *Deployment
					if buff.ReadUInt8() == uint8(0) {
						zzzz = nil
					} else {
						// --- [begin][read][struct](Deployment) ---
						ee := new(Deployment)
						buff.ReadInt() // [compatibility, unused]
						errG := ee.UnmarshalBinaryWithContext(ctx)
						if errG != nil {
							stream.err = errG
							return

						}
						zzzz = ee
						// --- [end][read][struct](Deployment) ---

					}

					if !yield(fi, pairV(vvvv, zzzz)) {
						return
					}
				}
				// --- [end][read][streaming-map](map[string]*Deployment) ---

			}

		} else {

			if !yield(fi, nil) {
				return
			}
		}

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[map[string]*StatefulSet](),
			Name: "StatefulSets",
		}
		// field version check
		if uint8(2) <= version {

			if buff.ReadUInt8() == uint8(0) {
				if !yield(fi, nil) {
					return
				}
			} else {
				// --- [begin][read][streaming-map](map[string]*StatefulSet) ---
				ff := buff.ReadInt() // map len
				for range ff {
					var vvvvv string
					var hh string
					if ctx.IsStringTable() {
						ll := buff.ReadInt() // read string index
						hh = ctx.Table.At(ll)
					} else {
						hh = buff.ReadString() // read string
					}
					gg := hh
					vvvvv = gg

					var zzzzz *StatefulSet
					if buff.ReadUInt8() == uint8(0) {
						zzzzz = nil
					} else {
						// --- [begin][read][struct](StatefulSet) ---
						mm := new(StatefulSet)
						buff.ReadInt() // [compatibility, unused]
						errH := mm.UnmarshalBinaryWithContext(ctx)
						if errH != nil {
							stream.err = errH
							return

						}
						zzzzz = mm
						// --- [end][read][struct](StatefulSet) ---

					}

					if !yield(fi, pairV(vvvvv, zzzzz)) {
						return
					}
				}
				// --- [end][read][streaming-map](map[string]*StatefulSet) ---

			}

		} else {

			if !yield(fi, nil) {
				return
			}
		}

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[map[string]*DaemonSet](),
			Name: "DaemonSets",
		}
		// field version check
		if uint8(2) <= version {

			if buff.ReadUInt8() == uint8(0) {
				if !yield(fi, nil) {
					return
				}
			} else {
				// --- [begin][read][streaming-map](map[string]*DaemonSet) ---
				nn := buff.ReadInt() // map len
				for range nn {
					var vvvvvv string
					var pp string
					if ctx.IsStringTable() {
						qq := buff.ReadInt() // read string index
						pp = ctx.Table.At(qq)
					} else {
						pp = buff.ReadString() // read string
					}
					oo := pp
					vvvvvv = oo

					var zzzzzz *DaemonSet
					if buff.ReadUInt8() == uint8(0) {
						zzzzzz = nil
					} else {

						// --- [begin][read][struct](DaemonSet) ---
						rr := new(DaemonSet)
						buff.ReadInt() // [compatibility, unused]
						errI := rr.UnmarshalBinaryWithContext(ctx)
						if errI != nil {
							stream.err = errI
							return

						}
						zzzzzz = rr
						// --- [end][read][struct](DaemonSet) ---

					}

					if !yield(fi, pairV(vvvvvv, zzzzzz)) {
						return
					}
				}
				// --- [end][read][streaming-map](map[string]*DaemonSet) ---

			}

		} else {

			if !yield(fi, nil) {
				return
			}
		}

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[map[string]*Job](),
			Name: "Jobs",
		}
		// field version check
		if uint8(2) <= version {

			if buff.ReadUInt8() == uint8(0) {
				if !yield(fi, nil) {
					return
				}
			} else {
				// --- [begin][read][streaming-map](map[string]*Job) ---
				ss := buff.ReadInt() // map len
				for range ss {
					var vvvvvvv string
					var uu string
					if ctx.IsStringTable() {
						ww := buff.ReadInt() // read string index
						uu = ctx.Table.At(ww)
					} else {
						uu = buff.ReadString() // read string
					}
					tt := uu
					vvvvvvv = tt

					var zzzzzzz *Job
					if buff.ReadUInt8() == uint8(0) {
						zzzzzzz = nil
					} else {
						// --- [begin][read][struct](Job) ---
						xx := new(Job)
						buff.ReadInt() // [compatibility, unused]
						errJ := xx.UnmarshalBinaryWithContext(ctx)
						if errJ != nil {
							stream.err = errJ
							return

						}
						zzzzzzz = xx
						// --- [end][read][struct](Job) ---

					}

					if !yield(fi, pairV(vvvvvvv, zzzzzzz)) {
						return
					}
				}
				// --- [end][read][streaming-map](map[string]*Job) ---

			}

		} else {

			if !yield(fi, nil) {
				return
			}
		}

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[map[string]*CronJob](),
			Name: "CronJobs",
		}
		// field version check
		if uint8(2) <= version {

			if buff.ReadUInt8() == uint8(0) {
				if !yield(fi, nil) {
					return
				}
			} else {
				// --- [begin][read][streaming-map](map[string]*CronJob) ---
				yy := buff.ReadInt() // map len
				for range yy {
					var vvvvvvvv string
					var bbb string
					if ctx.IsStringTable() {
						ccc := buff.ReadInt() // read string index
						bbb = ctx.Table.At(ccc)
					} else {
						bbb = buff.ReadString() // read string
					}
					aaa := bbb
					vvvvvvvv = aaa

					var zzzzzzzz *CronJob
					if buff.ReadUInt8() == uint8(0) {
						zzzzzzzz = nil
					} else {
						// --- [begin][read][struct](CronJob) ---
						ddd := new(CronJob)
						buff.ReadInt() // [compatibility, unused]
						errK := ddd.UnmarshalBinaryWithContext(ctx)
						if errK != nil {
							stream.err = errK
							return

						}
						zzzzzzzz = ddd
						// --- [end][read][struct](CronJob) ---

					}

					if !yield(fi, pairV(vvvvvvvv, zzzzzzzz)) {
						return
					}
				}
				// --- [end][read][streaming-map](map[string]*CronJob) ---

			}

		} else {

			if !yield(fi, nil) {
				return
			}
		}

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[map[string]*ReplicaSet](),
			Name: "ReplicaSets",
		}
		// field version check
		if uint8(2) <= version {

			if buff.ReadUInt8() == uint8(0) {
				if !yield(fi, nil) {
					return
				}
			} else {
				// --- [begin][read][streaming-map](map[string]*ReplicaSet) ---
				eee := buff.ReadInt() // map len
				for range eee {
					var vvvvvvvvv string
					var ggg string
					if ctx.IsStringTable() {
						hhh := buff.ReadInt() // read string index
						ggg = ctx.Table.At(hhh)
					} else {
						ggg = buff.ReadString() // read string
					}
					fff := ggg
					vvvvvvvvv = fff

					var zzzzzzzzz *ReplicaSet
					if buff.ReadUInt8() == uint8(0) {
						zzzzzzzzz = nil
					} else {
						// --- [begin][read][struct](ReplicaSet) ---
						lll := new(ReplicaSet)
						buff.ReadInt() // [compatibility, unused]
						errL := lll.UnmarshalBinaryWithContext(ctx)
						if errL != nil {
							stream.err = errL
							return

						}
						zzzzzzzzz = lll
						// --- [end][read][struct](ReplicaSet) ---

					}

					if !yield(fi, pairV(vvvvvvvvv, zzzzzzzzz)) {
						return
					}
				}
				// --- [end][read][streaming-map](map[string]*ReplicaSet) ---

			}

		} else {

			if !yield(fi, nil) {
				return
			}
		}

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[map[string]*Node](),
			Name: "Nodes",
		}
		// field version check
		if uint8(2) <= version {

			if buff.ReadUInt8() == uint8(0) {
				if !yield(fi, nil) {
					return
				}
			} else {
				// --- [begin][read][streaming-map](map[string]*Node) ---
				mmm := buff.ReadInt() // map len
				for range mmm {
					var vvvvvvvvvv string
					var ooo string
					if ctx.IsStringTable() {
						ppp := buff.ReadInt() // read string index
						ooo = ctx.Table.At(ppp)
					} else {
						ooo = buff.ReadString() // read string
					}
					nnn := ooo
					vvvvvvvvvv = nnn

					var zzzzzzzzzz *Node
					if buff.ReadUInt8() == uint8(0) {
						zzzzzzzzzz = nil
					} else {
						// --- [begin][read][struct](Node) ---
						qqq := new(Node)
						buff.ReadInt() // [compatibility, unused]
						errM := qqq.UnmarshalBinaryWithContext(ctx)
						if errM != nil {
							stream.err = errM
							return

						}
						zzzzzzzzzz = qqq
						// --- [end][read][struct](Node) ---

					}

					if !yield(fi, pairV(vvvvvvvvvv, zzzzzzzzzz)) {
						return
					}
				}
				// --- [end][read][streaming-map](map[string]*Node) ---

			}

		} else {

			if !yield(fi, nil) {
				return
			}
		}

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[map[string]*PersistentVolume](),
			Name: "PersistentVolumes",
		}
		// field version check
		if uint8(2) <= version {

			if buff.ReadUInt8() == uint8(0) {
				if !yield(fi, nil) {
					return
				}
			} else {
				// --- [begin][read][streaming-map](map[string]*PersistentVolume) ---
				rrr := buff.ReadInt() // map len
				for range rrr {
					var vvvvvvvvvvv string
					var ttt string
					if ctx.IsStringTable() {
						uuu := buff.ReadInt() // read string index
						ttt = ctx.Table.At(uuu)
					} else {
						ttt = buff.ReadString() // read string
					}
					sss := ttt
					vvvvvvvvvvv = sss

					var zzzzzzzzzzz *PersistentVolume
					if buff.ReadUInt8() == uint8(0) {
						zzzzzzzzzzz = nil
					} else {

						// --- [begin][read][struct](PersistentVolume) ---
						www := new(PersistentVolume)
						buff.ReadInt() // [compatibility, unused]
						errN := www.UnmarshalBinaryWithContext(ctx)
						if errN != nil {
							stream.err = errN
							return

						}
						zzzzzzzzzzz = www
						// --- [end][read][struct](PersistentVolume) ---

					}

					if !yield(fi, pairV(vvvvvvvvvvv, zzzzzzzzzzz)) {
						return
					}
				}
				// --- [end][read][streaming-map](map[string]*PersistentVolume) ---

			}

		} else {

			if !yield(fi, nil) {
				return
			}
		}

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[map[string]*PersistentVolumeClaim](),
			Name: "PersistentVolumeClaims",
		}
		// field version check
		if uint8(2) <= version {

			if buff.ReadUInt8() == uint8(0) {
				if !yield(fi, nil) {
					return
				}
			} else {
				// --- [begin][read][streaming-map](map[string]*PersistentVolumeClaim) ---
				xxx := buff.ReadInt() // map len
				for range xxx {
					var vvvvvvvvvvvv string
					var aaaa string
					if ctx.IsStringTable() {
						bbbb := buff.ReadInt() // read string index
						aaaa = ctx.Table.At(bbbb)
					} else {
						aaaa = buff.ReadString() // read string
					}
					yyy := aaaa
					vvvvvvvvvvvv = yyy

					var zzzzzzzzzzzz *PersistentVolumeClaim
					if buff.ReadUInt8() == uint8(0) {
						zzzzzzzzzzzz = nil
					} else {
						// --- [begin][read][struct](PersistentVolumeClaim) ---
						cccc := new(PersistentVolumeClaim)
						buff.ReadInt() // [compatibility, unused]
						errO := cccc.UnmarshalBinaryWithContext(ctx)
						if errO != nil {
							stream.err = errO
							return

						}
						zzzzzzzzzzzz = cccc
						// --- [end][read][struct](PersistentVolumeClaim) ---

					}

					if !yield(fi, pairV(vvvvvvvvvvvv, zzzzzzzzzzzz)) {
						return
					}
				}
				// --- [end][read][streaming-map](map[string]*PersistentVolumeClaim) ---

			}

		} else {

			if !yield(fi, nil) {
				return
			}
		}

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[map[string]*Pod](),
			Name: "Pods",
		}
		// field version check
		if uint8(2) <= version {

			if buff.ReadUInt8() == uint8(0) {
				if !yield(fi, nil) {
					return
				}
			} else {
				// --- [begin][read][streaming-map](map[string]*Pod) ---
				dddd := buff.ReadInt() // map len
				for range dddd {
					var vvvvvvvvvvvvv string
					var ffff string
					if ctx.IsStringTable() {
						gggg := buff.ReadInt() // read string index
						ffff = ctx.Table.At(gggg)
					} else {
						ffff = buff.ReadString() // read string
					}
					eeee := ffff
					vvvvvvvvvvvvv = eeee

					var zzzzzzzzzzzzz *Pod
					if buff.ReadUInt8() == uint8(0) {
						zzzzzzzzzzzzz = nil
					} else {
						// --- [begin][read][struct](Pod) ---
						hhhh := new(Pod)
						buff.ReadInt() // [compatibility, unused]
						errP := hhhh.UnmarshalBinaryWithContext(ctx)
						if errP != nil {
							stream.err = errP
							return

						}
						zzzzzzzzzzzzz = hhhh
						// --- [end][read][struct](Pod) ---

					}

					if !yield(fi, pairV(vvvvvvvvvvvvv, zzzzzzzzzzzzz)) {
						return
					}
				}
				// --- [end][read][streaming-map](map[string]*Pod) ---

			}

		} else {

			if !yield(fi, nil) {
				return
			}
		}

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[map[string]*Container](),
			Name: "Containers",
		}
		// field version check
		if uint8(2) <= version {

			if buff.ReadUInt8() == uint8(0) {
				if !yield(fi, nil) {
					return
				}
			} else {
				// --- [begin][read][streaming-map](map[string]*Container) ---
				llll := buff.ReadInt() // map len
				for range llll {
					var vvvvvvvvvvvvvv string
					var nnnn string
					if ctx.IsStringTable() {
						oooo := buff.ReadInt() // read string index
						nnnn = ctx.Table.At(oooo)
					} else {
						nnnn = buff.ReadString() // read string
					}
					mmmm := nnnn
					vvvvvvvvvvvvvv = mmmm

					var zzzzzzzzzzzzzz *Container
					if buff.ReadUInt8() == uint8(0) {
						zzzzzzzzzzzzzz = nil
					} else {

						// --- [begin][read][struct](Container) ---
						pppp := new(Container)
						buff.ReadInt() // [compatibility, unused]
						errQ := pppp.UnmarshalBinaryWithContext(ctx)
						if errQ != nil {
							stream.err = errQ
							return

						}
						zzzzzzzzzzzzzz = pppp
						// --- [end][read][struct](Container) ---

					}

					if !yield(fi, pairV(vvvvvvvvvvvvvv, zzzzzzzzzzzzzz)) {
						return
					}
				}
				// --- [end][read][streaming-map](map[string]*Container) ---

			}

		} else {

			if !yield(fi, nil) {
				return
			}
		}

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[map[string]*DCGMDevice](),
			Name: "DCGMDevices",
		}
		// field version check
		if uint8(2) <= version {

			if buff.ReadUInt8() == uint8(0) {
				if !yield(fi, nil) {
					return
				}
			} else {
				// --- [begin][read][streaming-map](map[string]*DCGMDevice) ---
				qqqq := buff.ReadInt() // map len
				for range qqqq {
					var vvvvvvvvvvvvvvv string
					var ssss string
					if ctx.IsStringTable() {
						tttt := buff.ReadInt() // read string index
						ssss = ctx.Table.At(tttt)
					} else {
						ssss = buff.ReadString() // read string
					}
					rrrr := ssss
					vvvvvvvvvvvvvvv = rrrr

					var zzzzzzzzzzzzzzz *DCGMDevice
					if buff.ReadUInt8() == uint8(0) {
						zzzzzzzzzzzzzzz = nil
					} else {

						// --- [begin][read][struct](DCGMDevice) ---
						uuuu := new(DCGMDevice)
						buff.ReadInt() // [compatibility, unused]
						errR := uuuu.UnmarshalBinaryWithContext(ctx)
						if errR != nil {
							stream.err = errR
							return

						}
						zzzzzzzzzzzzzzz = uuuu
						// --- [end][read][struct](DCGMDevice) ---

					}

					if !yield(fi, pairV(vvvvvvvvvvvvvvv, zzzzzzzzzzzzzzz)) {
						return
					}
				}
				// --- [end][read][streaming-map](map[string]*DCGMDevice) ---

			}

		} else {

			if !yield(fi, nil) {
				return
			}
		}
	}
}

//--------------------------------------------------------------------------
//  Metadata
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this Metadata instance
// into a byte array
func (target *Metadata) MarshalBinary() (data []byte, err error) {
	ctx := NewEncodingContext(nil)

	e := target.MarshalBinaryWithContext(ctx)
	if e != nil {
		return nil, e
	}

	return ctx.ToBytes(), nil
}

// MarshalBinary serializes the internal properties of this Metadata instance
// into an io.Writer.
func (target *Metadata) MarshalBinaryTo(writer io.Writer) error {
	buff := util.NewBufferFromWriter(writer)
	defer buff.Flush()

	ctx := NewEncodingContextFromBuffer(buff, nil)

	return target.MarshalBinaryWithContext(ctx)
}

// MarshalBinaryWithContext serializes the internal properties of this Metadata instance
// into a byte array leveraging a predefined context.
func (target *Metadata) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	buff.WriteUInt8(DefaultCodecVersion) // version

	// --- [begin][write][reference](time.Time) ---
	a, errA := target.CreatedAt.MarshalBinary()
	if errA != nil {
		return errA
	}
	buff.WriteInt(len(a))
	buff.WriteBytes(a)
	// --- [end][write][reference](time.Time) ---

	// --- [begin][write][reference](time.Time) ---
	b, errB := target.CompletedAt.MarshalBinary()
	if errB != nil {
		return errB
	}
	buff.WriteInt(len(b))
	buff.WriteBytes(b)
	// --- [end][write][reference](time.Time) ---

	buff.WriteInt(target.ObjectCount) // write int

	if target.Diagnostics == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][slice]([]Diagnostic) ---
		buff.WriteInt(len(target.Diagnostics)) // slice length
		for i := range target.Diagnostics {

			// --- [begin][write][struct](Diagnostic) ---
			buff.WriteInt(0) // [compatibility, unused]
			errC := target.Diagnostics[i].MarshalBinaryWithContext(ctx)
			if errC != nil {
				return errC
			}
			// --- [end][write][struct](Diagnostic) ---

		}
		// --- [end][write][slice]([]Diagnostic) ---

	}

	// --- [begin][write][alias](DiagnosticLevel) ---

	buff.WriteInt(int(target.DiagnosticLevel)) // write int

	// --- [end][write][alias](DiagnosticLevel) ---

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the Metadata type
func (target *Metadata) UnmarshalBinary(data []byte) error {
	ctx := NewDecodingContextFromBytes(data)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryFromReader uses the io.Reader data to set all the internal properties of
// the Metadata type
func (target *Metadata) UnmarshalBinaryFromReader(reader io.Reader) error {
	ctx := NewDecodingContextFromReader(reader)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
// the Metadata type
func (target *Metadata) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	version := buff.ReadUInt8()

	if version > DefaultCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling Metadata. Expected %d or less, got %d", DefaultCodecVersion, version)
	}

	// field version check
	if uint8(1) <= version {

		// --- [begin][read][reference](time.Time) ---
		a := new(time.Time)
		b := buff.ReadInt() // byte array length
		c := buff.ReadBytes(b)
		errA := a.UnmarshalBinary(c)
		if errA != nil {
			return errA
		}
		target.CreatedAt = *a
		// --- [end][read][reference](time.Time) ---

	} else {
	}
	// field version check
	if uint8(1) <= version {

		// --- [begin][read][reference](time.Time) ---
		d := new(time.Time)
		e := buff.ReadInt() // byte array length
		f := buff.ReadBytes(e)
		errB := d.UnmarshalBinary(f)
		if errB != nil {
			return errB
		}
		target.CompletedAt = *d
		// --- [end][read][reference](time.Time) ---

	} else {
	}
	// field version check
	if uint8(1) <= version {

		g := buff.ReadInt() // read int
		target.ObjectCount = g

	} else {
		target.ObjectCount = int(0) // default
	}
	// field version check
	if uint8(1) <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.Diagnostics = nil
		} else {
			// --- [begin][read][slice]([]Diagnostic) ---
			l := buff.ReadInt() // slice len
			h := make([]Diagnostic, l)
			for i := range l {

				// --- [begin][read][struct](Diagnostic) ---
				n := new(Diagnostic)
				buff.ReadInt() // [compatibility, unused]
				errC := n.UnmarshalBinaryWithContext(ctx)
				if errC != nil {
					return errC
				}
				m := *n
				// --- [end][read][struct](Diagnostic) ---

				h[i] = m
			}
			target.Diagnostics = h
			// --- [end][read][slice]([]Diagnostic) ---

		}

	} else {
		target.Diagnostics = nil
	}
	// field version check
	if uint8(1) <= version {

		// --- [begin][read][alias](DiagnosticLevel) ---
		var o int
		p := buff.ReadInt() // read int
		o = p

		target.DiagnosticLevel = DiagnosticLevel(o)
		// --- [end][read][alias](DiagnosticLevel) ---

	} else {
	}

	return nil
}

//--------------------------------------------------------------------------
//  Namespace
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this Namespace instance
// into a byte array
func (target *Namespace) MarshalBinary() (data []byte, err error) {
	ctx := NewEncodingContext(nil)

	e := target.MarshalBinaryWithContext(ctx)
	if e != nil {
		return nil, e
	}

	return ctx.ToBytes(), nil
}

// MarshalBinary serializes the internal properties of this Namespace instance
// into an io.Writer.
func (target *Namespace) MarshalBinaryTo(writer io.Writer) error {
	buff := util.NewBufferFromWriter(writer)
	defer buff.Flush()

	ctx := NewEncodingContextFromBuffer(buff, nil)

	return target.MarshalBinaryWithContext(ctx)
}

// MarshalBinaryWithContext serializes the internal properties of this Namespace instance
// into a byte array leveraging a predefined context.
func (target *Namespace) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	buff.WriteUInt8(DefaultCodecVersion) // version

	if ctx.IsStringTable() {
		a := ctx.Table.AddOrGet(target.UID)
		buff.WriteInt(a) // write table index
	} else {
		buff.WriteString(target.UID) // write string
	}

	if ctx.IsStringTable() {
		b := ctx.Table.AddOrGet(target.bingenPlaceHolder)
		buff.WriteInt(b) // write table index
	} else {
		buff.WriteString(target.bingenPlaceHolder) // write string
	}

	if ctx.IsStringTable() {
		c := ctx.Table.AddOrGet(target.Name)
		buff.WriteInt(c) // write table index
	} else {
		buff.WriteString(target.Name) // write string
	}

	if target.Labels == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]string) ---
		buff.WriteInt(len(target.Labels)) // map length
		for v, z := range target.Labels {
			if ctx.IsStringTable() {
				d := ctx.Table.AddOrGet(v)
				buff.WriteInt(d) // write table index
			} else {
				buff.WriteString(v) // write string
			}

			if ctx.IsStringTable() {
				e := ctx.Table.AddOrGet(z)
				buff.WriteInt(e) // write table index
			} else {
				buff.WriteString(z) // write string
			}

		}
		// --- [end][write][map](map[string]string) ---

	}
	if target.Annotations == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]string) ---
		buff.WriteInt(len(target.Annotations)) // map length
		for vv, zz := range target.Annotations {
			if ctx.IsStringTable() {
				f := ctx.Table.AddOrGet(vv)
				buff.WriteInt(f) // write table index
			} else {
				buff.WriteString(vv) // write string
			}

			if ctx.IsStringTable() {
				g := ctx.Table.AddOrGet(zz)
				buff.WriteInt(g) // write table index
			} else {
				buff.WriteString(zz) // write string
			}

		}
		// --- [end][write][map](map[string]string) ---

	}

	// --- [begin][write][reference](time.Time) ---
	h, errA := target.Start.MarshalBinary()
	if errA != nil {
		return errA
	}
	buff.WriteInt(len(h))
	buff.WriteBytes(h)
	// --- [end][write][reference](time.Time) ---

	// --- [begin][write][reference](time.Time) ---
	l, errB := target.End.MarshalBinary()
	if errB != nil {
		return errB
	}
	buff.WriteInt(len(l))
	buff.WriteBytes(l)
	// --- [end][write][reference](time.Time) ---

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the Namespace type
func (target *Namespace) UnmarshalBinary(data []byte) error {
	ctx := NewDecodingContextFromBytes(data)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryFromReader uses the io.Reader data to set all the internal properties of
// the Namespace type
func (target *Namespace) UnmarshalBinaryFromReader(reader io.Reader) error {
	ctx := NewDecodingContextFromReader(reader)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
// the Namespace type
func (target *Namespace) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	version := buff.ReadUInt8()

	if version > DefaultCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling Namespace. Expected %d or less, got %d", DefaultCodecVersion, version)
	}

	// field version check
	if uint8(1) <= version {

		var b string
		if ctx.IsStringTable() {
			c := buff.ReadInt() // read string index
			b = ctx.Table.At(c)
		} else {
			b = buff.ReadString() // read string
		}
		a := b
		target.UID = a

	} else {
		target.UID = "" // default
	}
	// field version check
	if uint8(1) <= version {

		var e string
		if ctx.IsStringTable() {
			f := buff.ReadInt() // read string index
			e = ctx.Table.At(f)
		} else {
			e = buff.ReadString() // read string
		}
		d := e
		target.bingenPlaceHolder = d

	} else {
		target.bingenPlaceHolder = "" // default
	}
	// field version check
	if uint8(1) <= version {

		var h string
		if ctx.IsStringTable() {
			l := buff.ReadInt() // read string index
			h = ctx.Table.At(l)
		} else {
			h = buff.ReadString() // read string
		}
		g := h
		target.Name = g

	} else {
		target.Name = "" // default
	}
	// field version check
	if uint8(1) <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.Labels = nil
		} else {
			// --- [begin][read][map](map[string]string) ---
			n := buff.ReadInt() // map len
			m := make(map[string]string, n)
			for range n {
				var v string
				var p string
				if ctx.IsStringTable() {
					q := buff.ReadInt() // read string index
					p = ctx.Table.At(q)
				} else {
					p = buff.ReadString() // read string
				}
				o := p
				v = o

				var z string
				var s string
				if ctx.IsStringTable() {
					t := buff.ReadInt() // read string index
					s = ctx.Table.At(t)
				} else {
					s = buff.ReadString() // read string
				}
				r := s
				z = r

				m[v] = z
			}
			target.Labels = m
			// --- [end][read][map](map[string]string) ---

		}

	} else {
		target.Labels = nil
	}
	// field version check
	if uint8(1) <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.Annotations = nil
		} else {
			// --- [begin][read][map](map[string]string) ---
			w := buff.ReadInt() // map len
			u := make(map[string]string, w)
			for range w {
				var vv string
				var y string
				if ctx.IsStringTable() {
					aa := buff.ReadInt() // read string index
					y = ctx.Table.At(aa)
				} else {
					y = buff.ReadString() // read string
				}
				x := y
				vv = x

				var zz string
				var cc string
				if ctx.IsStringTable() {
					dd := buff.ReadInt() // read string index
					cc = ctx.Table.At(dd)
				} else {
					cc = buff.ReadString() // read string
				}
				bb := cc
				zz = bb

				u[vv] = zz
			}
			target.Annotations = u
			// --- [end][read][map](map[string]string) ---

		}

	} else {
		target.Annotations = nil
	}
	// field version check
	if uint8(1) <= version {

		// --- [begin][read][reference](time.Time) ---
		ee := new(time.Time)
		ff := buff.ReadInt() // byte array length
		gg := buff.ReadBytes(ff)
		errA := ee.UnmarshalBinary(gg)
		if errA != nil {
			return errA
		}
		target.Start = *ee
		// --- [end][read][reference](time.Time) ---

	} else {
	}
	// field version check
	if uint8(1) <= version {

		// --- [begin][read][reference](time.Time) ---
		hh := new(time.Time)
		ll := buff.ReadInt() // byte array length
		mm := buff.ReadBytes(ll)
		errB := hh.UnmarshalBinary(mm)
		if errB != nil {
			return errB
		}
		target.End = *hh
		// --- [end][read][reference](time.Time) ---

	} else {
	}

	return nil
}

//--------------------------------------------------------------------------
//  NetworkTrafficDetail
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this NetworkTrafficDetail instance
// into a byte array
func (target *NetworkTrafficDetail) MarshalBinary() (data []byte, err error) {
	ctx := NewEncodingContext(nil)

	e := target.MarshalBinaryWithContext(ctx)
	if e != nil {
		return nil, e
	}

	return ctx.ToBytes(), nil
}

// MarshalBinary serializes the internal properties of this NetworkTrafficDetail instance
// into an io.Writer.
func (target *NetworkTrafficDetail) MarshalBinaryTo(writer io.Writer) error {
	buff := util.NewBufferFromWriter(writer)
	defer buff.Flush()

	ctx := NewEncodingContextFromBuffer(buff, nil)

	return target.MarshalBinaryWithContext(ctx)
}

// MarshalBinaryWithContext serializes the internal properties of this NetworkTrafficDetail instance
// into a byte array leveraging a predefined context.
func (target *NetworkTrafficDetail) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	buff.WriteUInt8(DefaultCodecVersion) // version

	if ctx.IsStringTable() {
		a := ctx.Table.AddOrGet(target.PodUID)
		buff.WriteInt(a) // write table index
	} else {
		buff.WriteString(target.PodUID) // write string
	}

	if ctx.IsStringTable() {
		b := ctx.Table.AddOrGet(target.Endpoint)
		buff.WriteInt(b) // write table index
	} else {
		buff.WriteString(target.Endpoint) // write string
	}

	// --- [begin][write][alias](TrafficDirection) ---

	if ctx.IsStringTable() {
		c := ctx.Table.AddOrGet(string(target.TrafficDirection))
		buff.WriteInt(c) // write table index
	} else {
		buff.WriteString(string(target.TrafficDirection)) // write string
	}

	// --- [end][write][alias](TrafficDirection) ---

	// --- [begin][write][alias](TrafficType) ---

	if ctx.IsStringTable() {
		d := ctx.Table.AddOrGet(string(target.TrafficType))
		buff.WriteInt(d) // write table index
	} else {
		buff.WriteString(string(target.TrafficType)) // write string
	}

	// --- [end][write][alias](TrafficType) ---

	buff.WriteBool(target.IsNatGateway) // write bool

	buff.WriteFloat64(target.Bytes) // write float64

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the NetworkTrafficDetail type
func (target *NetworkTrafficDetail) UnmarshalBinary(data []byte) error {
	ctx := NewDecodingContextFromBytes(data)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryFromReader uses the io.Reader data to set all the internal properties of
// the NetworkTrafficDetail type
func (target *NetworkTrafficDetail) UnmarshalBinaryFromReader(reader io.Reader) error {
	ctx := NewDecodingContextFromReader(reader)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
// the NetworkTrafficDetail type
func (target *NetworkTrafficDetail) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	version := buff.ReadUInt8()

	if version > DefaultCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling NetworkTrafficDetail. Expected %d or less, got %d", DefaultCodecVersion, version)
	}

	var b string
	if ctx.IsStringTable() {
		c := buff.ReadInt() // read string index
		b = ctx.Table.At(c)
	} else {
		b = buff.ReadString() // read string
	}
	a := b
	target.PodUID = a

	var e string
	if ctx.IsStringTable() {
		f := buff.ReadInt() // read string index
		e = ctx.Table.At(f)
	} else {
		e = buff.ReadString() // read string
	}
	d := e
	target.Endpoint = d

	// --- [begin][read][alias](TrafficDirection) ---
	var g string
	var l string
	if ctx.IsStringTable() {
		m := buff.ReadInt() // read string index
		l = ctx.Table.At(m)
	} else {
		l = buff.ReadString() // read string
	}
	h := l
	g = h

	target.TrafficDirection = TrafficDirection(g)
	// --- [end][read][alias](TrafficDirection) ---

	// --- [begin][read][alias](TrafficType) ---
	var n string
	var p string
	if ctx.IsStringTable() {
		q := buff.ReadInt() // read string index
		p = ctx.Table.At(q)
	} else {
		p = buff.ReadString() // read string
	}
	o := p
	n = o

	target.TrafficType = TrafficType(n)
	// --- [end][read][alias](TrafficType) ---

	r := buff.ReadBool() // read bool
	target.IsNatGateway = r

	s := buff.ReadFloat64() // read float64
	target.Bytes = s

	return nil
}

//--------------------------------------------------------------------------
//  Node
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this Node instance
// into a byte array
func (target *Node) MarshalBinary() (data []byte, err error) {
	ctx := NewEncodingContext(nil)

	e := target.MarshalBinaryWithContext(ctx)
	if e != nil {
		return nil, e
	}

	return ctx.ToBytes(), nil
}

// MarshalBinary serializes the internal properties of this Node instance
// into an io.Writer.
func (target *Node) MarshalBinaryTo(writer io.Writer) error {
	buff := util.NewBufferFromWriter(writer)
	defer buff.Flush()

	ctx := NewEncodingContextFromBuffer(buff, nil)

	return target.MarshalBinaryWithContext(ctx)
}

// MarshalBinaryWithContext serializes the internal properties of this Node instance
// into a byte array leveraging a predefined context.
func (target *Node) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	buff.WriteUInt8(DefaultCodecVersion) // version

	if ctx.IsStringTable() {
		a := ctx.Table.AddOrGet(target.UID)
		buff.WriteInt(a) // write table index
	} else {
		buff.WriteString(target.UID) // write string
	}

	if ctx.IsStringTable() {
		b := ctx.Table.AddOrGet(target.ProviderID)
		buff.WriteInt(b) // write table index
	} else {
		buff.WriteString(target.ProviderID) // write string
	}

	if ctx.IsStringTable() {
		c := ctx.Table.AddOrGet(target.Name)
		buff.WriteInt(c) // write table index
	} else {
		buff.WriteString(target.Name) // write string
	}

	if target.Labels == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]string) ---
		buff.WriteInt(len(target.Labels)) // map length
		for v, z := range target.Labels {
			if ctx.IsStringTable() {
				d := ctx.Table.AddOrGet(v)
				buff.WriteInt(d) // write table index
			} else {
				buff.WriteString(v) // write string
			}

			if ctx.IsStringTable() {
				e := ctx.Table.AddOrGet(z)
				buff.WriteInt(e) // write table index
			} else {
				buff.WriteString(z) // write string
			}

		}
		// --- [end][write][map](map[string]string) ---

	}

	// --- [begin][write][alias](ResourceQuantities) ---
	if map[Resource]ResourceQuantity(target.ResourceCapacities) == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[Resource]ResourceQuantity) ---
		buff.WriteInt(len(map[Resource]ResourceQuantity(target.ResourceCapacities))) // map length
		for vv, zz := range map[Resource]ResourceQuantity(target.ResourceCapacities) {
			// --- [begin][write][alias](Resource) ---

			if ctx.IsStringTable() {
				f := ctx.Table.AddOrGet(string(vv))
				buff.WriteInt(f) // write table index
			} else {
				buff.WriteString(string(vv)) // write string
			}

			// --- [end][write][alias](Resource) ---
			// --- [begin][write][struct](ResourceQuantity) ---
			buff.WriteInt(0) // [compatibility, unused]
			errA := zz.MarshalBinaryWithContext(ctx)
			if errA != nil {
				return errA
			}
			// --- [end][write][struct](ResourceQuantity) ---

		}
		// --- [end][write][map](map[Resource]ResourceQuantity) ---

	}
	// --- [end][write][alias](ResourceQuantities) ---

	// --- [begin][write][alias](ResourceQuantities) ---
	if map[Resource]ResourceQuantity(target.ResourcesAllocatable) == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[Resource]ResourceQuantity) ---
		buff.WriteInt(len(map[Resource]ResourceQuantity(target.ResourcesAllocatable))) // map length
		for vvv, zzz := range map[Resource]ResourceQuantity(target.ResourcesAllocatable) {
			// --- [begin][write][alias](Resource) ---

			if ctx.IsStringTable() {
				g := ctx.Table.AddOrGet(string(vvv))
				buff.WriteInt(g) // write table index
			} else {
				buff.WriteString(string(vvv)) // write string
			}

			// --- [end][write][alias](Resource) ---
			// --- [begin][write][struct](ResourceQuantity) ---
			buff.WriteInt(0) // [compatibility, unused]
			errB := zzz.MarshalBinaryWithContext(ctx)
			if errB != nil {
				return errB
			}
			// --- [end][write][struct](ResourceQuantity) ---

		}
		// --- [end][write][map](map[Resource]ResourceQuantity) ---

	}
	// --- [end][write][alias](ResourceQuantities) ---

	// --- [begin][write][struct](FileSystem) ---
	buff.WriteInt(0) // [compatibility, unused]
	errC := target.FileSystem.MarshalBinaryWithContext(ctx)
	if errC != nil {
		return errC
	}
	// --- [end][write][struct](FileSystem) ---

	// --- [begin][write][reference](time.Time) ---
	h, errD := target.Start.MarshalBinary()
	if errD != nil {
		return errD
	}
	buff.WriteInt(len(h))
	buff.WriteBytes(h)
	// --- [end][write][reference](time.Time) ---

	// --- [begin][write][reference](time.Time) ---
	l, errE := target.End.MarshalBinary()
	if errE != nil {
		return errE
	}
	buff.WriteInt(len(l))
	buff.WriteBytes(l)
	// --- [end][write][reference](time.Time) ---

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the Node type
func (target *Node) UnmarshalBinary(data []byte) error {
	ctx := NewDecodingContextFromBytes(data)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryFromReader uses the io.Reader data to set all the internal properties of
// the Node type
func (target *Node) UnmarshalBinaryFromReader(reader io.Reader) error {
	ctx := NewDecodingContextFromReader(reader)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
// the Node type
func (target *Node) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	version := buff.ReadUInt8()

	if version > DefaultCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling Node. Expected %d or less, got %d", DefaultCodecVersion, version)
	}

	var b string
	if ctx.IsStringTable() {
		c := buff.ReadInt() // read string index
		b = ctx.Table.At(c)
	} else {
		b = buff.ReadString() // read string
	}
	a := b
	target.UID = a

	var e string
	if ctx.IsStringTable() {
		f := buff.ReadInt() // read string index
		e = ctx.Table.At(f)
	} else {
		e = buff.ReadString() // read string
	}
	d := e
	target.ProviderID = d

	var h string
	if ctx.IsStringTable() {
		l := buff.ReadInt() // read string index
		h = ctx.Table.At(l)
	} else {
		h = buff.ReadString() // read string
	}
	g := h
	target.Name = g

	if buff.ReadUInt8() == uint8(0) {
		target.Labels = nil
	} else {
		// --- [begin][read][map](map[string]string) ---
		n := buff.ReadInt() // map len
		m := make(map[string]string, n)
		for range n {
			var v string
			var p string
			if ctx.IsStringTable() {
				q := buff.ReadInt() // read string index
				p = ctx.Table.At(q)
			} else {
				p = buff.ReadString() // read string
			}
			o := p
			v = o

			var z string
			var s string
			if ctx.IsStringTable() {
				t := buff.ReadInt() // read string index
				s = ctx.Table.At(t)
			} else {
				s = buff.ReadString() // read string
			}
			r := s
			z = r

			m[v] = z
		}
		target.Labels = m
		// --- [end][read][map](map[string]string) ---

	}

	// --- [begin][read][alias](ResourceQuantities) ---
	var u map[Resource]ResourceQuantity
	if buff.ReadUInt8() == uint8(0) {
		u = nil
	} else {
		// --- [begin][read][map](map[Resource]ResourceQuantity) ---
		x := buff.ReadInt() // map len
		w := make(map[Resource]ResourceQuantity, x)
		for range x {
			// --- [begin][read][alias](Resource) ---
			var y string
			var bb string
			if ctx.IsStringTable() {
				cc := buff.ReadInt() // read string index
				bb = ctx.Table.At(cc)
			} else {
				bb = buff.ReadString() // read string
			}
			aa := bb
			y = aa

			vv := Resource(y)
			// --- [end][read][alias](Resource) ---

			// --- [begin][read][struct](ResourceQuantity) ---
			dd := new(ResourceQuantity)
			buff.ReadInt() // [compatibility, unused]
			errA := dd.UnmarshalBinaryWithContext(ctx)
			if errA != nil {
				return errA
			}
			zz := *dd
			// --- [end][read][struct](ResourceQuantity) ---

			w[vv] = zz
		}
		u = w
		// --- [end][read][map](map[Resource]ResourceQuantity) ---

	}

	target.ResourceCapacities = ResourceQuantities(u)
	// --- [end][read][alias](ResourceQuantities) ---

	// --- [begin][read][alias](ResourceQuantities) ---
	var ee map[Resource]ResourceQuantity
	if buff.ReadUInt8() == uint8(0) {
		ee = nil
	} else {
		// --- [begin][read][map](map[Resource]ResourceQuantity) ---
		gg := buff.ReadInt() // map len
		ff := make(map[Resource]ResourceQuantity, gg)
		for range gg {
			// --- [begin][read][alias](Resource) ---
			var hh string
			var mm string
			if ctx.IsStringTable() {
				nn := buff.ReadInt() // read string index
				mm = ctx.Table.At(nn)
			} else {
				mm = buff.ReadString() // read string
			}
			ll := mm
			hh = ll

			vvv := Resource(hh)
			// --- [end][read][alias](Resource) ---

			// --- [begin][read][struct](ResourceQuantity) ---
			oo := new(ResourceQuantity)
			buff.ReadInt() // [compatibility, unused]
			errB := oo.UnmarshalBinaryWithContext(ctx)
			if errB != nil {
				return errB
			}
			zzz := *oo
			// --- [end][read][struct](ResourceQuantity) ---

			ff[vvv] = zzz
		}
		ee = ff
		// --- [end][read][map](map[Resource]ResourceQuantity) ---

	}

	target.ResourcesAllocatable = ResourceQuantities(ee)
	// --- [end][read][alias](ResourceQuantities) ---

	// --- [begin][read][struct](FileSystem) ---
	pp := new(FileSystem)
	buff.ReadInt() // [compatibility, unused]
	errC := pp.UnmarshalBinaryWithContext(ctx)
	if errC != nil {
		return errC
	}
	target.FileSystem = *pp
	// --- [end][read][struct](FileSystem) ---

	// --- [begin][read][reference](time.Time) ---
	qq := new(time.Time)
	rr := buff.ReadInt() // byte array length
	ss := buff.ReadBytes(rr)
	errD := qq.UnmarshalBinary(ss)
	if errD != nil {
		return errD
	}
	target.Start = *qq
	// --- [end][read][reference](time.Time) ---

	// --- [begin][read][reference](time.Time) ---
	tt := new(time.Time)
	uu := buff.ReadInt() // byte array length
	ww := buff.ReadBytes(uu)
	errE := tt.UnmarshalBinary(ww)
	if errE != nil {
		return errE
	}
	target.End = *tt
	// --- [end][read][reference](time.Time) ---

	return nil
}

//--------------------------------------------------------------------------
//  Owner
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this Owner instance
// into a byte array
func (target *Owner) MarshalBinary() (data []byte, err error) {
	ctx := NewEncodingContext(nil)

	e := target.MarshalBinaryWithContext(ctx)
	if e != nil {
		return nil, e
	}

	return ctx.ToBytes(), nil
}

// MarshalBinary serializes the internal properties of this Owner instance
// into an io.Writer.
func (target *Owner) MarshalBinaryTo(writer io.Writer) error {
	buff := util.NewBufferFromWriter(writer)
	defer buff.Flush()

	ctx := NewEncodingContextFromBuffer(buff, nil)

	return target.MarshalBinaryWithContext(ctx)
}

// MarshalBinaryWithContext serializes the internal properties of this Owner instance
// into a byte array leveraging a predefined context.
func (target *Owner) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	buff.WriteUInt8(DefaultCodecVersion) // version

	if ctx.IsStringTable() {
		a := ctx.Table.AddOrGet(target.UID)
		buff.WriteInt(a) // write table index
	} else {
		buff.WriteString(target.UID) // write string
	}

	buff.WriteBool(target.Controller) // write bool

	// --- [begin][write][alias](OwnerKind) ---

	if ctx.IsStringTable() {
		b := ctx.Table.AddOrGet(string(target.Kind))
		buff.WriteInt(b) // write table index
	} else {
		buff.WriteString(string(target.Kind)) // write string
	}

	// --- [end][write][alias](OwnerKind) ---

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the Owner type
func (target *Owner) UnmarshalBinary(data []byte) error {
	ctx := NewDecodingContextFromBytes(data)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryFromReader uses the io.Reader data to set all the internal properties of
// the Owner type
func (target *Owner) UnmarshalBinaryFromReader(reader io.Reader) error {
	ctx := NewDecodingContextFromReader(reader)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
// the Owner type
func (target *Owner) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	version := buff.ReadUInt8()

	if version > DefaultCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling Owner. Expected %d or less, got %d", DefaultCodecVersion, version)
	}

	var b string
	if ctx.IsStringTable() {
		c := buff.ReadInt() // read string index
		b = ctx.Table.At(c)
	} else {
		b = buff.ReadString() // read string
	}
	a := b
	target.UID = a

	d := buff.ReadBool() // read bool
	target.Controller = d

	// --- [begin][read][alias](OwnerKind) ---
	var e string
	var g string
	if ctx.IsStringTable() {
		h := buff.ReadInt() // read string index
		g = ctx.Table.At(h)
	} else {
		g = buff.ReadString() // read string
	}
	f := g
	e = f

	target.Kind = OwnerKind(e)
	// --- [end][read][alias](OwnerKind) ---

	return nil
}

//--------------------------------------------------------------------------
//  PersistentVolume
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this PersistentVolume instance
// into a byte array
func (target *PersistentVolume) MarshalBinary() (data []byte, err error) {
	ctx := NewEncodingContext(nil)

	e := target.MarshalBinaryWithContext(ctx)
	if e != nil {
		return nil, e
	}

	return ctx.ToBytes(), nil
}

// MarshalBinary serializes the internal properties of this PersistentVolume instance
// into an io.Writer.
func (target *PersistentVolume) MarshalBinaryTo(writer io.Writer) error {
	buff := util.NewBufferFromWriter(writer)
	defer buff.Flush()

	ctx := NewEncodingContextFromBuffer(buff, nil)

	return target.MarshalBinaryWithContext(ctx)
}

// MarshalBinaryWithContext serializes the internal properties of this PersistentVolume instance
// into a byte array leveraging a predefined context.
func (target *PersistentVolume) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	buff.WriteUInt8(DefaultCodecVersion) // version

	if ctx.IsStringTable() {
		a := ctx.Table.AddOrGet(target.UID)
		buff.WriteInt(a) // write table index
	} else {
		buff.WriteString(target.UID) // write string
	}

	if ctx.IsStringTable() {
		b := ctx.Table.AddOrGet(target.Name)
		buff.WriteInt(b) // write table index
	} else {
		buff.WriteString(target.Name) // write string
	}

	if ctx.IsStringTable() {
		c := ctx.Table.AddOrGet(target.StorageClass)
		buff.WriteInt(c) // write table index
	} else {
		buff.WriteString(target.StorageClass) // write string
	}

	if ctx.IsStringTable() {
		d := ctx.Table.AddOrGet(target.CSIVolumeHandle)
		buff.WriteInt(d) // write table index
	} else {
		buff.WriteString(target.CSIVolumeHandle) // write string
	}

	buff.WriteFloat64(target.SizeBytes) // write float64

	// --- [begin][write][reference](time.Time) ---
	e, errA := target.Start.MarshalBinary()
	if errA != nil {
		return errA
	}
	buff.WriteInt(len(e))
	buff.WriteBytes(e)
	// --- [end][write][reference](time.Time) ---

	// --- [begin][write][reference](time.Time) ---
	f, errB := target.End.MarshalBinary()
	if errB != nil {
		return errB
	}
	buff.WriteInt(len(f))
	buff.WriteBytes(f)
	// --- [end][write][reference](time.Time) ---

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the PersistentVolume type
func (target *PersistentVolume) UnmarshalBinary(data []byte) error {
	ctx := NewDecodingContextFromBytes(data)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryFromReader uses the io.Reader data to set all the internal properties of
// the PersistentVolume type
func (target *PersistentVolume) UnmarshalBinaryFromReader(reader io.Reader) error {
	ctx := NewDecodingContextFromReader(reader)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
// the PersistentVolume type
func (target *PersistentVolume) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	version := buff.ReadUInt8()

	if version > DefaultCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling PersistentVolume. Expected %d or less, got %d", DefaultCodecVersion, version)
	}

	var b string
	if ctx.IsStringTable() {
		c := buff.ReadInt() // read string index
		b = ctx.Table.At(c)
	} else {
		b = buff.ReadString() // read string
	}
	a := b
	target.UID = a

	var e string
	if ctx.IsStringTable() {
		f := buff.ReadInt() // read string index
		e = ctx.Table.At(f)
	} else {
		e = buff.ReadString() // read string
	}
	d := e
	target.Name = d

	var h string
	if ctx.IsStringTable() {
		l := buff.ReadInt() // read string index
		h = ctx.Table.At(l)
	} else {
		h = buff.ReadString() // read string
	}
	g := h
	target.StorageClass = g

	var n string
	if ctx.IsStringTable() {
		o := buff.ReadInt() // read string index
		n = ctx.Table.At(o)
	} else {
		n = buff.ReadString() // read string
	}
	m := n
	target.CSIVolumeHandle = m

	p := buff.ReadFloat64() // read float64
	target.SizeBytes = p

	// --- [begin][read][reference](time.Time) ---
	q := new(time.Time)
	r := buff.ReadInt() // byte array length
	s := buff.ReadBytes(r)
	errA := q.UnmarshalBinary(s)
	if errA != nil {
		return errA
	}
	target.Start = *q
	// --- [end][read][reference](time.Time) ---

	// --- [begin][read][reference](time.Time) ---
	t := new(time.Time)
	u := buff.ReadInt() // byte array length
	w := buff.ReadBytes(u)
	errB := t.UnmarshalBinary(w)
	if errB != nil {
		return errB
	}
	target.End = *t
	// --- [end][read][reference](time.Time) ---

	return nil
}

//--------------------------------------------------------------------------
//  PersistentVolumeClaim
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this PersistentVolumeClaim instance
// into a byte array
func (target *PersistentVolumeClaim) MarshalBinary() (data []byte, err error) {
	ctx := NewEncodingContext(nil)

	e := target.MarshalBinaryWithContext(ctx)
	if e != nil {
		return nil, e
	}

	return ctx.ToBytes(), nil
}

// MarshalBinary serializes the internal properties of this PersistentVolumeClaim instance
// into an io.Writer.
func (target *PersistentVolumeClaim) MarshalBinaryTo(writer io.Writer) error {
	buff := util.NewBufferFromWriter(writer)
	defer buff.Flush()

	ctx := NewEncodingContextFromBuffer(buff, nil)

	return target.MarshalBinaryWithContext(ctx)
}

// MarshalBinaryWithContext serializes the internal properties of this PersistentVolumeClaim instance
// into a byte array leveraging a predefined context.
func (target *PersistentVolumeClaim) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	buff.WriteUInt8(DefaultCodecVersion) // version

	if ctx.IsStringTable() {
		a := ctx.Table.AddOrGet(target.UID)
		buff.WriteInt(a) // write table index
	} else {
		buff.WriteString(target.UID) // write string
	}

	if ctx.IsStringTable() {
		b := ctx.Table.AddOrGet(target.NamespaceUID)
		buff.WriteInt(b) // write table index
	} else {
		buff.WriteString(target.NamespaceUID) // write string
	}

	if ctx.IsStringTable() {
		c := ctx.Table.AddOrGet(target.Name)
		buff.WriteInt(c) // write table index
	} else {
		buff.WriteString(target.Name) // write string
	}

	if ctx.IsStringTable() {
		d := ctx.Table.AddOrGet(target.PersistentVolumeUID)
		buff.WriteInt(d) // write table index
	} else {
		buff.WriteString(target.PersistentVolumeUID) // write string
	}

	if ctx.IsStringTable() {
		e := ctx.Table.AddOrGet(target.StorageClass)
		buff.WriteInt(e) // write table index
	} else {
		buff.WriteString(target.StorageClass) // write string
	}

	// --- [begin][write][reference](time.Time) ---
	f, errA := target.Start.MarshalBinary()
	if errA != nil {
		return errA
	}
	buff.WriteInt(len(f))
	buff.WriteBytes(f)
	// --- [end][write][reference](time.Time) ---

	// --- [begin][write][reference](time.Time) ---
	g, errB := target.End.MarshalBinary()
	if errB != nil {
		return errB
	}
	buff.WriteInt(len(g))
	buff.WriteBytes(g)
	// --- [end][write][reference](time.Time) ---

	buff.WriteFloat64(target.RequestedBytes) // write float64

	buff.WriteFloat64(target.UsageBytesAvg) // write float64

	buff.WriteFloat64(target.UsageBytesMax) // write float64

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the PersistentVolumeClaim type
func (target *PersistentVolumeClaim) UnmarshalBinary(data []byte) error {
	ctx := NewDecodingContextFromBytes(data)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryFromReader uses the io.Reader data to set all the internal properties of
// the PersistentVolumeClaim type
func (target *PersistentVolumeClaim) UnmarshalBinaryFromReader(reader io.Reader) error {
	ctx := NewDecodingContextFromReader(reader)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
// the PersistentVolumeClaim type
func (target *PersistentVolumeClaim) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	version := buff.ReadUInt8()

	if version > DefaultCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling PersistentVolumeClaim. Expected %d or less, got %d", DefaultCodecVersion, version)
	}

	var b string
	if ctx.IsStringTable() {
		c := buff.ReadInt() // read string index
		b = ctx.Table.At(c)
	} else {
		b = buff.ReadString() // read string
	}
	a := b
	target.UID = a

	var e string
	if ctx.IsStringTable() {
		f := buff.ReadInt() // read string index
		e = ctx.Table.At(f)
	} else {
		e = buff.ReadString() // read string
	}
	d := e
	target.NamespaceUID = d

	var h string
	if ctx.IsStringTable() {
		l := buff.ReadInt() // read string index
		h = ctx.Table.At(l)
	} else {
		h = buff.ReadString() // read string
	}
	g := h
	target.Name = g

	var n string
	if ctx.IsStringTable() {
		o := buff.ReadInt() // read string index
		n = ctx.Table.At(o)
	} else {
		n = buff.ReadString() // read string
	}
	m := n
	target.PersistentVolumeUID = m

	var q string
	if ctx.IsStringTable() {
		r := buff.ReadInt() // read string index
		q = ctx.Table.At(r)
	} else {
		q = buff.ReadString() // read string
	}
	p := q
	target.StorageClass = p

	// --- [begin][read][reference](time.Time) ---
	s := new(time.Time)
	t := buff.ReadInt() // byte array length
	u := buff.ReadBytes(t)
	errA := s.UnmarshalBinary(u)
	if errA != nil {
		return errA
	}
	target.Start = *s
	// --- [end][read][reference](time.Time) ---

	// --- [begin][read][reference](time.Time) ---
	w := new(time.Time)
	x := buff.ReadInt() // byte array length
	y := buff.ReadBytes(x)
	errB := w.UnmarshalBinary(y)
	if errB != nil {
		return errB
	}
	target.End = *w
	// --- [end][read][reference](time.Time) ---

	aa := buff.ReadFloat64() // read float64
	target.RequestedBytes = aa

	bb := buff.ReadFloat64() // read float64
	target.UsageBytesAvg = bb

	cc := buff.ReadFloat64() // read float64
	target.UsageBytesMax = cc

	return nil
}

//--------------------------------------------------------------------------
//  Pod
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this Pod instance
// into a byte array
func (target *Pod) MarshalBinary() (data []byte, err error) {
	ctx := NewEncodingContext(nil)

	e := target.MarshalBinaryWithContext(ctx)
	if e != nil {
		return nil, e
	}

	return ctx.ToBytes(), nil
}

// MarshalBinary serializes the internal properties of this Pod instance
// into an io.Writer.
func (target *Pod) MarshalBinaryTo(writer io.Writer) error {
	buff := util.NewBufferFromWriter(writer)
	defer buff.Flush()

	ctx := NewEncodingContextFromBuffer(buff, nil)

	return target.MarshalBinaryWithContext(ctx)
}

// MarshalBinaryWithContext serializes the internal properties of this Pod instance
// into a byte array leveraging a predefined context.
func (target *Pod) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	buff.WriteUInt8(DefaultCodecVersion) // version

	if ctx.IsStringTable() {
		a := ctx.Table.AddOrGet(target.UID)
		buff.WriteInt(a) // write table index
	} else {
		buff.WriteString(target.UID) // write string
	}

	if ctx.IsStringTable() {
		b := ctx.Table.AddOrGet(target.NamespaceUID)
		buff.WriteInt(b) // write table index
	} else {
		buff.WriteString(target.NamespaceUID) // write string
	}

	if ctx.IsStringTable() {
		c := ctx.Table.AddOrGet(target.NodeUID)
		buff.WriteInt(c) // write table index
	} else {
		buff.WriteString(target.NodeUID) // write string
	}

	if ctx.IsStringTable() {
		d := ctx.Table.AddOrGet(target.Name)
		buff.WriteInt(d) // write table index
	} else {
		buff.WriteString(target.Name) // write string
	}

	if target.Owners == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][slice]([]Owner) ---
		buff.WriteInt(len(target.Owners)) // slice length
		for i := range target.Owners {
			// --- [begin][write][struct](Owner) ---
			buff.WriteInt(0) // [compatibility, unused]
			errA := target.Owners[i].MarshalBinaryWithContext(ctx)
			if errA != nil {
				return errA
			}
			// --- [end][write][struct](Owner) ---

		}
		// --- [end][write][slice]([]Owner) ---

	}
	if target.PVCVolumes == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][slice]([]PodPVCVolume) ---
		buff.WriteInt(len(target.PVCVolumes)) // slice length
		for j := range target.PVCVolumes {
			// --- [begin][write][struct](PodPVCVolume) ---
			buff.WriteInt(0) // [compatibility, unused]
			errB := target.PVCVolumes[j].MarshalBinaryWithContext(ctx)
			if errB != nil {
				return errB
			}
			// --- [end][write][struct](PodPVCVolume) ---

		}
		// --- [end][write][slice]([]PodPVCVolume) ---

	}
	if target.Labels == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]string) ---
		buff.WriteInt(len(target.Labels)) // map length
		for v, z := range target.Labels {
			if ctx.IsStringTable() {
				e := ctx.Table.AddOrGet(v)
				buff.WriteInt(e) // write table index
			} else {
				buff.WriteString(v) // write string
			}

			if ctx.IsStringTable() {
				f := ctx.Table.AddOrGet(z)
				buff.WriteInt(f) // write table index
			} else {
				buff.WriteString(z) // write string
			}

		}
		// --- [end][write][map](map[string]string) ---

	}
	if target.Annotations == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]string) ---
		buff.WriteInt(len(target.Annotations)) // map length
		for vv, zz := range target.Annotations {
			if ctx.IsStringTable() {
				g := ctx.Table.AddOrGet(vv)
				buff.WriteInt(g) // write table index
			} else {
				buff.WriteString(vv) // write string
			}

			if ctx.IsStringTable() {
				h := ctx.Table.AddOrGet(zz)
				buff.WriteInt(h) // write table index
			} else {
				buff.WriteString(zz) // write string
			}

		}
		// --- [end][write][map](map[string]string) ---

	}
	if target.NetworkTrafficDetails == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][slice]([]NetworkTrafficDetail) ---
		buff.WriteInt(len(target.NetworkTrafficDetails)) // slice length
		for ii := range target.NetworkTrafficDetails {

			// --- [begin][write][struct](NetworkTrafficDetail) ---
			buff.WriteInt(0) // [compatibility, unused]
			errC := target.NetworkTrafficDetails[ii].MarshalBinaryWithContext(ctx)
			if errC != nil {
				return errC
			}
			// --- [end][write][struct](NetworkTrafficDetail) ---

		}
		// --- [end][write][slice]([]NetworkTrafficDetail) ---

	}

	// --- [begin][write][reference](time.Time) ---
	l, errD := target.Start.MarshalBinary()
	if errD != nil {
		return errD
	}
	buff.WriteInt(len(l))
	buff.WriteBytes(l)
	// --- [end][write][reference](time.Time) ---

	// --- [begin][write][reference](time.Time) ---
	m, errE := target.End.MarshalBinary()
	if errE != nil {
		return errE
	}
	buff.WriteInt(len(m))
	buff.WriteBytes(m)
	// --- [end][write][reference](time.Time) ---

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the Pod type
func (target *Pod) UnmarshalBinary(data []byte) error {
	ctx := NewDecodingContextFromBytes(data)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryFromReader uses the io.Reader data to set all the internal properties of
// the Pod type
func (target *Pod) UnmarshalBinaryFromReader(reader io.Reader) error {
	ctx := NewDecodingContextFromReader(reader)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
// the Pod type
func (target *Pod) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	version := buff.ReadUInt8()

	if version > DefaultCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling Pod. Expected %d or less, got %d", DefaultCodecVersion, version)
	}

	var b string
	if ctx.IsStringTable() {
		c := buff.ReadInt() // read string index
		b = ctx.Table.At(c)
	} else {
		b = buff.ReadString() // read string
	}
	a := b
	target.UID = a

	var e string
	if ctx.IsStringTable() {
		f := buff.ReadInt() // read string index
		e = ctx.Table.At(f)
	} else {
		e = buff.ReadString() // read string
	}
	d := e
	target.NamespaceUID = d

	var h string
	if ctx.IsStringTable() {
		l := buff.ReadInt() // read string index
		h = ctx.Table.At(l)
	} else {
		h = buff.ReadString() // read string
	}
	g := h
	target.NodeUID = g

	var n string
	if ctx.IsStringTable() {
		o := buff.ReadInt() // read string index
		n = ctx.Table.At(o)
	} else {
		n = buff.ReadString() // read string
	}
	m := n
	target.Name = m

	if buff.ReadUInt8() == uint8(0) {
		target.Owners = nil
	} else {
		// --- [begin][read][slice]([]Owner) ---
		q := buff.ReadInt() // slice len
		p := make([]Owner, q)
		for i := range q {
			// --- [begin][read][struct](Owner) ---
			s := new(Owner)
			buff.ReadInt() // [compatibility, unused]
			errA := s.UnmarshalBinaryWithContext(ctx)
			if errA != nil {
				return errA
			}
			r := *s
			// --- [end][read][struct](Owner) ---

			p[i] = r
		}
		target.Owners = p
		// --- [end][read][slice]([]Owner) ---

	}

	if buff.ReadUInt8() == uint8(0) {
		target.PVCVolumes = nil
	} else {
		// --- [begin][read][slice]([]PodPVCVolume) ---
		u := buff.ReadInt() // slice len
		t := make([]PodPVCVolume, u)
		for j := range u {
			// --- [begin][read][struct](PodPVCVolume) ---
			x := new(PodPVCVolume)
			buff.ReadInt() // [compatibility, unused]
			errB := x.UnmarshalBinaryWithContext(ctx)
			if errB != nil {
				return errB
			}
			w := *x
			// --- [end][read][struct](PodPVCVolume) ---

			t[j] = w
		}
		target.PVCVolumes = t
		// --- [end][read][slice]([]PodPVCVolume) ---

	}

	if buff.ReadUInt8() == uint8(0) {
		target.Labels = nil
	} else {
		// --- [begin][read][map](map[string]string) ---
		aa := buff.ReadInt() // map len
		y := make(map[string]string, aa)
		for range aa {
			var v string
			var cc string
			if ctx.IsStringTable() {
				dd := buff.ReadInt() // read string index
				cc = ctx.Table.At(dd)
			} else {
				cc = buff.ReadString() // read string
			}
			bb := cc
			v = bb

			var z string
			var ff string
			if ctx.IsStringTable() {
				gg := buff.ReadInt() // read string index
				ff = ctx.Table.At(gg)
			} else {
				ff = buff.ReadString() // read string
			}
			ee := ff
			z = ee

			y[v] = z
		}
		target.Labels = y
		// --- [end][read][map](map[string]string) ---

	}

	if buff.ReadUInt8() == uint8(0) {
		target.Annotations = nil
	} else {
		// --- [begin][read][map](map[string]string) ---
		ll := buff.ReadInt() // map len
		hh := make(map[string]string, ll)
		for range ll {
			var vv string
			var nn string
			if ctx.IsStringTable() {
				oo := buff.ReadInt() // read string index
				nn = ctx.Table.At(oo)
			} else {
				nn = buff.ReadString() // read string
			}
			mm := nn
			vv = mm

			var zz string
			var qq string
			if ctx.IsStringTable() {
				rr := buff.ReadInt() // read string index
				qq = ctx.Table.At(rr)
			} else {
				qq = buff.ReadString() // read string
			}
			pp := qq
			zz = pp

			hh[vv] = zz
		}
		target.Annotations = hh
		// --- [end][read][map](map[string]string) ---

	}

	if buff.ReadUInt8() == uint8(0) {
		target.NetworkTrafficDetails = nil
	} else {
		// --- [begin][read][slice]([]NetworkTrafficDetail) ---
		tt := buff.ReadInt() // slice len
		ss := make([]NetworkTrafficDetail, tt)
		for ii := range tt {

			// --- [begin][read][struct](NetworkTrafficDetail) ---
			ww := new(NetworkTrafficDetail)
			buff.ReadInt() // [compatibility, unused]
			errC := ww.UnmarshalBinaryWithContext(ctx)
			if errC != nil {
				return errC
			}
			uu := *ww
			// --- [end][read][struct](NetworkTrafficDetail) ---

			ss[ii] = uu
		}
		target.NetworkTrafficDetails = ss
		// --- [end][read][slice]([]NetworkTrafficDetail) ---

	}

	// --- [begin][read][reference](time.Time) ---
	xx := new(time.Time)
	yy := buff.ReadInt() // byte array length
	aaa := buff.ReadBytes(yy)
	errD := xx.UnmarshalBinary(aaa)
	if errD != nil {
		return errD
	}
	target.Start = *xx
	// --- [end][read][reference](time.Time) ---

	// --- [begin][read][reference](time.Time) ---
	bbb := new(time.Time)
	ccc := buff.ReadInt() // byte array length
	ddd := buff.ReadBytes(ccc)
	errE := bbb.UnmarshalBinary(ddd)
	if errE != nil {
		return errE
	}
	target.End = *bbb
	// --- [end][read][reference](time.Time) ---

	return nil
}

//--------------------------------------------------------------------------
//  PodPVCVolume
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this PodPVCVolume instance
// into a byte array
func (target *PodPVCVolume) MarshalBinary() (data []byte, err error) {
	ctx := NewEncodingContext(nil)

	e := target.MarshalBinaryWithContext(ctx)
	if e != nil {
		return nil, e
	}

	return ctx.ToBytes(), nil
}

// MarshalBinary serializes the internal properties of this PodPVCVolume instance
// into an io.Writer.
func (target *PodPVCVolume) MarshalBinaryTo(writer io.Writer) error {
	buff := util.NewBufferFromWriter(writer)
	defer buff.Flush()

	ctx := NewEncodingContextFromBuffer(buff, nil)

	return target.MarshalBinaryWithContext(ctx)
}

// MarshalBinaryWithContext serializes the internal properties of this PodPVCVolume instance
// into a byte array leveraging a predefined context.
func (target *PodPVCVolume) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	buff.WriteUInt8(DefaultCodecVersion) // version

	if ctx.IsStringTable() {
		a := ctx.Table.AddOrGet(target.Name)
		buff.WriteInt(a) // write table index
	} else {
		buff.WriteString(target.Name) // write string
	}

	if ctx.IsStringTable() {
		b := ctx.Table.AddOrGet(target.PersistentVolumeClaimUID)
		buff.WriteInt(b) // write table index
	} else {
		buff.WriteString(target.PersistentVolumeClaimUID) // write string
	}

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the PodPVCVolume type
func (target *PodPVCVolume) UnmarshalBinary(data []byte) error {
	ctx := NewDecodingContextFromBytes(data)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryFromReader uses the io.Reader data to set all the internal properties of
// the PodPVCVolume type
func (target *PodPVCVolume) UnmarshalBinaryFromReader(reader io.Reader) error {
	ctx := NewDecodingContextFromReader(reader)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
// the PodPVCVolume type
func (target *PodPVCVolume) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	version := buff.ReadUInt8()

	if version > DefaultCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling PodPVCVolume. Expected %d or less, got %d", DefaultCodecVersion, version)
	}

	var b string
	if ctx.IsStringTable() {
		c := buff.ReadInt() // read string index
		b = ctx.Table.At(c)
	} else {
		b = buff.ReadString() // read string
	}
	a := b
	target.Name = a

	var e string
	if ctx.IsStringTable() {
		f := buff.ReadInt() // read string index
		e = ctx.Table.At(f)
	} else {
		e = buff.ReadString() // read string
	}
	d := e
	target.PersistentVolumeClaimUID = d

	return nil
}

//--------------------------------------------------------------------------
//  ReplicaSet
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this ReplicaSet instance
// into a byte array
func (target *ReplicaSet) MarshalBinary() (data []byte, err error) {
	ctx := NewEncodingContext(nil)

	e := target.MarshalBinaryWithContext(ctx)
	if e != nil {
		return nil, e
	}

	return ctx.ToBytes(), nil
}

// MarshalBinary serializes the internal properties of this ReplicaSet instance
// into an io.Writer.
func (target *ReplicaSet) MarshalBinaryTo(writer io.Writer) error {
	buff := util.NewBufferFromWriter(writer)
	defer buff.Flush()

	ctx := NewEncodingContextFromBuffer(buff, nil)

	return target.MarshalBinaryWithContext(ctx)
}

// MarshalBinaryWithContext serializes the internal properties of this ReplicaSet instance
// into a byte array leveraging a predefined context.
func (target *ReplicaSet) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	buff.WriteUInt8(DefaultCodecVersion) // version

	if ctx.IsStringTable() {
		a := ctx.Table.AddOrGet(target.UID)
		buff.WriteInt(a) // write table index
	} else {
		buff.WriteString(target.UID) // write string
	}

	if ctx.IsStringTable() {
		b := ctx.Table.AddOrGet(target.NamespaceUID)
		buff.WriteInt(b) // write table index
	} else {
		buff.WriteString(target.NamespaceUID) // write string
	}

	if ctx.IsStringTable() {
		c := ctx.Table.AddOrGet(target.Name)
		buff.WriteInt(c) // write table index
	} else {
		buff.WriteString(target.Name) // write string
	}

	if target.Owners == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][slice]([]Owner) ---
		buff.WriteInt(len(target.Owners)) // slice length
		for i := range target.Owners {

			// --- [begin][write][struct](Owner) ---
			buff.WriteInt(0) // [compatibility, unused]
			errA := target.Owners[i].MarshalBinaryWithContext(ctx)
			if errA != nil {
				return errA
			}
			// --- [end][write][struct](Owner) ---

		}
		// --- [end][write][slice]([]Owner) ---

	}
	if target.Labels == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]string) ---
		buff.WriteInt(len(target.Labels)) // map length
		for v, z := range target.Labels {
			if ctx.IsStringTable() {
				d := ctx.Table.AddOrGet(v)
				buff.WriteInt(d) // write table index
			} else {
				buff.WriteString(v) // write string
			}

			if ctx.IsStringTable() {
				e := ctx.Table.AddOrGet(z)
				buff.WriteInt(e) // write table index
			} else {
				buff.WriteString(z) // write string
			}

		}
		// --- [end][write][map](map[string]string) ---

	}
	if target.Annotations == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]string) ---
		buff.WriteInt(len(target.Annotations)) // map length
		for vv, zz := range target.Annotations {
			if ctx.IsStringTable() {
				f := ctx.Table.AddOrGet(vv)
				buff.WriteInt(f) // write table index
			} else {
				buff.WriteString(vv) // write string
			}

			if ctx.IsStringTable() {
				g := ctx.Table.AddOrGet(zz)
				buff.WriteInt(g) // write table index
			} else {
				buff.WriteString(zz) // write string
			}

		}
		// --- [end][write][map](map[string]string) ---

	}

	// --- [begin][write][reference](time.Time) ---
	h, errB := target.Start.MarshalBinary()
	if errB != nil {
		return errB
	}
	buff.WriteInt(len(h))
	buff.WriteBytes(h)
	// --- [end][write][reference](time.Time) ---

	// --- [begin][write][reference](time.Time) ---
	l, errC := target.End.MarshalBinary()
	if errC != nil {
		return errC
	}
	buff.WriteInt(len(l))
	buff.WriteBytes(l)
	// --- [end][write][reference](time.Time) ---

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the ReplicaSet type
func (target *ReplicaSet) UnmarshalBinary(data []byte) error {
	ctx := NewDecodingContextFromBytes(data)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryFromReader uses the io.Reader data to set all the internal properties of
// the ReplicaSet type
func (target *ReplicaSet) UnmarshalBinaryFromReader(reader io.Reader) error {
	ctx := NewDecodingContextFromReader(reader)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
// the ReplicaSet type
func (target *ReplicaSet) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	version := buff.ReadUInt8()

	if version > DefaultCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling ReplicaSet. Expected %d or less, got %d", DefaultCodecVersion, version)
	}

	var b string
	if ctx.IsStringTable() {
		c := buff.ReadInt() // read string index
		b = ctx.Table.At(c)
	} else {
		b = buff.ReadString() // read string
	}
	a := b
	target.UID = a

	var e string
	if ctx.IsStringTable() {
		f := buff.ReadInt() // read string index
		e = ctx.Table.At(f)
	} else {
		e = buff.ReadString() // read string
	}
	d := e
	target.NamespaceUID = d

	var h string
	if ctx.IsStringTable() {
		l := buff.ReadInt() // read string index
		h = ctx.Table.At(l)
	} else {
		h = buff.ReadString() // read string
	}
	g := h
	target.Name = g

	if buff.ReadUInt8() == uint8(0) {
		target.Owners = nil
	} else {
		// --- [begin][read][slice]([]Owner) ---
		n := buff.ReadInt() // slice len
		m := make([]Owner, n)
		for i := range n {

			// --- [begin][read][struct](Owner) ---
			p := new(Owner)
			buff.ReadInt() // [compatibility, unused]
			errA := p.UnmarshalBinaryWithContext(ctx)
			if errA != nil {
				return errA
			}
			o := *p
			// --- [end][read][struct](Owner) ---

			m[i] = o
		}
		target.Owners = m
		// --- [end][read][slice]([]Owner) ---

	}

	if buff.ReadUInt8() == uint8(0) {
		target.Labels = nil
	} else {
		// --- [begin][read][map](map[string]string) ---
		r := buff.ReadInt() // map len
		q := make(map[string]string, r)
		for range r {
			var v string
			var t string
			if ctx.IsStringTable() {
				u := buff.ReadInt() // read string index
				t = ctx.Table.At(u)
			} else {
				t = buff.ReadString() // read string
			}
			s := t
			v = s

			var z string
			var x string
			if ctx.IsStringTable() {
				y := buff.ReadInt() // read string index
				x = ctx.Table.At(y)
			} else {
				x = buff.ReadString() // read string
			}
			w := x
			z = w

			q[v] = z
		}
		target.Labels = q
		// --- [end][read][map](map[string]string) ---

	}

	if buff.ReadUInt8() == uint8(0) {
		target.Annotations = nil
	} else {
		// --- [begin][read][map](map[string]string) ---
		bb := buff.ReadInt() // map len
		aa := make(map[string]string, bb)
		for range bb {
			var vv string
			var dd string
			if ctx.IsStringTable() {
				ee := buff.ReadInt() // read string index
				dd = ctx.Table.At(ee)
			} else {
				dd = buff.ReadString() // read string
			}
			cc := dd
			vv = cc

			var zz string
			var gg string
			if ctx.IsStringTable() {
				hh := buff.ReadInt() // read string index
				gg = ctx.Table.At(hh)
			} else {
				gg = buff.ReadString() // read string
			}
			ff := gg
			zz = ff

			aa[vv] = zz
		}
		target.Annotations = aa
		// --- [end][read][map](map[string]string) ---

	}

	// --- [begin][read][reference](time.Time) ---
	ll := new(time.Time)
	mm := buff.ReadInt() // byte array length
	nn := buff.ReadBytes(mm)
	errB := ll.UnmarshalBinary(nn)
	if errB != nil {
		return errB
	}
	target.Start = *ll
	// --- [end][read][reference](time.Time) ---

	// --- [begin][read][reference](time.Time) ---
	oo := new(time.Time)
	pp := buff.ReadInt() // byte array length
	qq := buff.ReadBytes(pp)
	errC := oo.UnmarshalBinary(qq)
	if errC != nil {
		return errC
	}
	target.End = *oo
	// --- [end][read][reference](time.Time) ---

	return nil
}

//--------------------------------------------------------------------------
//  ResourceQuantity
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this ResourceQuantity instance
// into a byte array
func (target *ResourceQuantity) MarshalBinary() (data []byte, err error) {
	ctx := NewEncodingContext(nil)

	e := target.MarshalBinaryWithContext(ctx)
	if e != nil {
		return nil, e
	}

	return ctx.ToBytes(), nil
}

// MarshalBinary serializes the internal properties of this ResourceQuantity instance
// into an io.Writer.
func (target *ResourceQuantity) MarshalBinaryTo(writer io.Writer) error {
	buff := util.NewBufferFromWriter(writer)
	defer buff.Flush()

	ctx := NewEncodingContextFromBuffer(buff, nil)

	return target.MarshalBinaryWithContext(ctx)
}

// MarshalBinaryWithContext serializes the internal properties of this ResourceQuantity instance
// into a byte array leveraging a predefined context.
func (target *ResourceQuantity) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	buff.WriteUInt8(DefaultCodecVersion) // version

	// --- [begin][write][alias](Resource) ---

	if ctx.IsStringTable() {
		a := ctx.Table.AddOrGet(string(target.Resource))
		buff.WriteInt(a) // write table index
	} else {
		buff.WriteString(string(target.Resource)) // write string
	}

	// --- [end][write][alias](Resource) ---

	// --- [begin][write][alias](Unit) ---

	if ctx.IsStringTable() {
		b := ctx.Table.AddOrGet(string(target.Unit))
		buff.WriteInt(b) // write table index
	} else {
		buff.WriteString(string(target.Unit)) // write string
	}

	// --- [end][write][alias](Unit) ---

	// --- [begin][write][alias](Stats) ---
	if map[StatType]float64(target.Values) == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[StatType]float64) ---
		buff.WriteInt(len(map[StatType]float64(target.Values))) // map length
		for v, z := range map[StatType]float64(target.Values) {
			// --- [begin][write][alias](StatType) ---

			if ctx.IsStringTable() {
				c := ctx.Table.AddOrGet(string(v))
				buff.WriteInt(c) // write table index
			} else {
				buff.WriteString(string(v)) // write string
			}

			// --- [end][write][alias](StatType) ---
			buff.WriteFloat64(z) // write float64

		}
		// --- [end][write][map](map[StatType]float64) ---

	}
	// --- [end][write][alias](Stats) ---

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the ResourceQuantity type
func (target *ResourceQuantity) UnmarshalBinary(data []byte) error {
	ctx := NewDecodingContextFromBytes(data)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryFromReader uses the io.Reader data to set all the internal properties of
// the ResourceQuantity type
func (target *ResourceQuantity) UnmarshalBinaryFromReader(reader io.Reader) error {
	ctx := NewDecodingContextFromReader(reader)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
// the ResourceQuantity type
func (target *ResourceQuantity) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	version := buff.ReadUInt8()

	if version > DefaultCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling ResourceQuantity. Expected %d or less, got %d", DefaultCodecVersion, version)
	}

	// field version check
	if uint8(1) <= version {
		// --- [begin][read][alias](Resource) ---
		var a string
		var c string
		if ctx.IsStringTable() {
			d := buff.ReadInt() // read string index
			c = ctx.Table.At(d)
		} else {
			c = buff.ReadString() // read string
		}
		b := c
		a = b

		target.Resource = Resource(a)
		// --- [end][read][alias](Resource) ---

	} else {
	}
	// field version check
	if uint8(1) <= version {

		// --- [begin][read][alias](Unit) ---
		var e string
		var g string
		if ctx.IsStringTable() {
			h := buff.ReadInt() // read string index
			g = ctx.Table.At(h)
		} else {
			g = buff.ReadString() // read string
		}
		f := g
		e = f

		target.Unit = Unit(e)
		// --- [end][read][alias](Unit) ---

	} else {
	}
	// field version check
	if uint8(1) <= version {
		// --- [begin][read][alias](Stats) ---
		var l map[StatType]float64
		if buff.ReadUInt8() == uint8(0) {
			l = nil
		} else {
			// --- [begin][read][map](map[StatType]float64) ---
			n := buff.ReadInt() // map len
			m := make(map[StatType]float64, n)
			for range n {
				// --- [begin][read][alias](StatType) ---
				var o string
				var q string
				if ctx.IsStringTable() {
					r := buff.ReadInt() // read string index
					q = ctx.Table.At(r)
				} else {
					q = buff.ReadString() // read string
				}
				p := q
				o = p

				v := StatType(o)
				// --- [end][read][alias](StatType) ---

				var z float64
				s := buff.ReadFloat64() // read float64
				z = s

				m[v] = z
			}
			l = m
			// --- [end][read][map](map[StatType]float64) ---

		}

		target.Values = Stats(l)
		// --- [end][read][alias](Stats) ---

	} else {
	}

	return nil
}

//--------------------------------------------------------------------------
//  ResourceQuota
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this ResourceQuota instance
// into a byte array
func (target *ResourceQuota) MarshalBinary() (data []byte, err error) {
	ctx := NewEncodingContext(nil)

	e := target.MarshalBinaryWithContext(ctx)
	if e != nil {
		return nil, e
	}

	return ctx.ToBytes(), nil
}

// MarshalBinary serializes the internal properties of this ResourceQuota instance
// into an io.Writer.
func (target *ResourceQuota) MarshalBinaryTo(writer io.Writer) error {
	buff := util.NewBufferFromWriter(writer)
	defer buff.Flush()

	ctx := NewEncodingContextFromBuffer(buff, nil)

	return target.MarshalBinaryWithContext(ctx)
}

// MarshalBinaryWithContext serializes the internal properties of this ResourceQuota instance
// into a byte array leveraging a predefined context.
func (target *ResourceQuota) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	buff.WriteUInt8(DefaultCodecVersion) // version

	if ctx.IsStringTable() {
		a := ctx.Table.AddOrGet(target.UID)
		buff.WriteInt(a) // write table index
	} else {
		buff.WriteString(target.UID) // write string
	}

	if ctx.IsStringTable() {
		b := ctx.Table.AddOrGet(target.NamespaceUID)
		buff.WriteInt(b) // write table index
	} else {
		buff.WriteString(target.NamespaceUID) // write string
	}

	if ctx.IsStringTable() {
		c := ctx.Table.AddOrGet(target.Name)
		buff.WriteInt(c) // write table index
	} else {
		buff.WriteString(target.Name) // write string
	}

	if target.Spec == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][struct](ResourceQuotaSpec) ---
		buff.WriteInt(0) // [compatibility, unused]
		errA := target.Spec.MarshalBinaryWithContext(ctx)
		if errA != nil {
			return errA
		}
		// --- [end][write][struct](ResourceQuotaSpec) ---

	}
	if target.Status == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][struct](ResourceQuotaStatus) ---
		buff.WriteInt(0) // [compatibility, unused]
		errB := target.Status.MarshalBinaryWithContext(ctx)
		if errB != nil {
			return errB
		}
		// --- [end][write][struct](ResourceQuotaStatus) ---

	}

	// --- [begin][write][reference](time.Time) ---
	d, errC := target.Start.MarshalBinary()
	if errC != nil {
		return errC
	}
	buff.WriteInt(len(d))
	buff.WriteBytes(d)
	// --- [end][write][reference](time.Time) ---

	// --- [begin][write][reference](time.Time) ---
	e, errD := target.End.MarshalBinary()
	if errD != nil {
		return errD
	}
	buff.WriteInt(len(e))
	buff.WriteBytes(e)
	// --- [end][write][reference](time.Time) ---

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the ResourceQuota type
func (target *ResourceQuota) UnmarshalBinary(data []byte) error {
	ctx := NewDecodingContextFromBytes(data)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryFromReader uses the io.Reader data to set all the internal properties of
// the ResourceQuota type
func (target *ResourceQuota) UnmarshalBinaryFromReader(reader io.Reader) error {
	ctx := NewDecodingContextFromReader(reader)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
// the ResourceQuota type
func (target *ResourceQuota) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	version := buff.ReadUInt8()

	if version > DefaultCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling ResourceQuota. Expected %d or less, got %d", DefaultCodecVersion, version)
	}

	// field version check
	if uint8(1) <= version {

		var b string
		if ctx.IsStringTable() {
			c := buff.ReadInt() // read string index
			b = ctx.Table.At(c)
		} else {
			b = buff.ReadString() // read string
		}
		a := b
		target.UID = a

	} else {
		target.UID = "" // default
	}
	// field version check
	if uint8(1) <= version {

		var e string
		if ctx.IsStringTable() {
			f := buff.ReadInt() // read string index
			e = ctx.Table.At(f)
		} else {
			e = buff.ReadString() // read string
		}
		d := e
		target.NamespaceUID = d

	} else {
		target.NamespaceUID = "" // default
	}
	// field version check
	if uint8(1) <= version {

		var h string
		if ctx.IsStringTable() {
			l := buff.ReadInt() // read string index
			h = ctx.Table.At(l)
		} else {
			h = buff.ReadString() // read string
		}
		g := h
		target.Name = g

	} else {
		target.Name = "" // default
	}
	// field version check
	if uint8(1) <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.Spec = nil
		} else {

			// --- [begin][read][struct](ResourceQuotaSpec) ---
			m := new(ResourceQuotaSpec)
			buff.ReadInt() // [compatibility, unused]
			errA := m.UnmarshalBinaryWithContext(ctx)
			if errA != nil {
				return errA
			}
			target.Spec = m
			// --- [end][read][struct](ResourceQuotaSpec) ---

		}

	} else {
		target.Spec = nil
	}
	// field version check
	if uint8(1) <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.Status = nil
		} else {

			// --- [begin][read][struct](ResourceQuotaStatus) ---
			n := new(ResourceQuotaStatus)
			buff.ReadInt() // [compatibility, unused]
			errB := n.UnmarshalBinaryWithContext(ctx)
			if errB != nil {
				return errB
			}
			target.Status = n
			// --- [end][read][struct](ResourceQuotaStatus) ---

		}

	} else {
		target.Status = nil
	}
	// field version check
	if uint8(1) <= version {

		// --- [begin][read][reference](time.Time) ---
		o := new(time.Time)
		p := buff.ReadInt() // byte array length
		q := buff.ReadBytes(p)
		errC := o.UnmarshalBinary(q)
		if errC != nil {
			return errC
		}
		target.Start = *o
		// --- [end][read][reference](time.Time) ---

	} else {
	}
	// field version check
	if uint8(1) <= version {

		// --- [begin][read][reference](time.Time) ---
		r := new(time.Time)
		s := buff.ReadInt() // byte array length
		t := buff.ReadBytes(s)
		errD := r.UnmarshalBinary(t)
		if errD != nil {
			return errD
		}
		target.End = *r
		// --- [end][read][reference](time.Time) ---

	} else {
	}

	return nil
}

//--------------------------------------------------------------------------
//  ResourceQuotaSpec
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this ResourceQuotaSpec instance
// into a byte array
func (target *ResourceQuotaSpec) MarshalBinary() (data []byte, err error) {
	ctx := NewEncodingContext(nil)

	e := target.MarshalBinaryWithContext(ctx)
	if e != nil {
		return nil, e
	}

	return ctx.ToBytes(), nil
}

// MarshalBinary serializes the internal properties of this ResourceQuotaSpec instance
// into an io.Writer.
func (target *ResourceQuotaSpec) MarshalBinaryTo(writer io.Writer) error {
	buff := util.NewBufferFromWriter(writer)
	defer buff.Flush()

	ctx := NewEncodingContextFromBuffer(buff, nil)

	return target.MarshalBinaryWithContext(ctx)
}

// MarshalBinaryWithContext serializes the internal properties of this ResourceQuotaSpec instance
// into a byte array leveraging a predefined context.
func (target *ResourceQuotaSpec) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	buff.WriteUInt8(DefaultCodecVersion) // version

	if target.Hard == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][struct](ResourceQuotaSpecHard) ---
		buff.WriteInt(0) // [compatibility, unused]
		errA := target.Hard.MarshalBinaryWithContext(ctx)
		if errA != nil {
			return errA
		}
		// --- [end][write][struct](ResourceQuotaSpecHard) ---

	}

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the ResourceQuotaSpec type
func (target *ResourceQuotaSpec) UnmarshalBinary(data []byte) error {
	ctx := NewDecodingContextFromBytes(data)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryFromReader uses the io.Reader data to set all the internal properties of
// the ResourceQuotaSpec type
func (target *ResourceQuotaSpec) UnmarshalBinaryFromReader(reader io.Reader) error {
	ctx := NewDecodingContextFromReader(reader)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
// the ResourceQuotaSpec type
func (target *ResourceQuotaSpec) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	version := buff.ReadUInt8()

	if version > DefaultCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling ResourceQuotaSpec. Expected %d or less, got %d", DefaultCodecVersion, version)
	}

	// field version check
	if uint8(1) <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.Hard = nil
		} else {

			// --- [begin][read][struct](ResourceQuotaSpecHard) ---
			a := new(ResourceQuotaSpecHard)
			buff.ReadInt() // [compatibility, unused]
			errA := a.UnmarshalBinaryWithContext(ctx)
			if errA != nil {
				return errA
			}
			target.Hard = a
			// --- [end][read][struct](ResourceQuotaSpecHard) ---

		}

	} else {
		target.Hard = nil
	}

	return nil
}

//--------------------------------------------------------------------------
//  ResourceQuotaSpecHard
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this ResourceQuotaSpecHard instance
// into a byte array
func (target *ResourceQuotaSpecHard) MarshalBinary() (data []byte, err error) {
	ctx := NewEncodingContext(nil)

	e := target.MarshalBinaryWithContext(ctx)
	if e != nil {
		return nil, e
	}

	return ctx.ToBytes(), nil
}

// MarshalBinary serializes the internal properties of this ResourceQuotaSpecHard instance
// into an io.Writer.
func (target *ResourceQuotaSpecHard) MarshalBinaryTo(writer io.Writer) error {
	buff := util.NewBufferFromWriter(writer)
	defer buff.Flush()

	ctx := NewEncodingContextFromBuffer(buff, nil)

	return target.MarshalBinaryWithContext(ctx)
}

// MarshalBinaryWithContext serializes the internal properties of this ResourceQuotaSpecHard instance
// into a byte array leveraging a predefined context.
func (target *ResourceQuotaSpecHard) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	buff.WriteUInt8(DefaultCodecVersion) // version

	// --- [begin][write][alias](ResourceQuantities) ---
	if map[Resource]ResourceQuantity(target.Requests) == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[Resource]ResourceQuantity) ---
		buff.WriteInt(len(map[Resource]ResourceQuantity(target.Requests))) // map length
		for v, z := range map[Resource]ResourceQuantity(target.Requests) {
			// --- [begin][write][alias](Resource) ---

			if ctx.IsStringTable() {
				a := ctx.Table.AddOrGet(string(v))
				buff.WriteInt(a) // write table index
			} else {
				buff.WriteString(string(v)) // write string
			}

			// --- [end][write][alias](Resource) ---
			// --- [begin][write][struct](ResourceQuantity) ---
			buff.WriteInt(0) // [compatibility, unused]
			errA := z.MarshalBinaryWithContext(ctx)
			if errA != nil {
				return errA
			}
			// --- [end][write][struct](ResourceQuantity) ---

		}
		// --- [end][write][map](map[Resource]ResourceQuantity) ---

	}
	// --- [end][write][alias](ResourceQuantities) ---

	// --- [begin][write][alias](ResourceQuantities) ---
	if map[Resource]ResourceQuantity(target.Limits) == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[Resource]ResourceQuantity) ---
		buff.WriteInt(len(map[Resource]ResourceQuantity(target.Limits))) // map length
		for vv, zz := range map[Resource]ResourceQuantity(target.Limits) {
			// --- [begin][write][alias](Resource) ---

			if ctx.IsStringTable() {
				b := ctx.Table.AddOrGet(string(vv))
				buff.WriteInt(b) // write table index
			} else {
				buff.WriteString(string(vv)) // write string
			}

			// --- [end][write][alias](Resource) ---
			// --- [begin][write][struct](ResourceQuantity) ---
			buff.WriteInt(0) // [compatibility, unused]
			errB := zz.MarshalBinaryWithContext(ctx)
			if errB != nil {
				return errB
			}
			// --- [end][write][struct](ResourceQuantity) ---

		}
		// --- [end][write][map](map[Resource]ResourceQuantity) ---

	}
	// --- [end][write][alias](ResourceQuantities) ---

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the ResourceQuotaSpecHard type
func (target *ResourceQuotaSpecHard) UnmarshalBinary(data []byte) error {
	ctx := NewDecodingContextFromBytes(data)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryFromReader uses the io.Reader data to set all the internal properties of
// the ResourceQuotaSpecHard type
func (target *ResourceQuotaSpecHard) UnmarshalBinaryFromReader(reader io.Reader) error {
	ctx := NewDecodingContextFromReader(reader)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
// the ResourceQuotaSpecHard type
func (target *ResourceQuotaSpecHard) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	version := buff.ReadUInt8()

	if version > DefaultCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling ResourceQuotaSpecHard. Expected %d or less, got %d", DefaultCodecVersion, version)
	}

	// field version check
	if uint8(1) <= version {

		// --- [begin][read][alias](ResourceQuantities) ---
		var a map[Resource]ResourceQuantity
		if buff.ReadUInt8() == uint8(0) {
			a = nil
		} else {
			// --- [begin][read][map](map[Resource]ResourceQuantity) ---
			c := buff.ReadInt() // map len
			b := make(map[Resource]ResourceQuantity, c)
			for range c {
				// --- [begin][read][alias](Resource) ---
				var d string
				var f string
				if ctx.IsStringTable() {
					g := buff.ReadInt() // read string index
					f = ctx.Table.At(g)
				} else {
					f = buff.ReadString() // read string
				}
				e := f
				d = e

				v := Resource(d)
				// --- [end][read][alias](Resource) ---

				// --- [begin][read][struct](ResourceQuantity) ---
				h := new(ResourceQuantity)
				buff.ReadInt() // [compatibility, unused]
				errA := h.UnmarshalBinaryWithContext(ctx)
				if errA != nil {
					return errA
				}
				z := *h
				// --- [end][read][struct](ResourceQuantity) ---

				b[v] = z
			}
			a = b
			// --- [end][read][map](map[Resource]ResourceQuantity) ---

		}

		target.Requests = ResourceQuantities(a)
		// --- [end][read][alias](ResourceQuantities) ---

	} else {
	}
	// field version check
	if uint8(1) <= version {

		// --- [begin][read][alias](ResourceQuantities) ---
		var l map[Resource]ResourceQuantity
		if buff.ReadUInt8() == uint8(0) {
			l = nil
		} else {
			// --- [begin][read][map](map[Resource]ResourceQuantity) ---
			n := buff.ReadInt() // map len
			m := make(map[Resource]ResourceQuantity, n)
			for range n {
				// --- [begin][read][alias](Resource) ---
				var o string
				var q string
				if ctx.IsStringTable() {
					r := buff.ReadInt() // read string index
					q = ctx.Table.At(r)
				} else {
					q = buff.ReadString() // read string
				}
				p := q
				o = p

				vv := Resource(o)
				// --- [end][read][alias](Resource) ---

				// --- [begin][read][struct](ResourceQuantity) ---
				s := new(ResourceQuantity)
				buff.ReadInt() // [compatibility, unused]
				errB := s.UnmarshalBinaryWithContext(ctx)
				if errB != nil {
					return errB
				}
				zz := *s
				// --- [end][read][struct](ResourceQuantity) ---

				m[vv] = zz
			}
			l = m
			// --- [end][read][map](map[Resource]ResourceQuantity) ---

		}

		target.Limits = ResourceQuantities(l)
		// --- [end][read][alias](ResourceQuantities) ---

	} else {
	}

	return nil
}

//--------------------------------------------------------------------------
//  ResourceQuotaStatus
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this ResourceQuotaStatus instance
// into a byte array
func (target *ResourceQuotaStatus) MarshalBinary() (data []byte, err error) {
	ctx := NewEncodingContext(nil)

	e := target.MarshalBinaryWithContext(ctx)
	if e != nil {
		return nil, e
	}

	return ctx.ToBytes(), nil
}

// MarshalBinary serializes the internal properties of this ResourceQuotaStatus instance
// into an io.Writer.
func (target *ResourceQuotaStatus) MarshalBinaryTo(writer io.Writer) error {
	buff := util.NewBufferFromWriter(writer)
	defer buff.Flush()

	ctx := NewEncodingContextFromBuffer(buff, nil)

	return target.MarshalBinaryWithContext(ctx)
}

// MarshalBinaryWithContext serializes the internal properties of this ResourceQuotaStatus instance
// into a byte array leveraging a predefined context.
func (target *ResourceQuotaStatus) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	buff.WriteUInt8(DefaultCodecVersion) // version

	if target.Used == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][struct](ResourceQuotaStatusUsed) ---
		buff.WriteInt(0) // [compatibility, unused]
		errA := target.Used.MarshalBinaryWithContext(ctx)
		if errA != nil {
			return errA
		}
		// --- [end][write][struct](ResourceQuotaStatusUsed) ---

	}

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the ResourceQuotaStatus type
func (target *ResourceQuotaStatus) UnmarshalBinary(data []byte) error {
	ctx := NewDecodingContextFromBytes(data)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryFromReader uses the io.Reader data to set all the internal properties of
// the ResourceQuotaStatus type
func (target *ResourceQuotaStatus) UnmarshalBinaryFromReader(reader io.Reader) error {
	ctx := NewDecodingContextFromReader(reader)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
// the ResourceQuotaStatus type
func (target *ResourceQuotaStatus) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	version := buff.ReadUInt8()

	if version > DefaultCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling ResourceQuotaStatus. Expected %d or less, got %d", DefaultCodecVersion, version)
	}

	// field version check
	if uint8(1) <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.Used = nil
		} else {

			// --- [begin][read][struct](ResourceQuotaStatusUsed) ---
			a := new(ResourceQuotaStatusUsed)
			buff.ReadInt() // [compatibility, unused]
			errA := a.UnmarshalBinaryWithContext(ctx)
			if errA != nil {
				return errA
			}
			target.Used = a
			// --- [end][read][struct](ResourceQuotaStatusUsed) ---

		}

	} else {
		target.Used = nil
	}

	return nil
}

//--------------------------------------------------------------------------
//  ResourceQuotaStatusUsed
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this ResourceQuotaStatusUsed instance
// into a byte array
func (target *ResourceQuotaStatusUsed) MarshalBinary() (data []byte, err error) {
	ctx := NewEncodingContext(nil)

	e := target.MarshalBinaryWithContext(ctx)
	if e != nil {
		return nil, e
	}

	return ctx.ToBytes(), nil
}

// MarshalBinary serializes the internal properties of this ResourceQuotaStatusUsed instance
// into an io.Writer.
func (target *ResourceQuotaStatusUsed) MarshalBinaryTo(writer io.Writer) error {
	buff := util.NewBufferFromWriter(writer)
	defer buff.Flush()

	ctx := NewEncodingContextFromBuffer(buff, nil)

	return target.MarshalBinaryWithContext(ctx)
}

// MarshalBinaryWithContext serializes the internal properties of this ResourceQuotaStatusUsed instance
// into a byte array leveraging a predefined context.
func (target *ResourceQuotaStatusUsed) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	buff.WriteUInt8(DefaultCodecVersion) // version

	// --- [begin][write][alias](ResourceQuantities) ---
	if map[Resource]ResourceQuantity(target.Requests) == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[Resource]ResourceQuantity) ---
		buff.WriteInt(len(map[Resource]ResourceQuantity(target.Requests))) // map length
		for v, z := range map[Resource]ResourceQuantity(target.Requests) {
			// --- [begin][write][alias](Resource) ---

			if ctx.IsStringTable() {
				a := ctx.Table.AddOrGet(string(v))
				buff.WriteInt(a) // write table index
			} else {
				buff.WriteString(string(v)) // write string
			}

			// --- [end][write][alias](Resource) ---
			// --- [begin][write][struct](ResourceQuantity) ---
			buff.WriteInt(0) // [compatibility, unused]
			errA := z.MarshalBinaryWithContext(ctx)
			if errA != nil {
				return errA
			}
			// --- [end][write][struct](ResourceQuantity) ---

		}
		// --- [end][write][map](map[Resource]ResourceQuantity) ---

	}
	// --- [end][write][alias](ResourceQuantities) ---

	// --- [begin][write][alias](ResourceQuantities) ---
	if map[Resource]ResourceQuantity(target.Limits) == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[Resource]ResourceQuantity) ---
		buff.WriteInt(len(map[Resource]ResourceQuantity(target.Limits))) // map length
		for vv, zz := range map[Resource]ResourceQuantity(target.Limits) {
			// --- [begin][write][alias](Resource) ---

			if ctx.IsStringTable() {
				b := ctx.Table.AddOrGet(string(vv))
				buff.WriteInt(b) // write table index
			} else {
				buff.WriteString(string(vv)) // write string
			}

			// --- [end][write][alias](Resource) ---
			// --- [begin][write][struct](ResourceQuantity) ---
			buff.WriteInt(0) // [compatibility, unused]
			errB := zz.MarshalBinaryWithContext(ctx)
			if errB != nil {
				return errB
			}
			// --- [end][write][struct](ResourceQuantity) ---

		}
		// --- [end][write][map](map[Resource]ResourceQuantity) ---

	}
	// --- [end][write][alias](ResourceQuantities) ---

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the ResourceQuotaStatusUsed type
func (target *ResourceQuotaStatusUsed) UnmarshalBinary(data []byte) error {
	ctx := NewDecodingContextFromBytes(data)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryFromReader uses the io.Reader data to set all the internal properties of
// the ResourceQuotaStatusUsed type
func (target *ResourceQuotaStatusUsed) UnmarshalBinaryFromReader(reader io.Reader) error {
	ctx := NewDecodingContextFromReader(reader)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
// the ResourceQuotaStatusUsed type
func (target *ResourceQuotaStatusUsed) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	version := buff.ReadUInt8()

	if version > DefaultCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling ResourceQuotaStatusUsed. Expected %d or less, got %d", DefaultCodecVersion, version)
	}

	// field version check
	if uint8(1) <= version {

		// --- [begin][read][alias](ResourceQuantities) ---
		var a map[Resource]ResourceQuantity
		if buff.ReadUInt8() == uint8(0) {
			a = nil
		} else {
			// --- [begin][read][map](map[Resource]ResourceQuantity) ---
			c := buff.ReadInt() // map len
			b := make(map[Resource]ResourceQuantity, c)
			for range c {
				// --- [begin][read][alias](Resource) ---
				var d string
				var f string
				if ctx.IsStringTable() {
					g := buff.ReadInt() // read string index
					f = ctx.Table.At(g)
				} else {
					f = buff.ReadString() // read string
				}
				e := f
				d = e

				v := Resource(d)
				// --- [end][read][alias](Resource) ---

				// --- [begin][read][struct](ResourceQuantity) ---
				h := new(ResourceQuantity)
				buff.ReadInt() // [compatibility, unused]
				errA := h.UnmarshalBinaryWithContext(ctx)
				if errA != nil {
					return errA
				}
				z := *h
				// --- [end][read][struct](ResourceQuantity) ---

				b[v] = z
			}
			a = b
			// --- [end][read][map](map[Resource]ResourceQuantity) ---

		}

		target.Requests = ResourceQuantities(a)
		// --- [end][read][alias](ResourceQuantities) ---

	} else {
	}
	// field version check
	if uint8(1) <= version {

		// --- [begin][read][alias](ResourceQuantities) ---
		var l map[Resource]ResourceQuantity
		if buff.ReadUInt8() == uint8(0) {
			l = nil
		} else {
			// --- [begin][read][map](map[Resource]ResourceQuantity) ---
			n := buff.ReadInt() // map len
			m := make(map[Resource]ResourceQuantity, n)
			for range n {
				// --- [begin][read][alias](Resource) ---
				var o string
				var q string
				if ctx.IsStringTable() {
					r := buff.ReadInt() // read string index
					q = ctx.Table.At(r)
				} else {
					q = buff.ReadString() // read string
				}
				p := q
				o = p

				vv := Resource(o)
				// --- [end][read][alias](Resource) ---

				// --- [begin][read][struct](ResourceQuantity) ---
				s := new(ResourceQuantity)
				buff.ReadInt() // [compatibility, unused]
				errB := s.UnmarshalBinaryWithContext(ctx)
				if errB != nil {
					return errB
				}
				zz := *s
				// --- [end][read][struct](ResourceQuantity) ---

				m[vv] = zz
			}
			l = m
			// --- [end][read][map](map[Resource]ResourceQuantity) ---

		}

		target.Limits = ResourceQuantities(l)
		// --- [end][read][alias](ResourceQuantities) ---

	} else {
	}

	return nil
}

//--------------------------------------------------------------------------
//  Service
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this Service instance
// into a byte array
func (target *Service) MarshalBinary() (data []byte, err error) {
	ctx := NewEncodingContext(nil)

	e := target.MarshalBinaryWithContext(ctx)
	if e != nil {
		return nil, e
	}

	return ctx.ToBytes(), nil
}

// MarshalBinary serializes the internal properties of this Service instance
// into an io.Writer.
func (target *Service) MarshalBinaryTo(writer io.Writer) error {
	buff := util.NewBufferFromWriter(writer)
	defer buff.Flush()

	ctx := NewEncodingContextFromBuffer(buff, nil)

	return target.MarshalBinaryWithContext(ctx)
}

// MarshalBinaryWithContext serializes the internal properties of this Service instance
// into a byte array leveraging a predefined context.
func (target *Service) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	buff.WriteUInt8(DefaultCodecVersion) // version

	if ctx.IsStringTable() {
		a := ctx.Table.AddOrGet(target.UID)
		buff.WriteInt(a) // write table index
	} else {
		buff.WriteString(target.UID) // write string
	}

	if ctx.IsStringTable() {
		b := ctx.Table.AddOrGet(target.NamespaceUID)
		buff.WriteInt(b) // write table index
	} else {
		buff.WriteString(target.NamespaceUID) // write string
	}

	if ctx.IsStringTable() {
		c := ctx.Table.AddOrGet(target.Name)
		buff.WriteInt(c) // write table index
	} else {
		buff.WriteString(target.Name) // write string
	}

	// --- [begin][write][alias](ServiceType) ---

	if ctx.IsStringTable() {
		d := ctx.Table.AddOrGet(string(target.Type))
		buff.WriteInt(d) // write table index
	} else {
		buff.WriteString(string(target.Type)) // write string
	}

	// --- [end][write][alias](ServiceType) ---

	// --- [begin][write][reference](time.Time) ---
	e, errA := target.Start.MarshalBinary()
	if errA != nil {
		return errA
	}
	buff.WriteInt(len(e))
	buff.WriteBytes(e)
	// --- [end][write][reference](time.Time) ---

	// --- [begin][write][reference](time.Time) ---
	f, errB := target.End.MarshalBinary()
	if errB != nil {
		return errB
	}
	buff.WriteInt(len(f))
	buff.WriteBytes(f)
	// --- [end][write][reference](time.Time) ---

	if target.Selector == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]string) ---
		buff.WriteInt(len(target.Selector)) // map length
		for v, z := range target.Selector {
			if ctx.IsStringTable() {
				g := ctx.Table.AddOrGet(v)
				buff.WriteInt(g) // write table index
			} else {
				buff.WriteString(v) // write string
			}

			if ctx.IsStringTable() {
				h := ctx.Table.AddOrGet(z)
				buff.WriteInt(h) // write table index
			} else {
				buff.WriteString(z) // write string
			}

		}
		// --- [end][write][map](map[string]string) ---

	}

	if ctx.IsStringTable() {
		l := ctx.Table.AddOrGet(target.LBIngressAddress)
		buff.WriteInt(l) // write table index
	} else {
		buff.WriteString(target.LBIngressAddress) // write string
	}

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the Service type
func (target *Service) UnmarshalBinary(data []byte) error {
	ctx := NewDecodingContextFromBytes(data)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryFromReader uses the io.Reader data to set all the internal properties of
// the Service type
func (target *Service) UnmarshalBinaryFromReader(reader io.Reader) error {
	ctx := NewDecodingContextFromReader(reader)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
// the Service type
func (target *Service) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	version := buff.ReadUInt8()

	if version > DefaultCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling Service. Expected %d or less, got %d", DefaultCodecVersion, version)
	}

	var b string
	if ctx.IsStringTable() {
		c := buff.ReadInt() // read string index
		b = ctx.Table.At(c)
	} else {
		b = buff.ReadString() // read string
	}
	a := b
	target.UID = a

	var e string
	if ctx.IsStringTable() {
		f := buff.ReadInt() // read string index
		e = ctx.Table.At(f)
	} else {
		e = buff.ReadString() // read string
	}
	d := e
	target.NamespaceUID = d

	var h string
	if ctx.IsStringTable() {
		l := buff.ReadInt() // read string index
		h = ctx.Table.At(l)
	} else {
		h = buff.ReadString() // read string
	}
	g := h
	target.Name = g

	// --- [begin][read][alias](ServiceType) ---
	var m string
	var o string
	if ctx.IsStringTable() {
		p := buff.ReadInt() // read string index
		o = ctx.Table.At(p)
	} else {
		o = buff.ReadString() // read string
	}
	n := o
	m = n

	target.Type = ServiceType(m)
	// --- [end][read][alias](ServiceType) ---

	// --- [begin][read][reference](time.Time) ---
	q := new(time.Time)
	r := buff.ReadInt() // byte array length
	s := buff.ReadBytes(r)
	errA := q.UnmarshalBinary(s)
	if errA != nil {
		return errA
	}
	target.Start = *q
	// --- [end][read][reference](time.Time) ---

	// --- [begin][read][reference](time.Time) ---
	t := new(time.Time)
	u := buff.ReadInt() // byte array length
	w := buff.ReadBytes(u)
	errB := t.UnmarshalBinary(w)
	if errB != nil {
		return errB
	}
	target.End = *t
	// --- [end][read][reference](time.Time) ---

	if buff.ReadUInt8() == uint8(0) {
		target.Selector = nil
	} else {
		// --- [begin][read][map](map[string]string) ---
		y := buff.ReadInt() // map len
		x := make(map[string]string, y)
		for range y {
			var v string
			var bb string
			if ctx.IsStringTable() {
				cc := buff.ReadInt() // read string index
				bb = ctx.Table.At(cc)
			} else {
				bb = buff.ReadString() // read string
			}
			aa := bb
			v = aa

			var z string
			var ee string
			if ctx.IsStringTable() {
				ff := buff.ReadInt() // read string index
				ee = ctx.Table.At(ff)
			} else {
				ee = buff.ReadString() // read string
			}
			dd := ee
			z = dd

			x[v] = z
		}
		target.Selector = x
		// --- [end][read][map](map[string]string) ---

	}

	var hh string
	if ctx.IsStringTable() {
		ll := buff.ReadInt() // read string index
		hh = ctx.Table.At(ll)
	} else {
		hh = buff.ReadString() // read string
	}
	gg := hh
	target.LBIngressAddress = gg

	return nil
}

//--------------------------------------------------------------------------
//  StatefulSet
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this StatefulSet instance
// into a byte array
func (target *StatefulSet) MarshalBinary() (data []byte, err error) {
	ctx := NewEncodingContext(nil)

	e := target.MarshalBinaryWithContext(ctx)
	if e != nil {
		return nil, e
	}

	return ctx.ToBytes(), nil
}

// MarshalBinary serializes the internal properties of this StatefulSet instance
// into an io.Writer.
func (target *StatefulSet) MarshalBinaryTo(writer io.Writer) error {
	buff := util.NewBufferFromWriter(writer)
	defer buff.Flush()

	ctx := NewEncodingContextFromBuffer(buff, nil)

	return target.MarshalBinaryWithContext(ctx)
}

// MarshalBinaryWithContext serializes the internal properties of this StatefulSet instance
// into a byte array leveraging a predefined context.
func (target *StatefulSet) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	buff.WriteUInt8(DefaultCodecVersion) // version

	if ctx.IsStringTable() {
		a := ctx.Table.AddOrGet(target.UID)
		buff.WriteInt(a) // write table index
	} else {
		buff.WriteString(target.UID) // write string
	}

	if ctx.IsStringTable() {
		b := ctx.Table.AddOrGet(target.NamespaceUID)
		buff.WriteInt(b) // write table index
	} else {
		buff.WriteString(target.NamespaceUID) // write string
	}

	if ctx.IsStringTable() {
		c := ctx.Table.AddOrGet(target.Name)
		buff.WriteInt(c) // write table index
	} else {
		buff.WriteString(target.Name) // write string
	}

	if target.Labels == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]string) ---
		buff.WriteInt(len(target.Labels)) // map length
		for v, z := range target.Labels {
			if ctx.IsStringTable() {
				d := ctx.Table.AddOrGet(v)
				buff.WriteInt(d) // write table index
			} else {
				buff.WriteString(v) // write string
			}

			if ctx.IsStringTable() {
				e := ctx.Table.AddOrGet(z)
				buff.WriteInt(e) // write table index
			} else {
				buff.WriteString(z) // write string
			}

		}
		// --- [end][write][map](map[string]string) ---

	}
	if target.Annotations == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]string) ---
		buff.WriteInt(len(target.Annotations)) // map length
		for vv, zz := range target.Annotations {
			if ctx.IsStringTable() {
				f := ctx.Table.AddOrGet(vv)
				buff.WriteInt(f) // write table index
			} else {
				buff.WriteString(vv) // write string
			}

			if ctx.IsStringTable() {
				g := ctx.Table.AddOrGet(zz)
				buff.WriteInt(g) // write table index
			} else {
				buff.WriteString(zz) // write string
			}

		}
		// --- [end][write][map](map[string]string) ---

	}
	if target.MatchLabels == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]string) ---
		buff.WriteInt(len(target.MatchLabels)) // map length
		for vvv, zzz := range target.MatchLabels {
			if ctx.IsStringTable() {
				h := ctx.Table.AddOrGet(vvv)
				buff.WriteInt(h) // write table index
			} else {
				buff.WriteString(vvv) // write string
			}

			if ctx.IsStringTable() {
				l := ctx.Table.AddOrGet(zzz)
				buff.WriteInt(l) // write table index
			} else {
				buff.WriteString(zzz) // write string
			}

		}
		// --- [end][write][map](map[string]string) ---

	}

	// --- [begin][write][reference](time.Time) ---
	m, errA := target.Start.MarshalBinary()
	if errA != nil {
		return errA
	}
	buff.WriteInt(len(m))
	buff.WriteBytes(m)
	// --- [end][write][reference](time.Time) ---

	// --- [begin][write][reference](time.Time) ---
	n, errB := target.End.MarshalBinary()
	if errB != nil {
		return errB
	}
	buff.WriteInt(len(n))
	buff.WriteBytes(n)
	// --- [end][write][reference](time.Time) ---

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the StatefulSet type
func (target *StatefulSet) UnmarshalBinary(data []byte) error {
	ctx := NewDecodingContextFromBytes(data)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryFromReader uses the io.Reader data to set all the internal properties of
// the StatefulSet type
func (target *StatefulSet) UnmarshalBinaryFromReader(reader io.Reader) error {
	ctx := NewDecodingContextFromReader(reader)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
// the StatefulSet type
func (target *StatefulSet) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	version := buff.ReadUInt8()

	if version > DefaultCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling StatefulSet. Expected %d or less, got %d", DefaultCodecVersion, version)
	}

	var b string
	if ctx.IsStringTable() {
		c := buff.ReadInt() // read string index
		b = ctx.Table.At(c)
	} else {
		b = buff.ReadString() // read string
	}
	a := b
	target.UID = a

	var e string
	if ctx.IsStringTable() {
		f := buff.ReadInt() // read string index
		e = ctx.Table.At(f)
	} else {
		e = buff.ReadString() // read string
	}
	d := e
	target.NamespaceUID = d

	var h string
	if ctx.IsStringTable() {
		l := buff.ReadInt() // read string index
		h = ctx.Table.At(l)
	} else {
		h = buff.ReadString() // read string
	}
	g := h
	target.Name = g

	if buff.ReadUInt8() == uint8(0) {
		target.Labels = nil
	} else {
		// --- [begin][read][map](map[string]string) ---
		n := buff.ReadInt() // map len
		m := make(map[string]string, n)
		for range n {
			var v string
			var p string
			if ctx.IsStringTable() {
				q := buff.ReadInt() // read string index
				p = ctx.Table.At(q)
			} else {
				p = buff.ReadString() // read string
			}
			o := p
			v = o

			var z string
			var s string
			if ctx.IsStringTable() {
				t := buff.ReadInt() // read string index
				s = ctx.Table.At(t)
			} else {
				s = buff.ReadString() // read string
			}
			r := s
			z = r

			m[v] = z
		}
		target.Labels = m
		// --- [end][read][map](map[string]string) ---

	}

	if buff.ReadUInt8() == uint8(0) {
		target.Annotations = nil
	} else {
		// --- [begin][read][map](map[string]string) ---
		w := buff.ReadInt() // map len
		u := make(map[string]string, w)
		for range w {
			var vv string
			var y string
			if ctx.IsStringTable() {
				aa := buff.ReadInt() // read string index
				y = ctx.Table.At(aa)
			} else {
				y = buff.ReadString() // read string
			}
			x := y
			vv = x

			var zz string
			var cc string
			if ctx.IsStringTable() {
				dd := buff.ReadInt() // read string index
				cc = ctx.Table.At(dd)
			} else {
				cc = buff.ReadString() // read string
			}
			bb := cc
			zz = bb

			u[vv] = zz
		}
		target.Annotations = u
		// --- [end][read][map](map[string]string) ---

	}

	if buff.ReadUInt8() == uint8(0) {
		target.MatchLabels = nil
	} else {
		// --- [begin][read][map](map[string]string) ---
		ff := buff.ReadInt() // map len
		ee := make(map[string]string, ff)
		for range ff {
			var vvv string
			var hh string
			if ctx.IsStringTable() {
				ll := buff.ReadInt() // read string index
				hh = ctx.Table.At(ll)
			} else {
				hh = buff.ReadString() // read string
			}
			gg := hh
			vvv = gg

			var zzz string
			var nn string
			if ctx.IsStringTable() {
				oo := buff.ReadInt() // read string index
				nn = ctx.Table.At(oo)
			} else {
				nn = buff.ReadString() // read string
			}
			mm := nn
			zzz = mm

			ee[vvv] = zzz
		}
		target.MatchLabels = ee
		// --- [end][read][map](map[string]string) ---

	}

	// --- [begin][read][reference](time.Time) ---
	pp := new(time.Time)
	qq := buff.ReadInt() // byte array length
	rr := buff.ReadBytes(qq)
	errA := pp.UnmarshalBinary(rr)
	if errA != nil {
		return errA
	}
	target.Start = *pp
	// --- [end][read][reference](time.Time) ---

	// --- [begin][read][reference](time.Time) ---
	ss := new(time.Time)
	tt := buff.ReadInt() // byte array length
	uu := buff.ReadBytes(tt)
	errB := ss.UnmarshalBinary(uu)
	if errB != nil {
		return errB
	}
	target.End = *ss
	// --- [end][read][reference](time.Time) ---

	return nil
}

//--------------------------------------------------------------------------
//  Window
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this Window instance
// into a byte array
func (target *Window) MarshalBinary() (data []byte, err error) {
	ctx := NewEncodingContext(nil)

	e := target.MarshalBinaryWithContext(ctx)
	if e != nil {
		return nil, e
	}

	return ctx.ToBytes(), nil
}

// MarshalBinary serializes the internal properties of this Window instance
// into an io.Writer.
func (target *Window) MarshalBinaryTo(writer io.Writer) error {
	buff := util.NewBufferFromWriter(writer)
	defer buff.Flush()

	ctx := NewEncodingContextFromBuffer(buff, nil)

	return target.MarshalBinaryWithContext(ctx)
}

// MarshalBinaryWithContext serializes the internal properties of this Window instance
// into a byte array leveraging a predefined context.
func (target *Window) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	buff.WriteUInt8(DefaultCodecVersion) // version

	// --- [begin][write][reference](time.Time) ---
	a, errA := target.Start.MarshalBinary()
	if errA != nil {
		return errA
	}
	buff.WriteInt(len(a))
	buff.WriteBytes(a)
	// --- [end][write][reference](time.Time) ---

	// --- [begin][write][reference](time.Time) ---
	b, errB := target.End.MarshalBinary()
	if errB != nil {
		return errB
	}
	buff.WriteInt(len(b))
	buff.WriteBytes(b)
	// --- [end][write][reference](time.Time) ---

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the Window type
func (target *Window) UnmarshalBinary(data []byte) error {
	ctx := NewDecodingContextFromBytes(data)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryFromReader uses the io.Reader data to set all the internal properties of
// the Window type
func (target *Window) UnmarshalBinaryFromReader(reader io.Reader) error {
	ctx := NewDecodingContextFromReader(reader)
	defer ctx.Close()

	err := target.UnmarshalBinaryWithContext(ctx)
	if err != nil {
		return err
	}

	return nil
}

// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
// the Window type
func (target *Window) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
	// panics are recovered and propagated as errors
	defer func() {
		if r := recover(); r != nil {
			if e, ok := r.(error); ok {
				err = e
			} else if s, ok := r.(string); ok {
				err = fmt.Errorf("unexpected panic: %s", s)
			} else {
				err = fmt.Errorf("unexpected panic: %+v", r)
			}
		}
	}()

	buff := ctx.Buffer
	version := buff.ReadUInt8()

	if version > DefaultCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling Window. Expected %d or less, got %d", DefaultCodecVersion, version)
	}

	// field version check
	if uint8(1) <= version {

		// --- [begin][read][reference](time.Time) ---
		a := new(time.Time)
		b := buff.ReadInt() // byte array length
		c := buff.ReadBytes(b)
		errA := a.UnmarshalBinary(c)
		if errA != nil {
			return errA
		}
		target.Start = *a
		// --- [end][read][reference](time.Time) ---

	} else {
	}
	// field version check
	if uint8(1) <= version {

		// --- [begin][read][reference](time.Time) ---
		d := new(time.Time)
		e := buff.ReadInt() // byte array length
		f := buff.ReadBytes(e)
		errB := d.UnmarshalBinary(f)
		if errB != nil {
			return errB
		}
		target.End = *d
		// --- [end][read][reference](time.Time) ---

	} else {
	}

	return nil
}