cost-model/core/pkg/opencost/opencost_codecs.go

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

package opencost

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

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

const (
	// GeneratorPackageName is the package the generator is targetting
	GeneratorPackageName string = "opencost"
	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"

	// AllocationCodecVersion is used for any resources listed in the Allocation version set
	AllocationCodecVersion uint8 = 25

	// CloudCostCodecVersion is used for any resources listed in the CloudCost version set
	CloudCostCodecVersion uint8 = 3

	// NetworkInsightCodecVersion is used for any resources listed in the NetworkInsight version set
	NetworkInsightCodecVersion uint8 = 1

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

	// AssetsCodecVersion is used for any resources listed in the Assets version set
	AssetsCodecVersion uint8 = 21
)

//--------------------------------------------------------------------------
//  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{
	"Allocation":            reflect.TypeFor[Allocation](),
	"AllocationProperties":  reflect.TypeFor[AllocationProperties](),
	"AllocationSet":         reflect.TypeFor[AllocationSet](),
	"AllocationSetRange":    reflect.TypeFor[AllocationSetRange](),
	"Any":                   reflect.TypeFor[Any](),
	"AssetProperties":       reflect.TypeFor[AssetProperties](),
	"AssetSet":              reflect.TypeFor[AssetSet](),
	"AssetSetRange":         reflect.TypeFor[AssetSetRange](),
	"Breakdown":             reflect.TypeFor[Breakdown](),
	"Cloud":                 reflect.TypeFor[Cloud](),
	"CloudCost":             reflect.TypeFor[CloudCost](),
	"CloudCostProperties":   reflect.TypeFor[CloudCostProperties](),
	"CloudCostSet":          reflect.TypeFor[CloudCostSet](),
	"CloudCostSetRange":     reflect.TypeFor[CloudCostSetRange](),
	"ClusterManagement":     reflect.TypeFor[ClusterManagement](),
	"CostMetric":            reflect.TypeFor[CostMetric](),
	"Disk":                  reflect.TypeFor[Disk](),
	"GPUAllocation":         reflect.TypeFor[GPUAllocation](),
	"LbAllocation":          reflect.TypeFor[LbAllocation](),
	"LoadBalancer":          reflect.TypeFor[LoadBalancer](),
	"Network":               reflect.TypeFor[Network](),
	"NetworkDetail":         reflect.TypeFor[NetworkDetail](),
	"NetworkInsight":        reflect.TypeFor[NetworkInsight](),
	"NetworkInsightSet":     reflect.TypeFor[NetworkInsightSet](),
	"Node":                  reflect.TypeFor[Node](),
	"NodeOverhead":          reflect.TypeFor[NodeOverhead](),
	"PVAllocation":          reflect.TypeFor[PVAllocation](),
	"PVKey":                 reflect.TypeFor[PVKey](),
	"RawAllocationOnlyData": reflect.TypeFor[RawAllocationOnlyData](),
	"SharedAsset":           reflect.TypeFor[SharedAsset](),
	"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[AllocationSet]():     NewAllocationSetStream,
	reflect.TypeFor[AssetSet]():          NewAssetSetStream,
	reflect.TypeFor[CloudCostSet]():      NewCloudCostSetStream,
	reflect.TypeFor[NetworkInsightSet](): NewNetworkInsightSetStream,
}

// 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
}

//--------------------------------------------------------------------------
//  Allocation
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this Allocation instance
// into a byte array
func (target *Allocation) 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 Allocation instance
// into an io.Writer.
func (target *Allocation) 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 Allocation instance
// into a byte array leveraging a predefined context.
func (target *Allocation) 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(AllocationCodecVersion) // version

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

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

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

	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	// --- [begin][write][alias](PVAllocations) ---
	if map[PVKey]*PVAllocation(target.PVs) == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[PVKey]*PVAllocation) ---
		buff.WriteInt(len(map[PVKey]*PVAllocation(target.PVs))) // map length
		for v, z := range map[PVKey]*PVAllocation(target.PVs) {

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

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

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

			}
		}
		// --- [end][write][map](map[PVKey]*PVAllocation) ---

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

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

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

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

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

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

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

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

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

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

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

	}

	// --- [begin][write][alias](LbAllocations) ---
	if map[string]*LbAllocation(target.LoadBalancers) == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]*LbAllocation) ---
		buff.WriteInt(len(map[string]*LbAllocation(target.LoadBalancers))) // map length
		for vv, zz := range map[string]*LbAllocation(target.LoadBalancers) {
			if ctx.IsStringTable() {
				d := ctx.Table.AddOrGet(vv)
				buff.WriteInt(d) // 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](LbAllocation) ---
				buff.WriteInt(0) // [compatibility, unused]
				errH := zz.MarshalBinaryWithContext(ctx)
				if errH != nil {
					return errH
				}
				// --- [end][write][struct](LbAllocation) ---

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

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

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

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

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

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

	}

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

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

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

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

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the Allocation type
func (target *Allocation) 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 Allocation type
func (target *Allocation) 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 Allocation type
func (target *Allocation) 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 > AllocationCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling Allocation. Expected %d or less, got %d", AllocationCodecVersion, 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

	if buff.ReadUInt8() == uint8(0) {
		target.Properties = nil
	} else {

		// --- [begin][read][struct](AllocationProperties) ---
		d := new(AllocationProperties)
		buff.ReadInt() // [compatibility, unused]
		errA := d.UnmarshalBinaryWithContext(ctx)
		if errA != nil {
			return errA
		}
		target.Properties = d
		// --- [end][read][struct](AllocationProperties) ---

	}

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

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

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

	o := buff.ReadFloat64() // read float64
	target.CPUCoreHours = o

	p := buff.ReadFloat64() // read float64
	target.CPUCoreRequestAverage = p

	q := buff.ReadFloat64() // read float64
	target.CPUCoreUsageAverage = q

	r := buff.ReadFloat64() // read float64
	target.CPUCost = r

	s := buff.ReadFloat64() // read float64
	target.CPUCostAdjustment = s

	t := buff.ReadFloat64() // read float64
	target.GPUHours = t

	u := buff.ReadFloat64() // read float64
	target.GPUCost = u

	w := buff.ReadFloat64() // read float64
	target.GPUCostAdjustment = w

	x := buff.ReadFloat64() // read float64
	target.NetworkTransferBytes = x

	y := buff.ReadFloat64() // read float64
	target.NetworkReceiveBytes = y

	aa := buff.ReadFloat64() // read float64
	target.NetworkCost = aa

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

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

	} else {
		target.NetworkCrossZoneCost = float64(0) // default
	}
	// field version check
	if uint8(16) <= version {

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

	} else {
		target.NetworkCrossRegionCost = float64(0) // default
	}
	// field version check
	if uint8(16) <= version {

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

	} else {
		target.NetworkInternetCost = float64(0) // default
	}

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

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

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

	// --- [begin][read][alias](PVAllocations) ---
	var hh map[PVKey]*PVAllocation
	if buff.ReadUInt8() == uint8(0) {
		hh = nil
	} else {
		// --- [begin][read][map](map[PVKey]*PVAllocation) ---
		mm := buff.ReadInt() // map len
		ll := make(map[PVKey]*PVAllocation, mm)
		for range mm {

			// --- [begin][read][struct](PVKey) ---
			nn := new(PVKey)
			buff.ReadInt() // [compatibility, unused]
			errE := nn.UnmarshalBinaryWithContext(ctx)
			if errE != nil {
				return errE
			}
			v := *nn
			// --- [end][read][struct](PVKey) ---

			var z *PVAllocation
			if buff.ReadUInt8() == uint8(0) {
				z = nil
			} else {

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

			}
			ll[v] = z
		}
		hh = ll
		// --- [end][read][map](map[PVKey]*PVAllocation) ---

	}

	target.PVs = PVAllocations(hh)
	// --- [end][read][alias](PVAllocations) ---

	pp := buff.ReadFloat64() // read float64
	target.PVCostAdjustment = pp

	qq := buff.ReadFloat64() // read float64
	target.RAMByteHours = qq

	rr := buff.ReadFloat64() // read float64
	target.RAMBytesRequestAverage = rr

	ss := buff.ReadFloat64() // read float64
	target.RAMBytesUsageAverage = ss

	tt := buff.ReadFloat64() // read float64
	target.RAMCost = tt

	uu := buff.ReadFloat64() // read float64
	target.RAMCostAdjustment = uu

	ww := buff.ReadFloat64() // read float64
	target.SharedCost = ww

	xx := buff.ReadFloat64() // read float64
	target.ExternalCost = xx

	if buff.ReadUInt8() == uint8(0) {
		target.RawAllocationOnly = nil
	} else {

		// --- [begin][read][struct](RawAllocationOnlyData) ---
		yy := new(RawAllocationOnlyData)
		buff.ReadInt() // [compatibility, unused]
		errG := yy.UnmarshalBinaryWithContext(ctx)
		if errG != nil {
			return errG
		}
		target.RawAllocationOnly = yy
		// --- [end][read][struct](RawAllocationOnlyData) ---

	}

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

		// --- [begin][read][alias](LbAllocations) ---
		var aaa map[string]*LbAllocation
		if buff.ReadUInt8() == uint8(0) {
			aaa = nil
		} else {
			// --- [begin][read][map](map[string]*LbAllocation) ---
			ccc := buff.ReadInt() // map len
			bbb := make(map[string]*LbAllocation, ccc)
			for range ccc {
				var vv string
				var eee string
				if ctx.IsStringTable() {
					fff := buff.ReadInt() // read string index
					eee = ctx.Table.At(fff)
				} else {
					eee = buff.ReadString() // read string
				}
				ddd := eee
				vv = ddd

				var zz *LbAllocation
				if buff.ReadUInt8() == uint8(0) {
					zz = nil
				} else {

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

				}
				bbb[vv] = zz
			}
			aaa = bbb
			// --- [end][read][map](map[string]*LbAllocation) ---

		}

		target.LoadBalancers = LbAllocations(aaa)
		// --- [end][read][alias](LbAllocations) ---

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

		hhh := buff.ReadFloat64() // read float64
		target.deprecatedGPURequestAverage = hhh

	} else {
		target.deprecatedGPURequestAverage = float64(0) // default
	}
	// field version check
	if uint8(22) <= version {

		lll := buff.ReadFloat64() // read float64
		target.deprecatedGPUUsageAverage = lll

	} else {
		target.deprecatedGPUUsageAverage = float64(0) // default
	}
	// field version check
	if uint8(23) <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.GPUAllocation = nil
		} else {

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

		}

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

		nnn := buff.ReadFloat64() // read float64
		target.CPUCoreLimitAverage = nnn

	} else {
		target.CPUCoreLimitAverage = float64(0) // default
	}
	// field version check
	if uint8(24) <= version {

		ooo := buff.ReadFloat64() // read float64
		target.RAMBytesLimitAverage = ooo

	} else {
		target.RAMBytesLimitAverage = float64(0) // default
	}
	// field version check
	if uint8(25) <= version {

		ppp := buff.ReadFloat64() // read float64
		target.NetworkNatGatewayEgressCost = ppp

	} else {
		target.NetworkNatGatewayEgressCost = float64(0) // default
	}
	// field version check
	if uint8(25) <= version {

		qqq := buff.ReadFloat64() // read float64
		target.NetworkNatGatewayIngressCost = qqq

	} else {
		target.NetworkNatGatewayIngressCost = float64(0) // default
	}

	// execute migration func if version delta detected
	if version != AllocationCodecVersion {
		migrateAllocation(target, version, AllocationCodecVersion)
	}

	return nil
}

//--------------------------------------------------------------------------
//  AllocationProperties
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this AllocationProperties instance
// into a byte array
func (target *AllocationProperties) 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 AllocationProperties instance
// into an io.Writer.
func (target *AllocationProperties) 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 AllocationProperties instance
// into a byte array leveraging a predefined context.
func (target *AllocationProperties) 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(AllocationCodecVersion) // version

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

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

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

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

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

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

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

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

		// --- [begin][write][slice]([]string) ---
		buff.WriteInt(len(target.Services)) // slice length
		for i := range target.Services {
			if ctx.IsStringTable() {
				h := ctx.Table.AddOrGet(target.Services[i])
				buff.WriteInt(h) // write table index
			} else {
				buff.WriteString(target.Services[i]) // write string
			}

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

	}

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

	// --- [begin][write][alias](AllocationLabels) ---
	if map[string]string(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(map[string]string(target.Labels))) // map length
		for v, z := range map[string]string(target.Labels) {
			if ctx.IsStringTable() {
				m := ctx.Table.AddOrGet(v)
				buff.WriteInt(m) // write table index
			} else {
				buff.WriteString(v) // write string
			}

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

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

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

	// --- [begin][write][alias](AllocationAnnotations) ---
	if map[string]string(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(map[string]string(target.Annotations))) // map length
		for vv, zz := range map[string]string(target.Annotations) {
			if ctx.IsStringTable() {
				o := ctx.Table.AddOrGet(vv)
				buff.WriteInt(o) // write table index
			} else {
				buff.WriteString(vv) // write string
			}

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

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

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

	// --- [begin][write][alias](AllocationLabels) ---
	if map[string]string(target.NamespaceLabels) == 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(map[string]string(target.NamespaceLabels))) // map length
		for vvv, zzz := range map[string]string(target.NamespaceLabels) {
			if ctx.IsStringTable() {
				q := ctx.Table.AddOrGet(vvv)
				buff.WriteInt(q) // write table index
			} else {
				buff.WriteString(vvv) // write string
			}

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

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

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

	// --- [begin][write][alias](AllocationAnnotations) ---
	if map[string]string(target.NamespaceAnnotations) == 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(map[string]string(target.NamespaceAnnotations))) // map length
		for vvvv, zzzz := range map[string]string(target.NamespaceAnnotations) {
			if ctx.IsStringTable() {
				s := ctx.Table.AddOrGet(vvvv)
				buff.WriteInt(s) // write table index
			} else {
				buff.WriteString(vvvv) // write string
			}

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

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

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

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the AllocationProperties type
func (target *AllocationProperties) 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 AllocationProperties type
func (target *AllocationProperties) 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 AllocationProperties type
func (target *AllocationProperties) 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 > AllocationCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling AllocationProperties. Expected %d or less, got %d", AllocationCodecVersion, 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.Cluster = 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.Node = 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.Container = 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.Controller = 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.ControllerKind = p

	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
	target.Namespace = s

	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
	target.Pod = w

	if buff.ReadUInt8() == uint8(0) {
		target.Services = nil
	} else {
		// --- [begin][read][slice]([]string) ---
		bb := buff.ReadInt() // slice len
		aa := make([]string, bb)
		for i := range bb {
			var cc 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
			cc = dd

			aa[i] = cc
		}
		target.Services = aa
		// --- [end][read][slice]([]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.ProviderID = gg

	// --- [begin][read][alias](AllocationLabels) ---
	var mm map[string]string
	if buff.ReadUInt8() == uint8(0) {
		mm = nil
	} else {
		// --- [begin][read][map](map[string]string) ---
		oo := buff.ReadInt() // map len
		nn := make(map[string]string, oo)
		for range oo {
			var v 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
			v = pp

			var z string
			var tt string
			if ctx.IsStringTable() {
				uu := buff.ReadInt() // read string index
				tt = ctx.Table.At(uu)
			} else {
				tt = buff.ReadString() // read string
			}
			ss := tt
			z = ss

			nn[v] = z
		}
		mm = nn
		// --- [end][read][map](map[string]string) ---

	}

	target.Labels = AllocationLabels(mm)
	// --- [end][read][alias](AllocationLabels) ---

	// --- [begin][read][alias](AllocationAnnotations) ---
	var ww map[string]string
	if buff.ReadUInt8() == uint8(0) {
		ww = nil
	} else {
		// --- [begin][read][map](map[string]string) ---
		yy := buff.ReadInt() // map len
		xx := make(map[string]string, yy)
		for range yy {
			var vv 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
			vv = aaa

			var zz string
			var eee string
			if ctx.IsStringTable() {
				fff := buff.ReadInt() // read string index
				eee = ctx.Table.At(fff)
			} else {
				eee = buff.ReadString() // read string
			}
			ddd := eee
			zz = ddd

			xx[vv] = zz
		}
		ww = xx
		// --- [end][read][map](map[string]string) ---

	}

	target.Annotations = AllocationAnnotations(ww)
	// --- [end][read][alias](AllocationAnnotations) ---

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

		// --- [begin][read][alias](AllocationLabels) ---
		var ggg map[string]string
		if buff.ReadUInt8() == uint8(0) {
			ggg = nil
		} else {
			// --- [begin][read][map](map[string]string) ---
			lll := buff.ReadInt() // map len
			hhh := make(map[string]string, lll)
			for range lll {
				var vvv string
				var nnn string
				if ctx.IsStringTable() {
					ooo := buff.ReadInt() // read string index
					nnn = ctx.Table.At(ooo)
				} else {
					nnn = buff.ReadString() // read string
				}
				mmm := nnn
				vvv = mmm

				var zzz string
				var qqq string
				if ctx.IsStringTable() {
					rrr := buff.ReadInt() // read string index
					qqq = ctx.Table.At(rrr)
				} else {
					qqq = buff.ReadString() // read string
				}
				ppp := qqq
				zzz = ppp

				hhh[vvv] = zzz
			}
			ggg = hhh
			// --- [end][read][map](map[string]string) ---

		}

		target.NamespaceLabels = AllocationLabels(ggg)
		// --- [end][read][alias](AllocationLabels) ---

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

		// --- [begin][read][alias](AllocationAnnotations) ---
		var sss map[string]string
		if buff.ReadUInt8() == uint8(0) {
			sss = nil
		} else {
			// --- [begin][read][map](map[string]string) ---
			uuu := buff.ReadInt() // map len
			ttt := make(map[string]string, uuu)
			for range uuu {
				var vvvv string
				var xxx string
				if ctx.IsStringTable() {
					yyy := buff.ReadInt() // read string index
					xxx = ctx.Table.At(yyy)
				} else {
					xxx = buff.ReadString() // read string
				}
				www := xxx
				vvvv = www

				var zzzz string
				var bbbb string
				if ctx.IsStringTable() {
					cccc := buff.ReadInt() // read string index
					bbbb = ctx.Table.At(cccc)
				} else {
					bbbb = buff.ReadString() // read string
				}
				aaaa := bbbb
				zzzz = aaaa

				ttt[vvvv] = zzzz
			}
			sss = ttt
			// --- [end][read][map](map[string]string) ---

		}

		target.NamespaceAnnotations = AllocationAnnotations(sss)
		// --- [end][read][alias](AllocationAnnotations) ---

	} else {
	}

	return nil
}

//--------------------------------------------------------------------------
//  AllocationSet
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this AllocationSet instance
// into a byte array
func (target *AllocationSet) 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 AllocationSet instance
// into an io.Writer.
func (target *AllocationSet) 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 AllocationSet instance
// into a byte array leveraging a predefined context.
func (target *AllocationSet) 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(AllocationCodecVersion) // version

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

		// --- [begin][write][map](map[string]*Allocation) ---
		buff.WriteInt(len(target.Allocations)) // map length
		for v, z := range target.Allocations {
			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](Allocation) ---
				buff.WriteInt(0) // [compatibility, unused]
				errA := z.MarshalBinaryWithContext(ctx)
				if errA != nil {
					return errA
				}
				// --- [end][write][struct](Allocation) ---

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

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

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

			buff.WriteBool(zz) // write bool

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

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

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

			buff.WriteBool(zzz) // write bool

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

	}

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

	// --- [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.Warnings == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][slice]([]string) ---
		buff.WriteInt(len(target.Warnings)) // slice length
		for i := range target.Warnings {
			if ctx.IsStringTable() {
				e := ctx.Table.AddOrGet(target.Warnings[i])
				buff.WriteInt(e) // write table index
			} else {
				buff.WriteString(target.Warnings[i]) // write string
			}

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

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

		// --- [begin][write][slice]([]string) ---
		buff.WriteInt(len(target.Errors)) // slice length
		for j := range target.Errors {
			if ctx.IsStringTable() {
				f := ctx.Table.AddOrGet(target.Errors[j])
				buff.WriteInt(f) // write table index
			} else {
				buff.WriteString(target.Errors[j]) // write string
			}

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

	}

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the AllocationSet type
func (target *AllocationSet) 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 AllocationSet type
func (target *AllocationSet) 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 AllocationSet type
func (target *AllocationSet) 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 > AllocationCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling AllocationSet. Expected %d or less, got %d", AllocationCodecVersion, version)
	}

	if buff.ReadUInt8() == uint8(0) {
		target.Allocations = nil
	} else {
		// --- [begin][read][map](map[string]*Allocation) ---
		b := buff.ReadInt() // map len
		a := make(map[string]*Allocation, 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

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

			}
			a[v] = z
		}
		target.Allocations = a
		// --- [end][read][map](map[string]*Allocation) ---

	}

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

			var zz bool
			o := buff.ReadBool() // read bool
			zz = o

			g[vv] = zz
		}
		target.ExternalKeys = g
		// --- [end][read][map](map[string]bool) ---

	}

	if buff.ReadUInt8() == uint8(0) {
		target.IdleKeys = nil
	} else {
		// --- [begin][read][map](map[string]bool) ---
		q := buff.ReadInt() // map len
		p := make(map[string]bool, q)
		for range q {
			var vvv 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
			vvv = r

			var zzz bool
			u := buff.ReadBool() // read bool
			zzz = u

			p[vvv] = zzz
		}
		target.IdleKeys = p
		// --- [end][read][map](map[string]bool) ---

	}

	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
	target.FromSource = w

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

	if buff.ReadUInt8() == uint8(0) {
		target.Warnings = nil
	} else {
		// --- [begin][read][slice]([]string) ---
		cc := buff.ReadInt() // slice len
		bb := make([]string, cc)
		for i := range cc {
			var dd 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
			dd = ee

			bb[i] = dd
		}
		target.Warnings = bb
		// --- [end][read][slice]([]string) ---

	}

	if buff.ReadUInt8() == uint8(0) {
		target.Errors = nil
	} else {
		// --- [begin][read][slice]([]string) ---
		ll := buff.ReadInt() // slice len
		hh := make([]string, ll)
		for j := range ll {
			var mm string
			var oo string
			if ctx.IsStringTable() {
				pp := buff.ReadInt() // read string index
				oo = ctx.Table.At(pp)
			} else {
				oo = buff.ReadString() // read string
			}
			nn := oo
			mm = nn

			hh[j] = mm
		}
		target.Errors = hh
		// --- [end][read][slice]([]string) ---

	}

	return nil
}

//--------------------------------------------------------------------------
//  AllocationSetStream
//--------------------------------------------------------------------------

// AllocationSetStream is a single use field stream for the contents of an AllocationSet 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 AllocationSetStream struct {
	reader io.Reader
	ctx    *DecodingContext
	err    error
}

// Closes closes the internal io.Reader used to read and parse the AllocationSet fields.
// This should be called once the stream is no longer needed.
func (stream *AllocationSetStream) 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 AllocationSet
// This can be checked after iterating through the Stream().
func (stream *AllocationSetStream) Error() error {
	return stream.err
}

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

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

// Stream returns the iterator which will stream each field of the target type.
func (stream *AllocationSetStream) 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 > AllocationCodecVersion {
			stream.err = fmt.Errorf("Invalid Version Unmarshalling AllocationSet. Expected %d or less, got %d", AllocationCodecVersion, version)
			return
		}

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[map[string]*Allocation](),
			Name: "Allocations",
		}
		if buff.ReadUInt8() == uint8(0) {
			if !yield(fi, nil) {
				return
			}
		} else {
			// --- [begin][read][streaming-map](map[string]*Allocation) ---
			a := buff.ReadInt() // map len
			for range a {
				var v 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
				v = b

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

					}
					z = e
					// --- [end][read][struct](Allocation) ---

				}

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

		}

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[map[string]bool](),
			Name: "ExternalKeys",
		}
		if buff.ReadUInt8() == uint8(0) {
			if !yield(fi, nil) {
				return
			}
		} else {
			// --- [begin][read][streaming-map](map[string]bool) ---
			f := buff.ReadInt() // map len
			for range f {
				var vv string
				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
				vv = g

				var zz bool
				m := buff.ReadBool() // read bool
				zz = m

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

		}

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[map[string]bool](),
			Name: "IdleKeys",
		}
		if buff.ReadUInt8() == uint8(0) {
			if !yield(fi, nil) {
				return
			}
		} else {
			// --- [begin][read][streaming-map](map[string]bool) ---
			n := buff.ReadInt() // map len
			for range n {
				var vvv 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
				vvv = o

				var zzz bool
				r := buff.ReadBool() // read bool
				zzz = r

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

		}

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[string](),
			Name: "FromSource",
		}

		var s string
		var u string
		if ctx.IsStringTable() {
			w := buff.ReadInt() // read string index
			u = ctx.Table.At(w)
		} else {
			u = buff.ReadString() // read string
		}
		t := u
		s = t
		if !yield(fi, singleV(s)) {
			return
		}

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[Window](),
			Name: "Window",
		}

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

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

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[[]string](),
			Name: "Warnings",
		}
		if buff.ReadUInt8() == uint8(0) {
			if !yield(fi, nil) {
				return
			}
		} else {
			// --- [begin][read][streaming-slice]([]string) ---
			aa := buff.ReadInt() // slice len
			for i := range aa {

				var bb 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
				bb = cc

				if !yield(fi, pairV(i, bb)) {
					return
				}
			}
			// --- [end][read][streaming-slice]([]string) ---

		}

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[[]string](),
			Name: "Errors",
		}
		if buff.ReadUInt8() == uint8(0) {
			if !yield(fi, nil) {
				return
			}
		} else {
			// --- [begin][read][streaming-slice]([]string) ---
			ff := buff.ReadInt() // slice len
			for j := range ff {

				var gg string
				var ll string
				if ctx.IsStringTable() {
					mm := buff.ReadInt() // read string index
					ll = ctx.Table.At(mm)
				} else {
					ll = buff.ReadString() // read string
				}
				hh := ll
				gg = hh

				if !yield(fi, pairV(j, gg)) {
					return
				}
			}
			// --- [end][read][streaming-slice]([]string) ---

		}

	}
}

//--------------------------------------------------------------------------
//  AllocationSetRange
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this AllocationSetRange instance
// into a byte array
func (target *AllocationSetRange) 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 AllocationSetRange instance
// into an io.Writer.
func (target *AllocationSetRange) 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 AllocationSetRange instance
// into a byte array leveraging a predefined context.
func (target *AllocationSetRange) 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(AllocationCodecVersion) // version

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

		// --- [begin][write][slice]([]*AllocationSet) ---
		buff.WriteInt(len(target.Allocations)) // slice length
		for i := range target.Allocations {
			if target.Allocations[i] == nil {
				buff.WriteUInt8(uint8(0)) // write nil byte
			} else {
				buff.WriteUInt8(uint8(1)) // write non-nil byte

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

			}
		}
		// --- [end][write][slice]([]*AllocationSet) ---

	}

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

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the AllocationSetRange type
func (target *AllocationSetRange) 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 AllocationSetRange type
func (target *AllocationSetRange) 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 AllocationSetRange type
func (target *AllocationSetRange) 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 > AllocationCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling AllocationSetRange. Expected %d or less, got %d", AllocationCodecVersion, version)
	}

	if buff.ReadUInt8() == uint8(0) {
		target.Allocations = nil
	} else {
		// --- [begin][read][slice]([]*AllocationSet) ---
		b := buff.ReadInt() // slice len
		a := make([]*AllocationSet, b)
		for i := range b {
			var c *AllocationSet
			if buff.ReadUInt8() == uint8(0) {
				c = nil
			} else {
				// --- [begin][read][struct](AllocationSet) ---
				d := new(AllocationSet)
				buff.ReadInt() // [compatibility, unused]
				errA := d.UnmarshalBinaryWithContext(ctx)
				if errA != nil {
					return errA
				}
				c = d
				// --- [end][read][struct](AllocationSet) ---

			}

			a[i] = c
		}
		target.Allocations = a
		// --- [end][read][slice]([]*AllocationSet) ---

	}

	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
	target.FromStore = e

	return nil
}

//--------------------------------------------------------------------------
//  Any
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this Any instance
// into a byte array
func (target *Any) 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 Any instance
// into an io.Writer.
func (target *Any) 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 Any instance
// into a byte array leveraging a predefined context.
func (target *Any) 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(AssetsCodecVersion) // version

	// --- [begin][write][alias](AssetLabels) ---
	if map[string]string(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(map[string]string(target.Labels))) // map length
		for v, z := range map[string]string(target.Labels) {
			if ctx.IsStringTable() {
				a := ctx.Table.AddOrGet(v)
				buff.WriteInt(a) // write table index
			} else {
				buff.WriteString(v) // write string
			}

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

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

	}
	// --- [end][write][alias](AssetLabels) ---
	if target.Properties == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

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

	}

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

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

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

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

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

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the Any type
func (target *Any) 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 Any type
func (target *Any) 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 Any type
func (target *Any) 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 > AssetsCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling Any. Expected %d or less, got %d", AssetsCodecVersion, version)
	}

	// --- [begin][read][alias](AssetLabels) ---
	var a map[string]string
	if buff.ReadUInt8() == uint8(0) {
		a = nil
	} else {
		// --- [begin][read][map](map[string]string) ---
		c := buff.ReadInt() // map len
		b := make(map[string]string, c)
		for range c {
			var v string
			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
			v = d

			var z string
			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
			z = g

			b[v] = z
		}
		a = b
		// --- [end][read][map](map[string]string) ---

	}

	target.Labels = AssetLabels(a)
	// --- [end][read][alias](AssetLabels) ---

	if buff.ReadUInt8() == uint8(0) {
		target.Properties = nil
	} else {
		// --- [begin][read][struct](AssetProperties) ---
		m := new(AssetProperties)
		buff.ReadInt() // [compatibility, unused]
		errA := m.UnmarshalBinaryWithContext(ctx)
		if errA != nil {
			return errA
		}
		target.Properties = m
		// --- [end][read][struct](AssetProperties) ---

	}

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

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

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

	u := buff.ReadFloat64() // read float64
	target.Adjustment = u

	w := buff.ReadFloat64() // read float64
	target.Cost = w

	return nil
}

//--------------------------------------------------------------------------
//  AssetProperties
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this AssetProperties instance
// into a byte array
func (target *AssetProperties) 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 AssetProperties instance
// into an io.Writer.
func (target *AssetProperties) 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 AssetProperties instance
// into a byte array leveraging a predefined context.
func (target *AssetProperties) 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(AssetsCodecVersion) // version

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

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

	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.Project)
		buff.WriteInt(d) // write table index
	} else {
		buff.WriteString(target.Project) // write string
	}

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

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

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

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

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the AssetProperties type
func (target *AssetProperties) 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 AssetProperties type
func (target *AssetProperties) 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 AssetProperties type
func (target *AssetProperties) 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 > AssetsCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling AssetProperties. Expected %d or less, got %d", AssetsCodecVersion, 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.Category = 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.Provider = 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.Account = 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.Project = 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.Service = p

	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
	target.Cluster = s

	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
	target.Name = w

	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
	target.ProviderID = aa

	return nil
}

//--------------------------------------------------------------------------
//  AssetSet
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this AssetSet instance
// into a byte array
func (target *AssetSet) 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 AssetSet instance
// into an io.Writer.
func (target *AssetSet) 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 AssetSet instance
// into a byte array leveraging a predefined context.
func (target *AssetSet) 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(AssetsCodecVersion) // version

	// execute pre-processing func
	preProcessAssetSet(target)
	if target.AggregationKeys == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][slice]([]string) ---
		buff.WriteInt(len(target.AggregationKeys)) // slice length
		for i := range target.AggregationKeys {
			if ctx.IsStringTable() {
				a := ctx.Table.AddOrGet(target.AggregationKeys[i])
				buff.WriteInt(a) // write table index
			} else {
				buff.WriteString(target.AggregationKeys[i]) // write string
			}

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

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

		// --- [begin][write][map](map[string]Asset) ---
		buff.WriteInt(len(target.Assets)) // map length
		for v, z := range target.Assets {
			if ctx.IsStringTable() {
				b := ctx.Table.AddOrGet(v)
				buff.WriteInt(b) // 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][interface](Asset) ---
				c := reflect.ValueOf(z).Interface()
				d, okA := c.(BinEncoder)
				if !okA {
					return fmt.Errorf("type: %s does not implement %s.BinEncoder", typeToString(z), GeneratorPackageName)
				}
				buff.WriteString(typeToString(z))
				buff.WriteInt(0) // [compatibility, unused]

				errA := d.MarshalBinaryWithContext(ctx)
				if errA != nil {
					return errA
				}
				// --- [end][write][interface](Asset) ---

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

	}

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

	// --- [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.Warnings == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][slice]([]string) ---
		buff.WriteInt(len(target.Warnings)) // slice length
		for j := range target.Warnings {
			if ctx.IsStringTable() {
				f := ctx.Table.AddOrGet(target.Warnings[j])
				buff.WriteInt(f) // write table index
			} else {
				buff.WriteString(target.Warnings[j]) // write string
			}

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

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

		// --- [begin][write][slice]([]string) ---
		buff.WriteInt(len(target.Errors)) // slice length
		for ii := range target.Errors {
			if ctx.IsStringTable() {
				g := ctx.Table.AddOrGet(target.Errors[ii])
				buff.WriteInt(g) // write table index
			} else {
				buff.WriteString(target.Errors[ii]) // write string
			}

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

	}

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the AssetSet type
func (target *AssetSet) 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 AssetSet type
func (target *AssetSet) 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 AssetSet type
func (target *AssetSet) 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 > AssetsCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling AssetSet. Expected %d or less, got %d", AssetsCodecVersion, version)
	}

	if buff.ReadUInt8() == uint8(0) {
		target.AggregationKeys = nil
	} else {
		// --- [begin][read][slice]([]string) ---
		b := buff.ReadInt() // slice len
		a := make([]string, b)
		for i := range b {
			var c string
			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
			c = d

			a[i] = c
		}
		target.AggregationKeys = a
		// --- [end][read][slice]([]string) ---

	}

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

			var z Asset
			if buff.ReadUInt8() == uint8(0) {
				z = nil
			} else {
				// --- [begin][read][interface](Asset) ---
				o := buff.ReadString()
				_, p, _ := resolveType(o)
				if _, ok := typeMap[p]; !ok {
					return fmt.Errorf("Unknown Type: %s", p)
				}

				q, okA := reflect.New(typeMap[p]).Interface().(BinDecoder)
				if !okA {
					return fmt.Errorf("Type: %s does not implement %s.BinDecoder.", p, GeneratorPackageName)
				}

				buff.ReadInt() // [compatibility, unused]
				errA := q.UnmarshalBinaryWithContext(ctx)
				if errA != nil {
					return errA
				}
				z = q.(Asset)
				// --- [end][read][interface](Asset) ---

			}
			g[v] = z
		}
		target.Assets = g
		// --- [end][read][map](map[string]Asset) ---

	}

	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
	target.FromSource = r

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

	if buff.ReadUInt8() == uint8(0) {
		target.Warnings = nil
	} else {
		// --- [begin][read][slice]([]string) ---
		x := buff.ReadInt() // slice len
		w := make([]string, x)
		for j := range x {
			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

			w[j] = y
		}
		target.Warnings = w
		// --- [end][read][slice]([]string) ---

	}

	if buff.ReadUInt8() == uint8(0) {
		target.Errors = nil
	} else {
		// --- [begin][read][slice]([]string) ---
		ee := buff.ReadInt() // slice len
		dd := make([]string, ee)
		for ii := range ee {
			var ff 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
			ff = gg

			dd[ii] = ff
		}
		target.Errors = dd
		// --- [end][read][slice]([]string) ---

	}

	// execute post-processing func
	postProcessAssetSet(target)

	return nil
}

//--------------------------------------------------------------------------
//  AssetSetStream
//--------------------------------------------------------------------------

// AssetSetStream is a single use field stream for the contents of an AssetSet 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 AssetSetStream struct {
	reader io.Reader
	ctx    *DecodingContext
	err    error
}

// Closes closes the internal io.Reader used to read and parse the AssetSet fields.
// This should be called once the stream is no longer needed.
func (stream *AssetSetStream) 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 AssetSet
// This can be checked after iterating through the Stream().
func (stream *AssetSetStream) Error() error {
	return stream.err
}

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

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

// Stream returns the iterator which will stream each field of the target type.
func (stream *AssetSetStream) 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 > AssetsCodecVersion {
			stream.err = fmt.Errorf("Invalid Version Unmarshalling AssetSet. Expected %d or less, got %d", AssetsCodecVersion, version)
			return
		}

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[[]string](),
			Name: "AggregationKeys",
		}
		if buff.ReadUInt8() == uint8(0) {
			if !yield(fi, nil) {
				return
			}
		} else {
			// --- [begin][read][streaming-slice]([]string) ---
			a := buff.ReadInt() // slice len
			for i := range a {

				var b 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
				b = c

				if !yield(fi, pairV(i, b)) {
					return
				}
			}
			// --- [end][read][streaming-slice]([]string) ---

		}

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[map[string]Asset](),
			Name: "Assets",
		}
		if buff.ReadUInt8() == uint8(0) {
			if !yield(fi, nil) {
				return
			}
		} else {
			// --- [begin][read][streaming-map](map[string]Asset) ---
			f := buff.ReadInt() // map len
			for range f {
				var v string
				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
				v = g

				var z Asset
				if buff.ReadUInt8() == uint8(0) {
					z = nil
				} else {
					// --- [begin][read][interface](Asset) ---
					m := buff.ReadString()
					_, n, _ := resolveType(m)
					if _, ok := typeMap[n]; !ok {
						stream.err = fmt.Errorf("Unknown Type: %s", n)
						return

					}

					o, okA := reflect.New(typeMap[n]).Interface().(BinDecoder)
					if !okA {
						stream.err = fmt.Errorf("Type: %s does not implement %s.BinDecoder.", n, GeneratorPackageName)
						return

					}

					buff.ReadInt() // [compatibility, unused]
					errA := o.UnmarshalBinaryWithContext(ctx)
					if errA != nil {
						stream.err = errA
						return

					}
					z = o.(Asset)
					// --- [end][read][interface](Asset) ---

				}

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

		}

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[string](),
			Name: "FromSource",
		}

		var p 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
		p = q
		if !yield(fi, singleV(p)) {
			return
		}

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[Window](),
			Name: "Window",
		}

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

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

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[[]string](),
			Name: "Warnings",
		}
		if buff.ReadUInt8() == uint8(0) {
			if !yield(fi, nil) {
				return
			}
		} else {
			// --- [begin][read][streaming-slice]([]string) ---
			w := buff.ReadInt() // slice len
			for j := range w {

				var x string
				var aa string
				if ctx.IsStringTable() {
					bb := buff.ReadInt() // read string index
					aa = ctx.Table.At(bb)
				} else {
					aa = buff.ReadString() // read string
				}
				y := aa
				x = y

				if !yield(fi, pairV(j, x)) {
					return
				}
			}
			// --- [end][read][streaming-slice]([]string) ---

		}

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[[]string](),
			Name: "Errors",
		}
		if buff.ReadUInt8() == uint8(0) {
			if !yield(fi, nil) {
				return
			}
		} else {
			// --- [begin][read][streaming-slice]([]string) ---
			cc := buff.ReadInt() // slice len
			for ii := range cc {

				var dd 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
				dd = ee

				if !yield(fi, pairV(ii, dd)) {
					return
				}
			}
			// --- [end][read][streaming-slice]([]string) ---

		}

	}
}

//--------------------------------------------------------------------------
//  AssetSetRange
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this AssetSetRange instance
// into a byte array
func (target *AssetSetRange) 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 AssetSetRange instance
// into an io.Writer.
func (target *AssetSetRange) 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 AssetSetRange instance
// into a byte array leveraging a predefined context.
func (target *AssetSetRange) 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(AssetsCodecVersion) // version

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

		// --- [begin][write][slice]([]*AssetSet) ---
		buff.WriteInt(len(target.Assets)) // slice length
		for i := range target.Assets {
			if target.Assets[i] == nil {
				buff.WriteUInt8(uint8(0)) // write nil byte
			} else {
				buff.WriteUInt8(uint8(1)) // write non-nil byte

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

			}
		}
		// --- [end][write][slice]([]*AssetSet) ---

	}

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

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the AssetSetRange type
func (target *AssetSetRange) 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 AssetSetRange type
func (target *AssetSetRange) 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 AssetSetRange type
func (target *AssetSetRange) 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 > AssetsCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling AssetSetRange. Expected %d or less, got %d", AssetsCodecVersion, version)
	}

	if buff.ReadUInt8() == uint8(0) {
		target.Assets = nil
	} else {
		// --- [begin][read][slice]([]*AssetSet) ---
		b := buff.ReadInt() // slice len
		a := make([]*AssetSet, b)
		for i := range b {
			var c *AssetSet
			if buff.ReadUInt8() == uint8(0) {
				c = nil
			} else {
				// --- [begin][read][struct](AssetSet) ---
				d := new(AssetSet)
				buff.ReadInt() // [compatibility, unused]
				errA := d.UnmarshalBinaryWithContext(ctx)
				if errA != nil {
					return errA
				}
				c = d
				// --- [end][read][struct](AssetSet) ---

			}

			a[i] = c
		}
		target.Assets = a
		// --- [end][read][slice]([]*AssetSet) ---

	}

	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
	target.FromStore = e

	return nil
}

//--------------------------------------------------------------------------
//  Breakdown
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this Breakdown instance
// into a byte array
func (target *Breakdown) 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 Breakdown instance
// into an io.Writer.
func (target *Breakdown) 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 Breakdown instance
// into a byte array leveraging a predefined context.
func (target *Breakdown) 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(AssetsCodecVersion) // version

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

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

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

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

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the Breakdown type
func (target *Breakdown) 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 Breakdown type
func (target *Breakdown) 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 Breakdown type
func (target *Breakdown) 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 > AssetsCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling Breakdown. Expected %d or less, got %d", AssetsCodecVersion, version)
	}

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

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

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

	d := buff.ReadFloat64() // read float64
	target.User = d

	return nil
}

//--------------------------------------------------------------------------
//  Cloud
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this Cloud instance
// into a byte array
func (target *Cloud) 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 Cloud instance
// into an io.Writer.
func (target *Cloud) 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 Cloud instance
// into a byte array leveraging a predefined context.
func (target *Cloud) 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(AssetsCodecVersion) // version

	// --- [begin][write][alias](AssetLabels) ---
	if map[string]string(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(map[string]string(target.Labels))) // map length
		for v, z := range map[string]string(target.Labels) {
			if ctx.IsStringTable() {
				a := ctx.Table.AddOrGet(v)
				buff.WriteInt(a) // write table index
			} else {
				buff.WriteString(v) // write string
			}

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

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

	}
	// --- [end][write][alias](AssetLabels) ---
	if target.Properties == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

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

	}

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

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

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

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

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

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

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the Cloud type
func (target *Cloud) 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 Cloud type
func (target *Cloud) 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 Cloud type
func (target *Cloud) 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 > AssetsCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling Cloud. Expected %d or less, got %d", AssetsCodecVersion, version)
	}

	// --- [begin][read][alias](AssetLabels) ---
	var a map[string]string
	if buff.ReadUInt8() == uint8(0) {
		a = nil
	} else {
		// --- [begin][read][map](map[string]string) ---
		c := buff.ReadInt() // map len
		b := make(map[string]string, c)
		for range c {
			var v string
			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
			v = d

			var z string
			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
			z = g

			b[v] = z
		}
		a = b
		// --- [end][read][map](map[string]string) ---

	}

	target.Labels = AssetLabels(a)
	// --- [end][read][alias](AssetLabels) ---

	if buff.ReadUInt8() == uint8(0) {
		target.Properties = nil
	} else {
		// --- [begin][read][struct](AssetProperties) ---
		m := new(AssetProperties)
		buff.ReadInt() // [compatibility, unused]
		errA := m.UnmarshalBinaryWithContext(ctx)
		if errA != nil {
			return errA
		}
		target.Properties = m
		// --- [end][read][struct](AssetProperties) ---

	}

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

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

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

	u := buff.ReadFloat64() // read float64
	target.Adjustment = u

	w := buff.ReadFloat64() // read float64
	target.Cost = w

	x := buff.ReadFloat64() // read float64
	target.Credit = x

	return nil
}

//--------------------------------------------------------------------------
//  CloudCost
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this CloudCost instance
// into a byte array
func (target *CloudCost) 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 CloudCost instance
// into an io.Writer.
func (target *CloudCost) 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 CloudCost instance
// into a byte array leveraging a predefined context.
func (target *CloudCost) 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(CloudCostCodecVersion) // version

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

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

	}

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

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

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

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

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

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

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the CloudCost type
func (target *CloudCost) 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 CloudCost type
func (target *CloudCost) 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 CloudCost type
func (target *CloudCost) 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 > CloudCostCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling CloudCost. Expected %d or less, got %d", CloudCostCodecVersion, version)
	}

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

	}

	// --- [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) ---

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

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

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

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

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

	return nil
}

//--------------------------------------------------------------------------
//  CloudCostProperties
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this CloudCostProperties instance
// into a byte array
func (target *CloudCostProperties) 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 CloudCostProperties instance
// into an io.Writer.
func (target *CloudCostProperties) 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 CloudCostProperties instance
// into a byte array leveraging a predefined context.
func (target *CloudCostProperties) 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(CloudCostCodecVersion) // version

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

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

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

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

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

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

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

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

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

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

	// --- [begin][write][alias](CloudCostLabels) ---
	if map[string]string(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(map[string]string(target.Labels))) // map length
		for v, z := range map[string]string(target.Labels) {
			if ctx.IsStringTable() {
				n := ctx.Table.AddOrGet(v)
				buff.WriteInt(n) // write table index
			} else {
				buff.WriteString(v) // write string
			}

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

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

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

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the CloudCostProperties type
func (target *CloudCostProperties) 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 CloudCostProperties type
func (target *CloudCostProperties) 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 CloudCostProperties type
func (target *CloudCostProperties) 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 > CloudCostCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling CloudCostProperties. Expected %d or less, got %d", CloudCostCodecVersion, 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.ProviderID = 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.Provider = 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.AccountID = g

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

		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.AccountName = m

	} else {
		target.AccountName = "" // default
	}

	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.InvoiceEntityID = p

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

		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
		target.InvoiceEntityName = s

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

		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
		target.RegionID = w

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

		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
		target.AvailabilityZone = aa

	} else {
		target.AvailabilityZone = "" // default
	}

	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
	target.Service = dd

	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.Category = gg

	// --- [begin][read][alias](CloudCostLabels) ---
	var mm map[string]string
	if buff.ReadUInt8() == uint8(0) {
		mm = nil
	} else {
		// --- [begin][read][map](map[string]string) ---
		oo := buff.ReadInt() // map len
		nn := make(map[string]string, oo)
		for range oo {
			var v 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
			v = pp

			var z string
			var tt string
			if ctx.IsStringTable() {
				uu := buff.ReadInt() // read string index
				tt = ctx.Table.At(uu)
			} else {
				tt = buff.ReadString() // read string
			}
			ss := tt
			z = ss

			nn[v] = z
		}
		mm = nn
		// --- [end][read][map](map[string]string) ---

	}

	target.Labels = CloudCostLabels(mm)
	// --- [end][read][alias](CloudCostLabels) ---

	return nil
}

//--------------------------------------------------------------------------
//  CloudCostSet
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this CloudCostSet instance
// into a byte array
func (target *CloudCostSet) 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 CloudCostSet instance
// into an io.Writer.
func (target *CloudCostSet) 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 CloudCostSet instance
// into a byte array leveraging a predefined context.
func (target *CloudCostSet) 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(CloudCostCodecVersion) // version

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

		// --- [begin][write][map](map[string]*CloudCost) ---
		buff.WriteInt(len(target.CloudCosts)) // map length
		for v, z := range target.CloudCosts {
			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](CloudCost) ---
				buff.WriteInt(0) // [compatibility, unused]
				errA := z.MarshalBinaryWithContext(ctx)
				if errA != nil {
					return errA
				}
				// --- [end][write][struct](CloudCost) ---

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

	}

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

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

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

		// --- [begin][write][slice]([]string) ---
		buff.WriteInt(len(target.AggregationProperties)) // slice length
		for i := range target.AggregationProperties {
			if ctx.IsStringTable() {
				c := ctx.Table.AddOrGet(target.AggregationProperties[i])
				buff.WriteInt(c) // write table index
			} else {
				buff.WriteString(target.AggregationProperties[i]) // write string
			}

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

	}

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the CloudCostSet type
func (target *CloudCostSet) 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 CloudCostSet type
func (target *CloudCostSet) 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 CloudCostSet type
func (target *CloudCostSet) 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 > CloudCostCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling CloudCostSet. Expected %d or less, got %d", CloudCostCodecVersion, version)
	}

	if buff.ReadUInt8() == uint8(0) {
		target.CloudCosts = nil
	} else {
		// --- [begin][read][map](map[string]*CloudCost) ---
		b := buff.ReadInt() // map len
		a := make(map[string]*CloudCost, 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

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

			}
			a[v] = z
		}
		target.CloudCosts = a
		// --- [end][read][map](map[string]*CloudCost) ---

	}

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

	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.Integration = h

	if buff.ReadUInt8() == uint8(0) {
		target.AggregationProperties = nil
	} else {
		// --- [begin][read][slice]([]string) ---
		o := buff.ReadInt() // slice len
		n := make([]string, o)
		for i := range o {
			var p 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
			p = q

			n[i] = p
		}
		target.AggregationProperties = n
		// --- [end][read][slice]([]string) ---

	}

	return nil
}

//--------------------------------------------------------------------------
//  CloudCostSetStream
//--------------------------------------------------------------------------

// CloudCostSetStream is a single use field stream for the contents of an CloudCostSet 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 CloudCostSetStream struct {
	reader io.Reader
	ctx    *DecodingContext
	err    error
}

// Closes closes the internal io.Reader used to read and parse the CloudCostSet fields.
// This should be called once the stream is no longer needed.
func (stream *CloudCostSetStream) 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 CloudCostSet
// This can be checked after iterating through the Stream().
func (stream *CloudCostSetStream) Error() error {
	return stream.err
}

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

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

// Stream returns the iterator which will stream each field of the target type.
func (stream *CloudCostSetStream) 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 > CloudCostCodecVersion {
			stream.err = fmt.Errorf("Invalid Version Unmarshalling CloudCostSet. Expected %d or less, got %d", CloudCostCodecVersion, version)
			return
		}

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[map[string]*CloudCost](),
			Name: "CloudCosts",
		}
		if buff.ReadUInt8() == uint8(0) {
			if !yield(fi, nil) {
				return
			}
		} else {
			// --- [begin][read][streaming-map](map[string]*CloudCost) ---
			a := buff.ReadInt() // map len
			for range a {
				var v 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
				v = b

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

					}
					z = e
					// --- [end][read][struct](CloudCost) ---

				}

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

		}

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[Window](),
			Name: "Window",
		}

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

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

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[string](),
			Name: "Integration",
		}

		var h string
		var m string
		if ctx.IsStringTable() {
			n := buff.ReadInt() // read string index
			m = ctx.Table.At(n)
		} else {
			m = buff.ReadString() // read string
		}
		l := m
		h = l
		if !yield(fi, singleV(h)) {
			return
		}

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[[]string](),
			Name: "AggregationProperties",
		}
		if buff.ReadUInt8() == uint8(0) {
			if !yield(fi, nil) {
				return
			}
		} else {
			// --- [begin][read][streaming-slice]([]string) ---
			o := buff.ReadInt() // slice len
			for i := range o {

				var p 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
				p = q

				if !yield(fi, pairV(i, p)) {
					return
				}
			}
			// --- [end][read][streaming-slice]([]string) ---

		}

	}
}

//--------------------------------------------------------------------------
//  CloudCostSetRange
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this CloudCostSetRange instance
// into a byte array
func (target *CloudCostSetRange) 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 CloudCostSetRange instance
// into an io.Writer.
func (target *CloudCostSetRange) 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 CloudCostSetRange instance
// into a byte array leveraging a predefined context.
func (target *CloudCostSetRange) 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(CloudCostCodecVersion) // version

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

		// --- [begin][write][slice]([]*CloudCostSet) ---
		buff.WriteInt(len(target.CloudCostSets)) // slice length
		for i := range target.CloudCostSets {
			if target.CloudCostSets[i] == nil {
				buff.WriteUInt8(uint8(0)) // write nil byte
			} else {
				buff.WriteUInt8(uint8(1)) // write non-nil byte

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

			}
		}
		// --- [end][write][slice]([]*CloudCostSet) ---

	}

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

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the CloudCostSetRange type
func (target *CloudCostSetRange) 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 CloudCostSetRange type
func (target *CloudCostSetRange) 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 CloudCostSetRange type
func (target *CloudCostSetRange) 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 > CloudCostCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling CloudCostSetRange. Expected %d or less, got %d", CloudCostCodecVersion, version)
	}

	if buff.ReadUInt8() == uint8(0) {
		target.CloudCostSets = nil
	} else {
		// --- [begin][read][slice]([]*CloudCostSet) ---
		b := buff.ReadInt() // slice len
		a := make([]*CloudCostSet, b)
		for i := range b {
			var c *CloudCostSet
			if buff.ReadUInt8() == uint8(0) {
				c = nil
			} else {
				// --- [begin][read][struct](CloudCostSet) ---
				d := new(CloudCostSet)
				buff.ReadInt() // [compatibility, unused]
				errA := d.UnmarshalBinaryWithContext(ctx)
				if errA != nil {
					return errA
				}
				c = d
				// --- [end][read][struct](CloudCostSet) ---

			}

			a[i] = c
		}
		target.CloudCostSets = a
		// --- [end][read][slice]([]*CloudCostSet) ---

	}

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

	return nil
}

//--------------------------------------------------------------------------
//  ClusterManagement
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this ClusterManagement instance
// into a byte array
func (target *ClusterManagement) 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 ClusterManagement instance
// into an io.Writer.
func (target *ClusterManagement) 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 ClusterManagement instance
// into a byte array leveraging a predefined context.
func (target *ClusterManagement) 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(AssetsCodecVersion) // version

	// --- [begin][write][alias](AssetLabels) ---
	if map[string]string(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(map[string]string(target.Labels))) // map length
		for v, z := range map[string]string(target.Labels) {
			if ctx.IsStringTable() {
				a := ctx.Table.AddOrGet(v)
				buff.WriteInt(a) // write table index
			} else {
				buff.WriteString(v) // write string
			}

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

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

	}
	// --- [end][write][alias](AssetLabels) ---
	if target.Properties == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

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

	}

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

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

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

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the ClusterManagement type
func (target *ClusterManagement) 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 ClusterManagement type
func (target *ClusterManagement) 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 ClusterManagement type
func (target *ClusterManagement) 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 > AssetsCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling ClusterManagement. Expected %d or less, got %d", AssetsCodecVersion, version)
	}

	// --- [begin][read][alias](AssetLabels) ---
	var a map[string]string
	if buff.ReadUInt8() == uint8(0) {
		a = nil
	} else {
		// --- [begin][read][map](map[string]string) ---
		c := buff.ReadInt() // map len
		b := make(map[string]string, c)
		for range c {
			var v string
			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
			v = d

			var z string
			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
			z = g

			b[v] = z
		}
		a = b
		// --- [end][read][map](map[string]string) ---

	}

	target.Labels = AssetLabels(a)
	// --- [end][read][alias](AssetLabels) ---

	if buff.ReadUInt8() == uint8(0) {
		target.Properties = nil
	} else {
		// --- [begin][read][struct](AssetProperties) ---
		m := new(AssetProperties)
		buff.ReadInt() // [compatibility, unused]
		errA := m.UnmarshalBinaryWithContext(ctx)
		if errA != nil {
			return errA
		}
		target.Properties = m
		// --- [end][read][struct](AssetProperties) ---

	}

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

	o := buff.ReadFloat64() // read float64
	target.Cost = o

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

		p := buff.ReadFloat64() // read float64
		target.Adjustment = p

	} else {
		target.Adjustment = float64(0) // default
	}

	return nil
}

//--------------------------------------------------------------------------
//  CostMetric
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this CostMetric instance
// into a byte array
func (target *CostMetric) 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 CostMetric instance
// into an io.Writer.
func (target *CostMetric) 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 CostMetric instance
// into a byte array leveraging a predefined context.
func (target *CostMetric) 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(CloudCostCodecVersion) // version

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

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

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the CostMetric type
func (target *CostMetric) 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 CostMetric type
func (target *CostMetric) 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 CostMetric type
func (target *CostMetric) 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 > CloudCostCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling CostMetric. Expected %d or less, got %d", CloudCostCodecVersion, version)
	}

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

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

	return nil
}

//--------------------------------------------------------------------------
//  Disk
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this Disk instance
// into a byte array
func (target *Disk) 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 Disk instance
// into an io.Writer.
func (target *Disk) 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 Disk instance
// into a byte array leveraging a predefined context.
func (target *Disk) 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(AssetsCodecVersion) // version

	// --- [begin][write][alias](AssetLabels) ---
	if map[string]string(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(map[string]string(target.Labels))) // map length
		for v, z := range map[string]string(target.Labels) {
			if ctx.IsStringTable() {
				a := ctx.Table.AddOrGet(v)
				buff.WriteInt(a) // write table index
			} else {
				buff.WriteString(v) // write string
			}

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

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

	}
	// --- [end][write][alias](AssetLabels) ---
	if target.Properties == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

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

	}

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

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

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

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

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

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

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

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

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

	}

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

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

		buff.WriteFloat64(*target.ByteHoursUsed) // write float64

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

		buff.WriteFloat64(*target.ByteUsageMax) // write float64

	}

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

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

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

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the Disk type
func (target *Disk) 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 Disk type
func (target *Disk) 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 Disk type
func (target *Disk) 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 > AssetsCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling Disk. Expected %d or less, got %d", AssetsCodecVersion, version)
	}

	// --- [begin][read][alias](AssetLabels) ---
	var a map[string]string
	if buff.ReadUInt8() == uint8(0) {
		a = nil
	} else {
		// --- [begin][read][map](map[string]string) ---
		c := buff.ReadInt() // map len
		b := make(map[string]string, c)
		for range c {
			var v string
			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
			v = d

			var z string
			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
			z = g

			b[v] = z
		}
		a = b
		// --- [end][read][map](map[string]string) ---

	}

	target.Labels = AssetLabels(a)
	// --- [end][read][alias](AssetLabels) ---

	if buff.ReadUInt8() == uint8(0) {
		target.Properties = nil
	} else {
		// --- [begin][read][struct](AssetProperties) ---
		m := new(AssetProperties)
		buff.ReadInt() // [compatibility, unused]
		errA := m.UnmarshalBinaryWithContext(ctx)
		if errA != nil {
			return errA
		}
		target.Properties = m
		// --- [end][read][struct](AssetProperties) ---

	}

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

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

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

	u := buff.ReadFloat64() // read float64
	target.Adjustment = u

	w := buff.ReadFloat64() // read float64
	target.Cost = w

	x := buff.ReadFloat64() // read float64
	target.ByteHours = x

	y := buff.ReadFloat64() // read float64
	target.Local = y

	if buff.ReadUInt8() == uint8(0) {
		target.Breakdown = nil
	} else {

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

	}

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

		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
		target.StorageClass = bb

	} else {
		target.StorageClass = "" // default
	}
	// field version check
	if uint8(18) <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.ByteHoursUsed = nil
		} else {

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

		}

	} else {
		target.ByteHoursUsed = nil
	}
	// field version check
	if uint8(18) <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.ByteUsageMax = nil
		} else {

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

		}

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

		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.VolumeName = gg

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

		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
		target.ClaimName = mm

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

		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
		target.ClaimNamespace = pp

	} else {
		target.ClaimNamespace = "" // default
	}

	return nil
}

//--------------------------------------------------------------------------
//  GPUAllocation
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this GPUAllocation instance
// into a byte array
func (target *GPUAllocation) 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 GPUAllocation instance
// into an io.Writer.
func (target *GPUAllocation) 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 GPUAllocation instance
// into a byte array leveraging a predefined context.
func (target *GPUAllocation) 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(AllocationCodecVersion) // version

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

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

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

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

		buff.WriteBool(*target.IsGPUShared) // write bool

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

		buff.WriteFloat64(*target.GPUUsageAverage) // write float64

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

		buff.WriteFloat64(*target.GPURequestAverage) // write float64

	}

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the GPUAllocation type
func (target *GPUAllocation) 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 GPUAllocation type
func (target *GPUAllocation) 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 GPUAllocation type
func (target *GPUAllocation) 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 > AllocationCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling GPUAllocation. Expected %d or less, got %d", AllocationCodecVersion, 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.GPUDevice = 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.GPUModel = 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.GPUUUID = g

	if buff.ReadUInt8() == uint8(0) {
		target.IsGPUShared = nil
	} else {

		m := buff.ReadBool() // read bool
		target.IsGPUShared = &m

	}

	if buff.ReadUInt8() == uint8(0) {
		target.GPUUsageAverage = nil
	} else {

		n := buff.ReadFloat64() // read float64
		target.GPUUsageAverage = &n

	}

	if buff.ReadUInt8() == uint8(0) {
		target.GPURequestAverage = nil
	} else {

		o := buff.ReadFloat64() // read float64
		target.GPURequestAverage = &o

	}

	return nil
}

//--------------------------------------------------------------------------
//  LbAllocation
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this LbAllocation instance
// into a byte array
func (target *LbAllocation) 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 LbAllocation instance
// into an io.Writer.
func (target *LbAllocation) 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 LbAllocation instance
// into a byte array leveraging a predefined context.
func (target *LbAllocation) 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(AllocationCodecVersion) // version

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

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

	buff.WriteBool(target.Private) // write bool

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

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

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the LbAllocation type
func (target *LbAllocation) 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 LbAllocation type
func (target *LbAllocation) 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 LbAllocation type
func (target *LbAllocation) 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 > AllocationCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling LbAllocation. Expected %d or less, got %d", AllocationCodecVersion, 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.Service = a

	d := buff.ReadFloat64() // read float64
	target.Cost = d

	e := buff.ReadBool() // read bool
	target.Private = e

	// field version check
	if uint8(19) <= 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.Ip = f

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

		l := buff.ReadFloat64() // read float64
		target.Hours = l

	} else {
		target.Hours = float64(0) // default
	}

	return nil
}

//--------------------------------------------------------------------------
//  LoadBalancer
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this LoadBalancer instance
// into a byte array
func (target *LoadBalancer) 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 LoadBalancer instance
// into an io.Writer.
func (target *LoadBalancer) 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 LoadBalancer instance
// into a byte array leveraging a predefined context.
func (target *LoadBalancer) 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(AssetsCodecVersion) // version

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

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

	}

	// --- [begin][write][alias](AssetLabels) ---
	if map[string]string(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(map[string]string(target.Labels))) // map length
		for v, z := range map[string]string(target.Labels) {
			if ctx.IsStringTable() {
				a := ctx.Table.AddOrGet(v)
				buff.WriteInt(a) // write table index
			} else {
				buff.WriteString(v) // write string
			}

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

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

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

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

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

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

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

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

	buff.WriteBool(target.Private) // write bool

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

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the LoadBalancer type
func (target *LoadBalancer) 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 LoadBalancer type
func (target *LoadBalancer) 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 LoadBalancer type
func (target *LoadBalancer) 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 > AssetsCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling LoadBalancer. Expected %d or less, got %d", AssetsCodecVersion, version)
	}

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

	}

	// --- [begin][read][alias](AssetLabels) ---
	var b map[string]string
	if buff.ReadUInt8() == uint8(0) {
		b = nil
	} else {
		// --- [begin][read][map](map[string]string) ---
		d := buff.ReadInt() // map len
		c := make(map[string]string, d)
		for range d {
			var v 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
			v = e

			var z 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
			z = h

			c[v] = z
		}
		b = c
		// --- [end][read][map](map[string]string) ---

	}

	target.Labels = AssetLabels(b)
	// --- [end][read][alias](AssetLabels) ---

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

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

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

	u := buff.ReadFloat64() // read float64
	target.Adjustment = u

	w := buff.ReadFloat64() // read float64
	target.Cost = w

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

		x := buff.ReadBool() // read bool
		target.Private = x

	} else {
		target.Private = false // default
	}
	// field version check
	if uint8(21) <= version {

		var aa string
		if ctx.IsStringTable() {
			bb := buff.ReadInt() // read string index
			aa = ctx.Table.At(bb)
		} else {
			aa = buff.ReadString() // read string
		}
		y := aa
		target.Ip = y

	} else {
		target.Ip = "" // default
	}

	return nil
}

//--------------------------------------------------------------------------
//  Network
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this Network instance
// into a byte array
func (target *Network) 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 Network instance
// into an io.Writer.
func (target *Network) 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 Network instance
// into a byte array leveraging a predefined context.
func (target *Network) 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(AssetsCodecVersion) // version

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

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

	}

	// --- [begin][write][alias](AssetLabels) ---
	if map[string]string(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(map[string]string(target.Labels))) // map length
		for v, z := range map[string]string(target.Labels) {
			if ctx.IsStringTable() {
				a := ctx.Table.AddOrGet(v)
				buff.WriteInt(a) // write table index
			} else {
				buff.WriteString(v) // write string
			}

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

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

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

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

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

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

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

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

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the Network type
func (target *Network) 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 Network type
func (target *Network) 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 Network type
func (target *Network) 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 > AssetsCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling Network. Expected %d or less, got %d", AssetsCodecVersion, version)
	}

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

	}

	// --- [begin][read][alias](AssetLabels) ---
	var b map[string]string
	if buff.ReadUInt8() == uint8(0) {
		b = nil
	} else {
		// --- [begin][read][map](map[string]string) ---
		d := buff.ReadInt() // map len
		c := make(map[string]string, d)
		for range d {
			var v 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
			v = e

			var z 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
			z = h

			c[v] = z
		}
		b = c
		// --- [end][read][map](map[string]string) ---

	}

	target.Labels = AssetLabels(b)
	// --- [end][read][alias](AssetLabels) ---

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

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

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

	u := buff.ReadFloat64() // read float64
	target.Adjustment = u

	w := buff.ReadFloat64() // read float64
	target.Cost = w

	return nil
}

//--------------------------------------------------------------------------
//  NetworkDetail
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this NetworkDetail instance
// into a byte array
func (target *NetworkDetail) 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 NetworkDetail instance
// into an io.Writer.
func (target *NetworkDetail) 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 NetworkDetail instance
// into a byte array leveraging a predefined context.
func (target *NetworkDetail) 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(NetworkInsightCodecVersion) // version

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

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

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

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

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

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

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

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

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

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the NetworkDetail type
func (target *NetworkDetail) 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 NetworkDetail type
func (target *NetworkDetail) 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 NetworkDetail type
func (target *NetworkDetail) 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 > NetworkInsightCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling NetworkDetail. Expected %d or less, got %d", NetworkInsightCodecVersion, version)
	}

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

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

	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
	target.EndPoint = c

	// --- [begin][read][alias](NetworkTrafficDirection) ---
	var f string
	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
	f = g

	target.TrafficDirection = NetworkTrafficDirection(f)
	// --- [end][read][alias](NetworkTrafficDirection) ---

	// --- [begin][read][alias](NetworkTrafficType) ---
	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.TrafficType = NetworkTrafficType(m)
	// --- [end][read][alias](NetworkTrafficType) ---

	return nil
}

//--------------------------------------------------------------------------
//  NetworkInsight
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this NetworkInsight instance
// into a byte array
func (target *NetworkInsight) 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 NetworkInsight instance
// into an io.Writer.
func (target *NetworkInsight) 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 NetworkInsight instance
// into a byte array leveraging a predefined context.
func (target *NetworkInsight) 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(NetworkInsightCodecVersion) // version

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

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

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

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

	if ctx.IsStringTable() {
		e := ctx.Table.AddOrGet(target.Node)
		buff.WriteInt(e) // write table index
	} else {
		buff.WriteString(target.Node) // 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() {
				f := ctx.Table.AddOrGet(v)
				buff.WriteInt(f) // write table index
			} else {
				buff.WriteString(v) // write string
			}

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

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

	}

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

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

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

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

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

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

	// --- [begin][write][alias](NetworkDetailsSet) ---
	if map[string]*NetworkDetail(target.NetworkDetails) == nil {
		buff.WriteUInt8(uint8(0)) // write nil byte
	} else {
		buff.WriteUInt8(uint8(1)) // write non-nil byte

		// --- [begin][write][map](map[string]*NetworkDetail) ---
		buff.WriteInt(len(map[string]*NetworkDetail(target.NetworkDetails))) // map length
		for vv, zz := range map[string]*NetworkDetail(target.NetworkDetails) {
			if ctx.IsStringTable() {
				m := ctx.Table.AddOrGet(vv)
				buff.WriteInt(m) // 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](NetworkDetail) ---
				buff.WriteInt(0) // [compatibility, unused]
				errA := zz.MarshalBinaryWithContext(ctx)
				if errA != nil {
					return errA
				}
				// --- [end][write][struct](NetworkDetail) ---

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

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

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the NetworkInsight type
func (target *NetworkInsight) 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 NetworkInsight type
func (target *NetworkInsight) 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 NetworkInsight type
func (target *NetworkInsight) 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 > NetworkInsightCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling NetworkInsight. Expected %d or less, got %d", NetworkInsightCodecVersion, 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.Cluster = 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.Namespace = 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.Controller = 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.Pod = 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.Node = p

	if buff.ReadUInt8() == uint8(0) {
		target.Labels = nil
	} else {
		// --- [begin][read][map](map[string]string) ---
		t := buff.ReadInt() // map len
		s := make(map[string]string, 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

			var z string
			var aa string
			if ctx.IsStringTable() {
				bb := buff.ReadInt() // read string index
				aa = ctx.Table.At(bb)
			} else {
				aa = buff.ReadString() // read string
			}
			y := aa
			z = y

			s[v] = z
		}
		target.Labels = s
		// --- [end][read][map](map[string]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
	target.Region = cc

	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
	target.Zone = ff

	ll := buff.ReadFloat64() // read float64
	target.NetworkTotalCost = ll

	mm := buff.ReadFloat64() // read float64
	target.NetworkCrossZoneCost = mm

	nn := buff.ReadFloat64() // read float64
	target.NetworkCrossRegionCost = nn

	oo := buff.ReadFloat64() // read float64
	target.NetworkInternetCost = oo

	// --- [begin][read][alias](NetworkDetailsSet) ---
	var pp map[string]*NetworkDetail
	if buff.ReadUInt8() == uint8(0) {
		pp = nil
	} else {
		// --- [begin][read][map](map[string]*NetworkDetail) ---
		rr := buff.ReadInt() // map len
		qq := make(map[string]*NetworkDetail, rr)
		for range rr {
			var vv string
			var tt string
			if ctx.IsStringTable() {
				uu := buff.ReadInt() // read string index
				tt = ctx.Table.At(uu)
			} else {
				tt = buff.ReadString() // read string
			}
			ss := tt
			vv = ss

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

			}
			qq[vv] = zz
		}
		pp = qq
		// --- [end][read][map](map[string]*NetworkDetail) ---

	}

	target.NetworkDetails = NetworkDetailsSet(pp)
	// --- [end][read][alias](NetworkDetailsSet) ---

	return nil
}

//--------------------------------------------------------------------------
//  NetworkInsightSet
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this NetworkInsightSet instance
// into a byte array
func (target *NetworkInsightSet) 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 NetworkInsightSet instance
// into an io.Writer.
func (target *NetworkInsightSet) 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 NetworkInsightSet instance
// into a byte array leveraging a predefined context.
func (target *NetworkInsightSet) 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(NetworkInsightCodecVersion) // version

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

		// --- [begin][write][map](map[string]*NetworkInsight) ---
		buff.WriteInt(len(target.NetworkInsights)) // map length
		for v, z := range target.NetworkInsights {
			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](NetworkInsight) ---
				buff.WriteInt(0) // [compatibility, unused]
				errA := z.MarshalBinaryWithContext(ctx)
				if errA != nil {
					return errA
				}
				// --- [end][write][struct](NetworkInsight) ---

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

	}

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

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the NetworkInsightSet type
func (target *NetworkInsightSet) 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 NetworkInsightSet type
func (target *NetworkInsightSet) 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 NetworkInsightSet type
func (target *NetworkInsightSet) 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 > NetworkInsightCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling NetworkInsightSet. Expected %d or less, got %d", NetworkInsightCodecVersion, version)
	}

	if buff.ReadUInt8() == uint8(0) {
		target.NetworkInsights = nil
	} else {
		// --- [begin][read][map](map[string]*NetworkInsight) ---
		b := buff.ReadInt() // map len
		a := make(map[string]*NetworkInsight, 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

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

			}
			a[v] = z
		}
		target.NetworkInsights = a
		// --- [end][read][map](map[string]*NetworkInsight) ---

	}

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

	return nil
}

//--------------------------------------------------------------------------
//  NetworkInsightSetStream
//--------------------------------------------------------------------------

// NetworkInsightSetStream is a single use field stream for the contents of an NetworkInsightSet 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 NetworkInsightSetStream struct {
	reader io.Reader
	ctx    *DecodingContext
	err    error
}

// Closes closes the internal io.Reader used to read and parse the NetworkInsightSet fields.
// This should be called once the stream is no longer needed.
func (stream *NetworkInsightSetStream) 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 NetworkInsightSet
// This can be checked after iterating through the Stream().
func (stream *NetworkInsightSetStream) Error() error {
	return stream.err
}

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

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

// Stream returns the iterator which will stream each field of the target type.
func (stream *NetworkInsightSetStream) 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 > NetworkInsightCodecVersion {
			stream.err = fmt.Errorf("Invalid Version Unmarshalling NetworkInsightSet. Expected %d or less, got %d", NetworkInsightCodecVersion, version)
			return
		}

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[map[string]*NetworkInsight](),
			Name: "NetworkInsights",
		}
		if buff.ReadUInt8() == uint8(0) {
			if !yield(fi, nil) {
				return
			}
		} else {
			// --- [begin][read][streaming-map](map[string]*NetworkInsight) ---
			a := buff.ReadInt() // map len
			for range a {
				var v 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
				v = b

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

					}
					z = e
					// --- [end][read][struct](NetworkInsight) ---

				}

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

		}

		fi = BingenFieldInfo{
			Type: reflect.TypeFor[Window](),
			Name: "Window",
		}

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

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

	}
}

//--------------------------------------------------------------------------
//  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(AssetsCodecVersion) // version

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

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

	}

	// --- [begin][write][alias](AssetLabels) ---
	if map[string]string(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(map[string]string(target.Labels))) // map length
		for v, z := range map[string]string(target.Labels) {
			if ctx.IsStringTable() {
				a := ctx.Table.AddOrGet(v)
				buff.WriteInt(a) // write table index
			} else {
				buff.WriteString(v) // write string
			}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	}

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

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

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

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

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

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

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

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

	}

	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 > AssetsCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling Node. Expected %d or less, got %d", AssetsCodecVersion, version)
	}

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

	}

	// --- [begin][read][alias](AssetLabels) ---
	var b map[string]string
	if buff.ReadUInt8() == uint8(0) {
		b = nil
	} else {
		// --- [begin][read][map](map[string]string) ---
		d := buff.ReadInt() // map len
		c := make(map[string]string, d)
		for range d {
			var v 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
			v = e

			var z 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
			z = h

			c[v] = z
		}
		b = c
		// --- [end][read][map](map[string]string) ---

	}

	target.Labels = AssetLabels(b)
	// --- [end][read][alias](AssetLabels) ---

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

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

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

	u := buff.ReadFloat64() // read float64
	target.Adjustment = u

	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
	target.NodeType = w

	aa := buff.ReadFloat64() // read float64
	target.CPUCoreHours = aa

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

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

	if buff.ReadUInt8() == uint8(0) {
		target.CPUBreakdown = nil
	} else {
		// --- [begin][read][struct](Breakdown) ---
		dd := new(Breakdown)
		buff.ReadInt() // [compatibility, unused]
		errE := dd.UnmarshalBinaryWithContext(ctx)
		if errE != nil {
			return errE
		}
		target.CPUBreakdown = dd
		// --- [end][read][struct](Breakdown) ---

	}

	if buff.ReadUInt8() == uint8(0) {
		target.RAMBreakdown = nil
	} else {
		// --- [begin][read][struct](Breakdown) ---
		ee := new(Breakdown)
		buff.ReadInt() // [compatibility, unused]
		errF := ee.UnmarshalBinaryWithContext(ctx)
		if errF != nil {
			return errF
		}
		target.RAMBreakdown = ee
		// --- [end][read][struct](Breakdown) ---

	}

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

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

	hh := buff.ReadFloat64() // read float64
	target.GPUCount = hh

	ll := buff.ReadFloat64() // read float64
	target.RAMCost = ll

	mm := buff.ReadFloat64() // read float64
	target.Discount = mm

	nn := buff.ReadFloat64() // read float64
	target.Preemptible = nn

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

		}

	} else {
		target.Overhead = nil
	}

	return nil
}

//--------------------------------------------------------------------------
//  NodeOverhead
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this NodeOverhead instance
// into a byte array
func (target *NodeOverhead) 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 NodeOverhead instance
// into an io.Writer.
func (target *NodeOverhead) 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 NodeOverhead instance
// into a byte array leveraging a predefined context.
func (target *NodeOverhead) 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(AssetsCodecVersion) // version

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

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

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

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the NodeOverhead type
func (target *NodeOverhead) 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 NodeOverhead type
func (target *NodeOverhead) 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 NodeOverhead type
func (target *NodeOverhead) 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 > AssetsCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling NodeOverhead. Expected %d or less, got %d", AssetsCodecVersion, version)
	}

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

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

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

	return nil
}

//--------------------------------------------------------------------------
//  PVAllocation
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this PVAllocation instance
// into a byte array
func (target *PVAllocation) 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 PVAllocation instance
// into an io.Writer.
func (target *PVAllocation) 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 PVAllocation instance
// into a byte array leveraging a predefined context.
func (target *PVAllocation) 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(AllocationCodecVersion) // version

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

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

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

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the PVAllocation type
func (target *PVAllocation) 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 PVAllocation type
func (target *PVAllocation) 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 PVAllocation type
func (target *PVAllocation) 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 > AllocationCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling PVAllocation. Expected %d or less, got %d", AllocationCodecVersion, version)
	}

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

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

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

		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
		target.ProviderID = c

	} else {
		target.ProviderID = "" // default
	}

	return nil
}

//--------------------------------------------------------------------------
//  PVKey
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this PVKey instance
// into a byte array
func (target *PVKey) 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 PVKey instance
// into an io.Writer.
func (target *PVKey) 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 PVKey instance
// into a byte array leveraging a predefined context.
func (target *PVKey) 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(AllocationCodecVersion) // version

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

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

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the PVKey type
func (target *PVKey) 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 PVKey type
func (target *PVKey) 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 PVKey type
func (target *PVKey) 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 > AllocationCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling PVKey. Expected %d or less, got %d", AllocationCodecVersion, 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.Cluster = 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

	return nil
}

//--------------------------------------------------------------------------
//  RawAllocationOnlyData
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this RawAllocationOnlyData instance
// into a byte array
func (target *RawAllocationOnlyData) 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 RawAllocationOnlyData instance
// into an io.Writer.
func (target *RawAllocationOnlyData) 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 RawAllocationOnlyData instance
// into a byte array leveraging a predefined context.
func (target *RawAllocationOnlyData) 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(AllocationCodecVersion) // version

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

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

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

		buff.WriteFloat64(*target.GPUUsageMax) // write float64

	}

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the RawAllocationOnlyData type
func (target *RawAllocationOnlyData) 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 RawAllocationOnlyData type
func (target *RawAllocationOnlyData) 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 RawAllocationOnlyData type
func (target *RawAllocationOnlyData) 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 > AllocationCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling RawAllocationOnlyData. Expected %d or less, got %d", AllocationCodecVersion, version)
	}

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

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

	// field version check
	if uint8(23) <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.GPUUsageMax = nil
		} else {

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

		}

	} else {
		target.GPUUsageMax = nil
	}

	return nil
}

//--------------------------------------------------------------------------
//  SharedAsset
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this SharedAsset instance
// into a byte array
func (target *SharedAsset) 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 SharedAsset instance
// into an io.Writer.
func (target *SharedAsset) 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 SharedAsset instance
// into a byte array leveraging a predefined context.
func (target *SharedAsset) 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(AssetsCodecVersion) // version

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

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

	}

	// --- [begin][write][alias](AssetLabels) ---
	if map[string]string(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(map[string]string(target.Labels))) // map length
		for v, z := range map[string]string(target.Labels) {
			if ctx.IsStringTable() {
				a := ctx.Table.AddOrGet(v)
				buff.WriteInt(a) // write table index
			} else {
				buff.WriteString(v) // write string
			}

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

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

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

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

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

	return nil
}

// UnmarshalBinary uses the data passed byte array to set all the internal properties of
// the SharedAsset type
func (target *SharedAsset) 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 SharedAsset type
func (target *SharedAsset) 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 SharedAsset type
func (target *SharedAsset) 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 > AssetsCodecVersion {
		return fmt.Errorf("Invalid Version Unmarshalling SharedAsset. Expected %d or less, got %d", AssetsCodecVersion, version)
	}

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

	}

	// --- [begin][read][alias](AssetLabels) ---
	var b map[string]string
	if buff.ReadUInt8() == uint8(0) {
		b = nil
	} else {
		// --- [begin][read][map](map[string]string) ---
		d := buff.ReadInt() // map len
		c := make(map[string]string, d)
		for range d {
			var v 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
			v = e

			var z 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
			z = h

			c[v] = z
		}
		b = c
		// --- [end][read][map](map[string]string) ---

	}

	target.Labels = AssetLabels(b)
	// --- [end][read][alias](AssetLabels) ---

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

	o := buff.ReadFloat64() // read float64
	target.Cost = o

	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

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

		// --- [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) ---

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

		// --- [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)
	}

	if buff.ReadUInt8() == uint8(0) {
		target.start = nil
	} else {

		// --- [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) ---

	}

	if buff.ReadUInt8() == uint8(0) {
		target.end = nil
	} else {

		// --- [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) ---

	}

	return nil
}