cost-model/pkg/kubecost/kubecost_codecs.go

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

package kubecost

import (
	"fmt"
	util "github.com/kubecost/cost-model/pkg/util"
	"reflect"
	"strings"
	"sync"
	"time"
)

const (
	// GeneratorPackageName is the package the generator is targetting
	GeneratorPackageName string = "kubecost"
)

// BinaryTags represent the formatting tag used for specific optimization features
const (
	// 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"
)

const (
	// DefaultCodecVersion is used for any resources listed in the Default version set
	DefaultCodecVersion uint8 = 15

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

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

//--------------------------------------------------------------------------
//  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.TypeOf((*Allocation)(nil)).Elem(),
	"AllocationProperties":  reflect.TypeOf((*AllocationProperties)(nil)).Elem(),
	"AllocationSet":         reflect.TypeOf((*AllocationSet)(nil)).Elem(),
	"AllocationSetRange":    reflect.TypeOf((*AllocationSetRange)(nil)).Elem(),
	"Any":                   reflect.TypeOf((*Any)(nil)).Elem(),
	"AssetProperties":       reflect.TypeOf((*AssetProperties)(nil)).Elem(),
	"AssetSet":              reflect.TypeOf((*AssetSet)(nil)).Elem(),
	"AssetSetRange":         reflect.TypeOf((*AssetSetRange)(nil)).Elem(),
	"Breakdown":             reflect.TypeOf((*Breakdown)(nil)).Elem(),
	"Cloud":                 reflect.TypeOf((*Cloud)(nil)).Elem(),
	"ClusterManagement":     reflect.TypeOf((*ClusterManagement)(nil)).Elem(),
	"Disk":                  reflect.TypeOf((*Disk)(nil)).Elem(),
	"LoadBalancer":          reflect.TypeOf((*LoadBalancer)(nil)).Elem(),
	"Network":               reflect.TypeOf((*Network)(nil)).Elem(),
	"Node":                  reflect.TypeOf((*Node)(nil)).Elem(),
	"PVAllocation":          reflect.TypeOf((*PVAllocation)(nil)).Elem(),
	"PVKey":                 reflect.TypeOf((*PVKey)(nil)).Elem(),
	"RawAllocationOnlyData": reflect.TypeOf((*RawAllocationOnlyData)(nil)).Elem(),
	"SharedAsset":           reflect.TypeOf((*SharedAsset)(nil)).Elem(),
	"Window":                reflect.TypeOf((*Window)(nil)).Elem(),
}

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

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

// appendBytes combines a and b into a new byte array
func appendBytes(a []byte, b []byte) []byte {
	al := len(a)
	bl := len(b)
	tl := al + bl

	// allocate a new byte array for the combined
	// use native copy for speedy byte copying
	result := make([]byte, tl, tl)
	copy(result, a)
	copy(result[al:], b)

	return result
}

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

//--------------------------------------------------------------------------
//  StringTable
//--------------------------------------------------------------------------

// StringTable maps strings to specific indices for encoding
type StringTable struct {
	l       *sync.Mutex
	indices map[string]int
	next    int
}

// NewStringTable Creates a new StringTable instance with provided contents
func NewStringTable(contents ...string) *StringTable {
	st := &StringTable{
		l:       new(sync.Mutex),
		indices: make(map[string]int),
		next:    len(contents),
	}

	for i, entry := range contents {
		st.indices[entry] = i
	}

	return st
}

// AddOrGet atomically retrieves a string entry's index if it exist. Otherwise, it will
// add the entry and return the index.
func (st *StringTable) AddOrGet(s string) int {
	st.l.Lock()
	defer st.l.Unlock()

	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 *StringTable) ToSlice() []string {
	st.l.Lock()
	defer st.l.Unlock()

	if st.next == 0 {
		return []string{}
	}

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

// ToBytes Converts the contents to a binary encoded representation
func (st *StringTable) ToBytes() []byte {
	buff := util.NewBuffer()
	buff.WriteBytes([]byte(BinaryTagStringTable)) // bingen table header

	strs := st.ToSlice()

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

	return buff.Bytes()
}

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

// 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  []string
}

// IsStringTable returns true if the table is available
func (dc *DecodingContext) IsStringTable() bool {
	return len(dc.Table) > 0
}

//--------------------------------------------------------------------------
//  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 := &EncodingContext{
		Buffer: util.NewBuffer(),
		Table:  nil,
	}

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

	encBytes := ctx.Buffer.Bytes()
	return encBytes, nil
}

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

	}
	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 {
	var table []string
	buff := util.NewBufferFromBytes(data)

	// string table header validation
	if isBinaryTag(data, BinaryTagStringTable) {
		buff.ReadBytes(len(BinaryTagStringTable)) // strip tag length
		tl := buff.ReadInt()                      // table length
		if tl > 0 {
			table = make([]string, tl, tl)
			for i := 0; i < tl; i++ {
				table[i] = buff.ReadString()
			}
		}
	}

	ctx := &DecodingContext{
		Buffer: buff,
		Table:  table,
	}

	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 Unmarshaling Allocation. Expected %d or less, got %d", AllocationCodecVersion, version)
	}

	if uint8(0) /* field version */ <= version {
		var b string
		if ctx.IsStringTable() {
			c := buff.ReadInt() // read string index
			b = ctx.Table[c]
		} else {
			b = buff.ReadString() // read string
		}
		a := b
		target.Name = a

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

	if uint8(0) /* field version */ <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.Properties = nil
		} else {
			// --- [begin][read][struct](AllocationProperties) ---
			d := &AllocationProperties{}
			buff.ReadInt() // [compatibility, unused]
			errA := d.UnmarshalBinaryWithContext(ctx)
			if errA != nil {
				return errA
			}
			target.Properties = d
			// --- [end][read][struct](AllocationProperties) ---

		}
	} else {
		target.Properties = nil

	}

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

	} else {
	}

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

	} else {
	}

	if uint8(0) /* field version */ <= version {
		// --- [begin][read][reference](time.Time) ---
		k := &time.Time{}
		l := buff.ReadInt()    // byte array length
		m := buff.ReadBytes(l) // byte array
		errD := k.UnmarshalBinary(m)
		if errD != nil {
			return errD
		}
		target.End = *k
		// --- [end][read][reference](time.Time) ---

	} else {
	}

	if uint8(0) /* field version */ <= version {
		n := buff.ReadFloat64() // read float64
		target.CPUCoreHours = n

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

	if uint8(0) /* field version */ <= version {
		o := buff.ReadFloat64() // read float64
		target.CPUCoreRequestAverage = o

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

	if uint8(0) /* field version */ <= version {
		p := buff.ReadFloat64() // read float64
		target.CPUCoreUsageAverage = p

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

	if uint8(0) /* field version */ <= version {
		q := buff.ReadFloat64() // read float64
		target.CPUCost = q

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

	if uint8(0) /* field version */ <= version {
		r := buff.ReadFloat64() // read float64
		target.CPUCostAdjustment = r

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

	if uint8(0) /* field version */ <= version {
		s := buff.ReadFloat64() // read float64
		target.GPUHours = s

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

	if uint8(0) /* field version */ <= version {
		t := buff.ReadFloat64() // read float64
		target.GPUCost = t

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

	if uint8(0) /* field version */ <= version {
		u := buff.ReadFloat64() // read float64
		target.GPUCostAdjustment = u

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

	if uint8(0) /* field version */ <= version {
		w := buff.ReadFloat64() // read float64
		target.NetworkTransferBytes = w

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

	if uint8(0) /* field version */ <= version {
		x := buff.ReadFloat64() // read float64
		target.NetworkReceiveBytes = x

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

	if uint8(0) /* field version */ <= version {
		y := buff.ReadFloat64() // read float64
		target.NetworkCost = y

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

	if uint8(0) /* field version */ <= version {
		aa := buff.ReadFloat64() // read float64
		target.NetworkCostAdjustment = aa

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

	if uint8(0) /* field version */ <= version {
		bb := buff.ReadFloat64() // read float64
		target.LoadBalancerCost = bb

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

	if uint8(0) /* field version */ <= version {
		cc := buff.ReadFloat64() // read float64
		target.LoadBalancerCostAdjustment = cc

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

	if uint8(0) /* field version */ <= version {
		// --- [begin][read][alias](PVAllocations) ---
		var dd map[PVKey]*PVAllocation
		if buff.ReadUInt8() == uint8(0) {
			dd = nil
		} else {
			// --- [begin][read][map](map[PVKey]*PVAllocation) ---
			ff := buff.ReadInt() // map len
			ee := make(map[PVKey]*PVAllocation, ff)
			for i := 0; i < ff; i++ {
				// --- [begin][read][struct](PVKey) ---
				gg := &PVKey{}
				buff.ReadInt() // [compatibility, unused]
				errE := gg.UnmarshalBinaryWithContext(ctx)
				if errE != nil {
					return errE
				}
				v := *gg
				// --- [end][read][struct](PVKey) ---

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

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

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

	} else {
	}

	if uint8(0) /* field version */ <= version {
		kk := buff.ReadFloat64() // read float64
		target.PVCostAdjustment = kk

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

	if uint8(0) /* field version */ <= version {
		ll := buff.ReadFloat64() // read float64
		target.RAMByteHours = ll

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

	if uint8(0) /* field version */ <= version {
		mm := buff.ReadFloat64() // read float64
		target.RAMBytesRequestAverage = mm

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

	if uint8(0) /* field version */ <= version {
		nn := buff.ReadFloat64() // read float64
		target.RAMBytesUsageAverage = nn

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

	if uint8(0) /* field version */ <= version {
		oo := buff.ReadFloat64() // read float64
		target.RAMCost = oo

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

	if uint8(0) /* field version */ <= version {
		pp := buff.ReadFloat64() // read float64
		target.RAMCostAdjustment = pp

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

	if uint8(0) /* field version */ <= version {
		qq := buff.ReadFloat64() // read float64
		target.SharedCost = qq

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

	if uint8(0) /* field version */ <= version {
		rr := buff.ReadFloat64() // read float64
		target.ExternalCost = rr

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

	if uint8(0) /* field version */ <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.RawAllocationOnly = nil
		} else {
			// --- [begin][read][struct](RawAllocationOnlyData) ---
			ss := &RawAllocationOnlyData{}
			buff.ReadInt() // [compatibility, unused]
			errG := ss.UnmarshalBinaryWithContext(ctx)
			if errG != nil {
				return errG
			}
			target.RawAllocationOnly = ss
			// --- [end][read][struct](RawAllocationOnlyData) ---

		}
	} else {
		target.RawAllocationOnly = nil

	}

	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 := &EncodingContext{
		Buffer: util.NewBuffer(),
		Table:  nil,
	}

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

	encBytes := ctx.Buffer.Bytes()
	return encBytes, nil
}

// 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)) // array length
		for i := 0; i < len(target.Services); i++ {
			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() {
		k := ctx.Table.AddOrGet(target.ProviderID)
		buff.WriteInt(k) // 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() {
				l := ctx.Table.AddOrGet(v)
				buff.WriteInt(l) // write table index
			} else {
				buff.WriteString(v) // write string
			}
			if ctx.IsStringTable() {
				m := ctx.Table.AddOrGet(z)
				buff.WriteInt(m) // 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() {
				n := ctx.Table.AddOrGet(vv)
				buff.WriteInt(n) // write table index
			} else {
				buff.WriteString(vv) // write string
			}
			if ctx.IsStringTable() {
				o := ctx.Table.AddOrGet(zz)
				buff.WriteInt(o) // write table index
			} else {
				buff.WriteString(zz) // 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 {
	var table []string
	buff := util.NewBufferFromBytes(data)

	// string table header validation
	if isBinaryTag(data, BinaryTagStringTable) {
		buff.ReadBytes(len(BinaryTagStringTable)) // strip tag length
		tl := buff.ReadInt()                      // table length
		if tl > 0 {
			table = make([]string, tl, tl)
			for i := 0; i < tl; i++ {
				table[i] = buff.ReadString()
			}
		}
	}

	ctx := &DecodingContext{
		Buffer: buff,
		Table:  table,
	}

	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 Unmarshaling AllocationProperties. Expected %d or less, got %d", AllocationCodecVersion, version)
	}

	if uint8(0) /* field version */ <= version {
		var b string
		if ctx.IsStringTable() {
			c := buff.ReadInt() // read string index
			b = ctx.Table[c]
		} else {
			b = buff.ReadString() // read string
		}
		a := b
		target.Cluster = a

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

	if uint8(0) /* field version */ <= version {
		var e string
		if ctx.IsStringTable() {
			f := buff.ReadInt() // read string index
			e = ctx.Table[f]
		} else {
			e = buff.ReadString() // read string
		}
		d := e
		target.Node = d

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

	if uint8(0) /* field version */ <= version {
		var h string
		if ctx.IsStringTable() {
			k := buff.ReadInt() // read string index
			h = ctx.Table[k]
		} else {
			h = buff.ReadString() // read string
		}
		g := h
		target.Container = g

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

	if uint8(0) /* field version */ <= version {
		var m string
		if ctx.IsStringTable() {
			n := buff.ReadInt() // read string index
			m = ctx.Table[n]
		} else {
			m = buff.ReadString() // read string
		}
		l := m
		target.Controller = l

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

	if uint8(0) /* field version */ <= version {
		var p string
		if ctx.IsStringTable() {
			q := buff.ReadInt() // read string index
			p = ctx.Table[q]
		} else {
			p = buff.ReadString() // read string
		}
		o := p
		target.ControllerKind = o

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

	if uint8(0) /* field version */ <= version {
		var s string
		if ctx.IsStringTable() {
			t := buff.ReadInt() // read string index
			s = ctx.Table[t]
		} else {
			s = buff.ReadString() // read string
		}
		r := s
		target.Namespace = r

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

	if uint8(0) /* field version */ <= version {
		var w string
		if ctx.IsStringTable() {
			x := buff.ReadInt() // read string index
			w = ctx.Table[x]
		} else {
			w = buff.ReadString() // read string
		}
		u := w
		target.Pod = u

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

	if uint8(0) /* field version */ <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.Services = nil
		} else {
			// --- [begin][read][slice]([]string) ---
			aa := buff.ReadInt() // array len
			y := make([]string, aa)
			for i := 0; i < aa; i++ {
				var bb string
				var dd string
				if ctx.IsStringTable() {
					ee := buff.ReadInt() // read string index
					dd = ctx.Table[ee]
				} else {
					dd = buff.ReadString() // read string
				}
				cc := dd
				bb = cc

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

		}
	} else {
		target.Services = nil

	}

	if uint8(0) /* field version */ <= version {
		var gg string
		if ctx.IsStringTable() {
			hh := buff.ReadInt() // read string index
			gg = ctx.Table[hh]
		} else {
			gg = buff.ReadString() // read string
		}
		ff := gg
		target.ProviderID = ff

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

	if uint8(0) /* field version */ <= version {
		// --- [begin][read][alias](AllocationLabels) ---
		var kk map[string]string
		if buff.ReadUInt8() == uint8(0) {
			kk = nil
		} else {
			// --- [begin][read][map](map[string]string) ---
			mm := buff.ReadInt() // map len
			ll := make(map[string]string, mm)
			for j := 0; j < mm; j++ {
				var v string
				var oo string
				if ctx.IsStringTable() {
					pp := buff.ReadInt() // read string index
					oo = ctx.Table[pp]
				} else {
					oo = buff.ReadString() // read string
				}
				nn := oo
				v = nn

				var z string
				var rr string
				if ctx.IsStringTable() {
					ss := buff.ReadInt() // read string index
					rr = ctx.Table[ss]
				} else {
					rr = buff.ReadString() // read string
				}
				qq := rr
				z = qq

				ll[v] = z
			}
			kk = ll
			// --- [end][read][map](map[string]string) ---

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

	} else {
	}

	if uint8(0) /* field version */ <= version {
		// --- [begin][read][alias](AllocationAnnotations) ---
		var tt map[string]string
		if buff.ReadUInt8() == uint8(0) {
			tt = nil
		} else {
			// --- [begin][read][map](map[string]string) ---
			ww := buff.ReadInt() // map len
			uu := make(map[string]string, ww)
			for ii := 0; ii < ww; ii++ {
				var vv string
				var yy string
				if ctx.IsStringTable() {
					aaa := buff.ReadInt() // read string index
					yy = ctx.Table[aaa]
				} else {
					yy = buff.ReadString() // read string
				}
				xx := yy
				vv = xx

				var zz string
				var ccc string
				if ctx.IsStringTable() {
					ddd := buff.ReadInt() // read string index
					ccc = ctx.Table[ddd]
				} else {
					ccc = buff.ReadString() // read string
				}
				bbb := ccc
				zz = bbb

				uu[vv] = zz
			}
			tt = uu
			// --- [end][read][map](map[string]string) ---

		}
		target.Annotations = AllocationAnnotations(tt)
		// --- [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 := &EncodingContext{
		Buffer: util.NewBuffer(),
		Table:  NewStringTable(),
	}

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

	encBytes := ctx.Buffer.Bytes()
	sTableBytes := ctx.Table.ToBytes()
	merged := appendBytes(sTableBytes, encBytes)
	return merged, nil
}

// 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)) // array length
		for i := 0; i < len(target.Warnings); i++ {
			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)) // array length
		for j := 0; j < len(target.Errors); j++ {
			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 {
	var table []string
	buff := util.NewBufferFromBytes(data)

	// string table header validation
	if isBinaryTag(data, BinaryTagStringTable) {
		buff.ReadBytes(len(BinaryTagStringTable)) // strip tag length
		tl := buff.ReadInt()                      // table length
		if tl > 0 {
			table = make([]string, tl, tl)
			for i := 0; i < tl; i++ {
				table[i] = buff.ReadString()
			}
		}
	}

	ctx := &DecodingContext{
		Buffer: buff,
		Table:  table,
	}

	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 Unmarshaling AllocationSet. Expected %d or less, got %d", AllocationCodecVersion, version)
	}

	if uint8(0) /* field version */ <= 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 i := 0; i < b; i++ {
				var v string
				var d string
				if ctx.IsStringTable() {
					e := buff.ReadInt() // read string index
					d = ctx.Table[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 := &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) ---

		}
	} else {
		target.allocations = nil

	}

	if uint8(0) /* field version */ <= version {
		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 j := 0; j < h; j++ {
				var vv string
				var l string
				if ctx.IsStringTable() {
					m := buff.ReadInt() // read string index
					l = ctx.Table[m]
				} else {
					l = buff.ReadString() // read string
				}
				k := l
				vv = k

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

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

		}
	} else {
		target.externalKeys = nil

	}

	if uint8(0) /* field version */ <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.idleKeys = nil
		} else {
			// --- [begin][read][map](map[string]bool) ---
			p := buff.ReadInt() // map len
			o := make(map[string]bool, p)
			for ii := 0; ii < p; ii++ {
				var vvv string
				var r string
				if ctx.IsStringTable() {
					s := buff.ReadInt() // read string index
					r = ctx.Table[s]
				} else {
					r = buff.ReadString() // read string
				}
				q := r
				vvv = q

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

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

		}
	} else {
		target.idleKeys = nil

	}

	if uint8(0) /* field version */ <= version {
		var w string
		if ctx.IsStringTable() {
			x := buff.ReadInt() // read string index
			w = ctx.Table[x]
		} else {
			w = buff.ReadString() // read string
		}
		u := w
		target.FromSource = u

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

	if uint8(0) /* field version */ <= version {
		// --- [begin][read][struct](Window) ---
		y := &Window{}
		buff.ReadInt() // [compatibility, unused]
		errB := y.UnmarshalBinaryWithContext(ctx)
		if errB != nil {
			return errB
		}
		target.Window = *y
		// --- [end][read][struct](Window) ---

	} else {
	}

	if uint8(0) /* field version */ <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.Warnings = nil
		} else {
			// --- [begin][read][slice]([]string) ---
			bb := buff.ReadInt() // array len
			aa := make([]string, bb)
			for jj := 0; jj < bb; jj++ {
				var cc string
				var ee string
				if ctx.IsStringTable() {
					ff := buff.ReadInt() // read string index
					ee = ctx.Table[ff]
				} else {
					ee = buff.ReadString() // read string
				}
				dd := ee
				cc = dd

				aa[jj] = cc
			}
			target.Warnings = aa
			// --- [end][read][slice]([]string) ---

		}
	} else {
		target.Warnings = nil

	}

	if uint8(0) /* field version */ <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.Errors = nil
		} else {
			// --- [begin][read][slice]([]string) ---
			hh := buff.ReadInt() // array len
			gg := make([]string, hh)
			for iii := 0; iii < hh; iii++ {
				var kk string
				var mm string
				if ctx.IsStringTable() {
					nn := buff.ReadInt() // read string index
					mm = ctx.Table[nn]
				} else {
					mm = buff.ReadString() // read string
				}
				ll := mm
				kk = ll

				gg[iii] = kk
			}
			target.Errors = gg
			// --- [end][read][slice]([]string) ---

		}
	} else {
		target.Errors = nil

	}

	return nil
}

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

// MarshalBinary serializes the internal properties of this AllocationSetRange instance
// into a byte array
func (target *AllocationSetRange) MarshalBinary() (data []byte, err error) {
	ctx := &EncodingContext{
		Buffer: util.NewBuffer(),
		Table:  nil,
	}

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

	encBytes := ctx.Buffer.Bytes()
	return encBytes, nil
}

// 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)) // array length
		for i := 0; i < len(target.allocations); i++ {
			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 {
	var table []string
	buff := util.NewBufferFromBytes(data)

	// string table header validation
	if isBinaryTag(data, BinaryTagStringTable) {
		buff.ReadBytes(len(BinaryTagStringTable)) // strip tag length
		tl := buff.ReadInt()                      // table length
		if tl > 0 {
			table = make([]string, tl, tl)
			for i := 0; i < tl; i++ {
				table[i] = buff.ReadString()
			}
		}
	}

	ctx := &DecodingContext{
		Buffer: buff,
		Table:  table,
	}

	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 Unmarshaling AllocationSetRange. Expected %d or less, got %d", AllocationCodecVersion, version)
	}

	if uint8(0) /* field version */ <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.allocations = nil
		} else {
			// --- [begin][read][slice]([]*AllocationSet) ---
			b := buff.ReadInt() // array len
			a := make([]*AllocationSet, b)
			for i := 0; i < b; i++ {
				var c *AllocationSet
				if buff.ReadUInt8() == uint8(0) {
					c = nil
				} else {
					// --- [begin][read][struct](AllocationSet) ---
					d := &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) ---

		}
	} else {
		target.allocations = nil

	}

	if uint8(0) /* field version */ <= version {
		var f string
		if ctx.IsStringTable() {
			g := buff.ReadInt() // read string index
			f = ctx.Table[g]
		} else {
			f = buff.ReadString() // read string
		}
		e := f
		target.FromStore = e

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

	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 := &EncodingContext{
		Buffer: util.NewBuffer(),
		Table:  nil,
	}

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

	encBytes := ctx.Buffer.Bytes()
	return encBytes, nil
}

// 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 {
	var table []string
	buff := util.NewBufferFromBytes(data)

	// string table header validation
	if isBinaryTag(data, BinaryTagStringTable) {
		buff.ReadBytes(len(BinaryTagStringTable)) // strip tag length
		tl := buff.ReadInt()                      // table length
		if tl > 0 {
			table = make([]string, tl, tl)
			for i := 0; i < tl; i++ {
				table[i] = buff.ReadString()
			}
		}
	}

	ctx := &DecodingContext{
		Buffer: buff,
		Table:  table,
	}

	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 Unmarshaling Any. Expected %d or less, got %d", AssetsCodecVersion, version)
	}

	if uint8(0) /* field version */ <= 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 i := 0; i < c; i++ {
				var v string
				var e string
				if ctx.IsStringTable() {
					f := buff.ReadInt() // read string index
					e = ctx.Table[f]
				} else {
					e = buff.ReadString() // read string
				}
				d := e
				v = d

				var z string
				var h string
				if ctx.IsStringTable() {
					k := buff.ReadInt() // read string index
					h = ctx.Table[k]
				} 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) ---

	} else {
	}

	if uint8(0) /* field version */ <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.properties = nil
		} else {
			// --- [begin][read][struct](AssetProperties) ---
			l := &AssetProperties{}
			buff.ReadInt() // [compatibility, unused]
			errA := l.UnmarshalBinaryWithContext(ctx)
			if errA != nil {
				return errA
			}
			target.properties = l
			// --- [end][read][struct](AssetProperties) ---

		}
	} else {
		target.properties = nil

	}

	if uint8(0) /* field version */ <= version {
		// --- [begin][read][reference](time.Time) ---
		m := &time.Time{}
		n := buff.ReadInt()    // byte array length
		o := buff.ReadBytes(n) // byte array
		errB := m.UnmarshalBinary(o)
		if errB != nil {
			return errB
		}
		target.start = *m
		// --- [end][read][reference](time.Time) ---

	} else {
	}

	if uint8(0) /* field version */ <= version {
		// --- [begin][read][reference](time.Time) ---
		p := &time.Time{}
		q := buff.ReadInt()    // byte array length
		r := buff.ReadBytes(q) // byte array
		errC := p.UnmarshalBinary(r)
		if errC != nil {
			return errC
		}
		target.end = *p
		// --- [end][read][reference](time.Time) ---

	} else {
	}

	if uint8(0) /* field version */ <= version {
		// --- [begin][read][struct](Window) ---
		s := &Window{}
		buff.ReadInt() // [compatibility, unused]
		errD := s.UnmarshalBinaryWithContext(ctx)
		if errD != nil {
			return errD
		}
		target.window = *s
		// --- [end][read][struct](Window) ---

	} else {
	}

	if uint8(0) /* field version */ <= version {
		t := buff.ReadFloat64() // read float64
		target.adjustment = t

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

	if uint8(0) /* field version */ <= version {
		u := buff.ReadFloat64() // read float64
		target.Cost = u

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

	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 := &EncodingContext{
		Buffer: util.NewBuffer(),
		Table:  nil,
	}

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

	encBytes := ctx.Buffer.Bytes()
	return encBytes, nil
}

// 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 {
	var table []string
	buff := util.NewBufferFromBytes(data)

	// string table header validation
	if isBinaryTag(data, BinaryTagStringTable) {
		buff.ReadBytes(len(BinaryTagStringTable)) // strip tag length
		tl := buff.ReadInt()                      // table length
		if tl > 0 {
			table = make([]string, tl, tl)
			for i := 0; i < tl; i++ {
				table[i] = buff.ReadString()
			}
		}
	}

	ctx := &DecodingContext{
		Buffer: buff,
		Table:  table,
	}

	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 Unmarshaling AssetProperties. Expected %d or less, got %d", AssetsCodecVersion, version)
	}

	if uint8(0) /* field version */ <= version {
		var b string
		if ctx.IsStringTable() {
			c := buff.ReadInt() // read string index
			b = ctx.Table[c]
		} else {
			b = buff.ReadString() // read string
		}
		a := b
		target.Category = a

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

	if uint8(0) /* field version */ <= version {
		var e string
		if ctx.IsStringTable() {
			f := buff.ReadInt() // read string index
			e = ctx.Table[f]
		} else {
			e = buff.ReadString() // read string
		}
		d := e
		target.Provider = d

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

	if uint8(0) /* field version */ <= version {
		var h string
		if ctx.IsStringTable() {
			k := buff.ReadInt() // read string index
			h = ctx.Table[k]
		} else {
			h = buff.ReadString() // read string
		}
		g := h
		target.Account = g

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

	if uint8(0) /* field version */ <= version {
		var m string
		if ctx.IsStringTable() {
			n := buff.ReadInt() // read string index
			m = ctx.Table[n]
		} else {
			m = buff.ReadString() // read string
		}
		l := m
		target.Project = l

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

	if uint8(0) /* field version */ <= version {
		var p string
		if ctx.IsStringTable() {
			q := buff.ReadInt() // read string index
			p = ctx.Table[q]
		} else {
			p = buff.ReadString() // read string
		}
		o := p
		target.Service = o

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

	if uint8(0) /* field version */ <= version {
		var s string
		if ctx.IsStringTable() {
			t := buff.ReadInt() // read string index
			s = ctx.Table[t]
		} else {
			s = buff.ReadString() // read string
		}
		r := s
		target.Cluster = r

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

	if uint8(0) /* field version */ <= version {
		var w string
		if ctx.IsStringTable() {
			x := buff.ReadInt() // read string index
			w = ctx.Table[x]
		} else {
			w = buff.ReadString() // read string
		}
		u := w
		target.Name = u

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

	if uint8(0) /* field version */ <= version {
		var aa string
		if ctx.IsStringTable() {
			bb := buff.ReadInt() // read string index
			aa = ctx.Table[bb]
		} else {
			aa = buff.ReadString() // read string
		}
		y := aa
		target.ProviderID = y

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

	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 := &EncodingContext{
		Buffer: util.NewBuffer(),
		Table:  NewStringTable(),
	}

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

	encBytes := ctx.Buffer.Bytes()
	sTableBytes := ctx.Table.ToBytes()
	merged := appendBytes(sTableBytes, encBytes)
	return merged, nil
}

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

	if target.aggregateBy == 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.aggregateBy)) // array length
		for i := 0; i < len(target.aggregateBy); i++ {
			if ctx.IsStringTable() {
				a := ctx.Table.AddOrGet(target.aggregateBy[i])
				buff.WriteInt(a) // write table index
			} else {
				buff.WriteString(target.aggregateBy[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)) // array length
		for j := 0; j < len(target.Warnings); j++ {
			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)) // array length
		for ii := 0; ii < len(target.Errors); ii++ {
			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 {
	var table []string
	buff := util.NewBufferFromBytes(data)

	// string table header validation
	if isBinaryTag(data, BinaryTagStringTable) {
		buff.ReadBytes(len(BinaryTagStringTable)) // strip tag length
		tl := buff.ReadInt()                      // table length
		if tl > 0 {
			table = make([]string, tl, tl)
			for i := 0; i < tl; i++ {
				table[i] = buff.ReadString()
			}
		}
	}

	ctx := &DecodingContext{
		Buffer: buff,
		Table:  table,
	}

	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 Unmarshaling AssetSet. Expected %d or less, got %d", AssetsCodecVersion, version)
	}

	if uint8(0) /* field version */ <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.aggregateBy = nil
		} else {
			// --- [begin][read][slice]([]string) ---
			b := buff.ReadInt() // array len
			a := make([]string, b)
			for i := 0; i < b; i++ {
				var c string
				var e string
				if ctx.IsStringTable() {
					f := buff.ReadInt() // read string index
					e = ctx.Table[f]
				} else {
					e = buff.ReadString() // read string
				}
				d := e
				c = d

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

		}
	} else {
		target.aggregateBy = nil

	}

	if uint8(0) /* field version */ <= version {
		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 j := 0; j < h; j++ {
				var v string
				var l string
				if ctx.IsStringTable() {
					m := buff.ReadInt() // read string index
					l = ctx.Table[m]
				} else {
					l = buff.ReadString() // read string
				}
				k := l
				v = k

				var z Asset
				if buff.ReadUInt8() == uint8(0) {
					z = nil
				} else {
					// --- [begin][read][interface](Asset) ---
					n := buff.ReadString()
					_, o, _ := resolveType(n)
					if _, ok := typeMap[o]; !ok {
						return fmt.Errorf("Unknown Type: %s", o)
					}
					p, okA := reflect.New(typeMap[o]).Interface().(BinDecoder)
					if !okA {
						return fmt.Errorf("Type: %s does not implement %s.BinDecoder.", o, GeneratorPackageName)
					}
					buff.ReadInt() // [compatibility, unused]
					errA := p.UnmarshalBinaryWithContext(ctx)
					if errA != nil {
						return errA
					}
					z = p.(Asset)
					// --- [end][read][interface](Asset) ---

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

		}
	} else {
		target.assets = nil

	}

	if uint8(0) /* field version */ <= version {
		var r string
		if ctx.IsStringTable() {
			s := buff.ReadInt() // read string index
			r = ctx.Table[s]
		} else {
			r = buff.ReadString() // read string
		}
		q := r
		target.FromSource = q

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

	if uint8(0) /* field version */ <= version {
		// --- [begin][read][struct](Window) ---
		t := &Window{}
		buff.ReadInt() // [compatibility, unused]
		errB := t.UnmarshalBinaryWithContext(ctx)
		if errB != nil {
			return errB
		}
		target.Window = *t
		// --- [end][read][struct](Window) ---

	} else {
	}

	if uint8(0) /* field version */ <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.Warnings = nil
		} else {
			// --- [begin][read][slice]([]string) ---
			w := buff.ReadInt() // array len
			u := make([]string, w)
			for ii := 0; ii < w; ii++ {
				var x string
				var aa string
				if ctx.IsStringTable() {
					bb := buff.ReadInt() // read string index
					aa = ctx.Table[bb]
				} else {
					aa = buff.ReadString() // read string
				}
				y := aa
				x = y

				u[ii] = x
			}
			target.Warnings = u
			// --- [end][read][slice]([]string) ---

		}
	} else {
		target.Warnings = nil

	}

	if uint8(0) /* field version */ <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.Errors = nil
		} else {
			// --- [begin][read][slice]([]string) ---
			dd := buff.ReadInt() // array len
			cc := make([]string, dd)
			for jj := 0; jj < dd; jj++ {
				var ee string
				var gg string
				if ctx.IsStringTable() {
					hh := buff.ReadInt() // read string index
					gg = ctx.Table[hh]
				} else {
					gg = buff.ReadString() // read string
				}
				ff := gg
				ee = ff

				cc[jj] = ee
			}
			target.Errors = cc
			// --- [end][read][slice]([]string) ---

		}
	} else {
		target.Errors = nil

	}

	return nil
}

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

// MarshalBinary serializes the internal properties of this AssetSetRange instance
// into a byte array
func (target *AssetSetRange) MarshalBinary() (data []byte, err error) {
	ctx := &EncodingContext{
		Buffer: util.NewBuffer(),
		Table:  nil,
	}

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

	encBytes := ctx.Buffer.Bytes()
	return encBytes, nil
}

// 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)) // array length
		for i := 0; i < len(target.assets); i++ {
			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 {
	var table []string
	buff := util.NewBufferFromBytes(data)

	// string table header validation
	if isBinaryTag(data, BinaryTagStringTable) {
		buff.ReadBytes(len(BinaryTagStringTable)) // strip tag length
		tl := buff.ReadInt()                      // table length
		if tl > 0 {
			table = make([]string, tl, tl)
			for i := 0; i < tl; i++ {
				table[i] = buff.ReadString()
			}
		}
	}

	ctx := &DecodingContext{
		Buffer: buff,
		Table:  table,
	}

	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 Unmarshaling AssetSetRange. Expected %d or less, got %d", AssetsCodecVersion, version)
	}

	if uint8(0) /* field version */ <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.assets = nil
		} else {
			// --- [begin][read][slice]([]*AssetSet) ---
			b := buff.ReadInt() // array len
			a := make([]*AssetSet, b)
			for i := 0; i < b; i++ {
				var c *AssetSet
				if buff.ReadUInt8() == uint8(0) {
					c = nil
				} else {
					// --- [begin][read][struct](AssetSet) ---
					d := &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) ---

		}
	} else {
		target.assets = nil

	}

	if uint8(0) /* field version */ <= version {
		var f string
		if ctx.IsStringTable() {
			g := buff.ReadInt() // read string index
			f = ctx.Table[g]
		} else {
			f = buff.ReadString() // read string
		}
		e := f
		target.FromStore = e

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

	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 := &EncodingContext{
		Buffer: util.NewBuffer(),
		Table:  nil,
	}

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

	encBytes := ctx.Buffer.Bytes()
	return encBytes, nil
}

// 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 {
	var table []string
	buff := util.NewBufferFromBytes(data)

	// string table header validation
	if isBinaryTag(data, BinaryTagStringTable) {
		buff.ReadBytes(len(BinaryTagStringTable)) // strip tag length
		tl := buff.ReadInt()                      // table length
		if tl > 0 {
			table = make([]string, tl, tl)
			for i := 0; i < tl; i++ {
				table[i] = buff.ReadString()
			}
		}
	}

	ctx := &DecodingContext{
		Buffer: buff,
		Table:  table,
	}

	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 Unmarshaling Breakdown. Expected %d or less, got %d", AssetsCodecVersion, version)
	}

	if uint8(0) /* field version */ <= version {
		a := buff.ReadFloat64() // read float64
		target.Idle = a

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

	if uint8(0) /* field version */ <= version {
		b := buff.ReadFloat64() // read float64
		target.Other = b

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

	if uint8(0) /* field version */ <= version {
		c := buff.ReadFloat64() // read float64
		target.System = c

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

	if uint8(0) /* field version */ <= version {
		d := buff.ReadFloat64() // read float64
		target.User = d

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

	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 := &EncodingContext{
		Buffer: util.NewBuffer(),
		Table:  nil,
	}

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

	encBytes := ctx.Buffer.Bytes()
	return encBytes, nil
}

// 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 {
	var table []string
	buff := util.NewBufferFromBytes(data)

	// string table header validation
	if isBinaryTag(data, BinaryTagStringTable) {
		buff.ReadBytes(len(BinaryTagStringTable)) // strip tag length
		tl := buff.ReadInt()                      // table length
		if tl > 0 {
			table = make([]string, tl, tl)
			for i := 0; i < tl; i++ {
				table[i] = buff.ReadString()
			}
		}
	}

	ctx := &DecodingContext{
		Buffer: buff,
		Table:  table,
	}

	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 Unmarshaling Cloud. Expected %d or less, got %d", AssetsCodecVersion, version)
	}

	if uint8(0) /* field version */ <= 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 i := 0; i < c; i++ {
				var v string
				var e string
				if ctx.IsStringTable() {
					f := buff.ReadInt() // read string index
					e = ctx.Table[f]
				} else {
					e = buff.ReadString() // read string
				}
				d := e
				v = d

				var z string
				var h string
				if ctx.IsStringTable() {
					k := buff.ReadInt() // read string index
					h = ctx.Table[k]
				} 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) ---

	} else {
	}

	if uint8(0) /* field version */ <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.properties = nil
		} else {
			// --- [begin][read][struct](AssetProperties) ---
			l := &AssetProperties{}
			buff.ReadInt() // [compatibility, unused]
			errA := l.UnmarshalBinaryWithContext(ctx)
			if errA != nil {
				return errA
			}
			target.properties = l
			// --- [end][read][struct](AssetProperties) ---

		}
	} else {
		target.properties = nil

	}

	if uint8(0) /* field version */ <= version {
		// --- [begin][read][reference](time.Time) ---
		m := &time.Time{}
		n := buff.ReadInt()    // byte array length
		o := buff.ReadBytes(n) // byte array
		errB := m.UnmarshalBinary(o)
		if errB != nil {
			return errB
		}
		target.start = *m
		// --- [end][read][reference](time.Time) ---

	} else {
	}

	if uint8(0) /* field version */ <= version {
		// --- [begin][read][reference](time.Time) ---
		p := &time.Time{}
		q := buff.ReadInt()    // byte array length
		r := buff.ReadBytes(q) // byte array
		errC := p.UnmarshalBinary(r)
		if errC != nil {
			return errC
		}
		target.end = *p
		// --- [end][read][reference](time.Time) ---

	} else {
	}

	if uint8(0) /* field version */ <= version {
		// --- [begin][read][struct](Window) ---
		s := &Window{}
		buff.ReadInt() // [compatibility, unused]
		errD := s.UnmarshalBinaryWithContext(ctx)
		if errD != nil {
			return errD
		}
		target.window = *s
		// --- [end][read][struct](Window) ---

	} else {
	}

	if uint8(0) /* field version */ <= version {
		t := buff.ReadFloat64() // read float64
		target.adjustment = t

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

	if uint8(0) /* field version */ <= version {
		u := buff.ReadFloat64() // read float64
		target.Cost = u

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

	if uint8(0) /* field version */ <= version {
		w := buff.ReadFloat64() // read float64
		target.Credit = w

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

	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 := &EncodingContext{
		Buffer: util.NewBuffer(),
		Table:  nil,
	}

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

	encBytes := ctx.Buffer.Bytes()
	return encBytes, nil
}

// 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
	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 {
	var table []string
	buff := util.NewBufferFromBytes(data)

	// string table header validation
	if isBinaryTag(data, BinaryTagStringTable) {
		buff.ReadBytes(len(BinaryTagStringTable)) // strip tag length
		tl := buff.ReadInt()                      // table length
		if tl > 0 {
			table = make([]string, tl, tl)
			for i := 0; i < tl; i++ {
				table[i] = buff.ReadString()
			}
		}
	}

	ctx := &DecodingContext{
		Buffer: buff,
		Table:  table,
	}

	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 Unmarshaling ClusterManagement. Expected %d or less, got %d", AssetsCodecVersion, version)
	}

	if uint8(0) /* field version */ <= 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 i := 0; i < c; i++ {
				var v string
				var e string
				if ctx.IsStringTable() {
					f := buff.ReadInt() // read string index
					e = ctx.Table[f]
				} else {
					e = buff.ReadString() // read string
				}
				d := e
				v = d

				var z string
				var h string
				if ctx.IsStringTable() {
					k := buff.ReadInt() // read string index
					h = ctx.Table[k]
				} 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) ---

	} else {
	}

	if uint8(0) /* field version */ <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.properties = nil
		} else {
			// --- [begin][read][struct](AssetProperties) ---
			l := &AssetProperties{}
			buff.ReadInt() // [compatibility, unused]
			errA := l.UnmarshalBinaryWithContext(ctx)
			if errA != nil {
				return errA
			}
			target.properties = l
			// --- [end][read][struct](AssetProperties) ---

		}
	} else {
		target.properties = nil

	}

	if uint8(0) /* field version */ <= version {
		// --- [begin][read][struct](Window) ---
		m := &Window{}
		buff.ReadInt() // [compatibility, unused]
		errB := m.UnmarshalBinaryWithContext(ctx)
		if errB != nil {
			return errB
		}
		target.window = *m
		// --- [end][read][struct](Window) ---

	} else {
	}

	if uint8(0) /* field version */ <= version {
		n := buff.ReadFloat64() // read float64
		target.Cost = n

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

	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 := &EncodingContext{
		Buffer: util.NewBuffer(),
		Table:  nil,
	}

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

	encBytes := ctx.Buffer.Bytes()
	return encBytes, nil
}

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

	}
	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 {
	var table []string
	buff := util.NewBufferFromBytes(data)

	// string table header validation
	if isBinaryTag(data, BinaryTagStringTable) {
		buff.ReadBytes(len(BinaryTagStringTable)) // strip tag length
		tl := buff.ReadInt()                      // table length
		if tl > 0 {
			table = make([]string, tl, tl)
			for i := 0; i < tl; i++ {
				table[i] = buff.ReadString()
			}
		}
	}

	ctx := &DecodingContext{
		Buffer: buff,
		Table:  table,
	}

	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 Unmarshaling Disk. Expected %d or less, got %d", AssetsCodecVersion, version)
	}

	if uint8(0) /* field version */ <= 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 i := 0; i < c; i++ {
				var v string
				var e string
				if ctx.IsStringTable() {
					f := buff.ReadInt() // read string index
					e = ctx.Table[f]
				} else {
					e = buff.ReadString() // read string
				}
				d := e
				v = d

				var z string
				var h string
				if ctx.IsStringTable() {
					k := buff.ReadInt() // read string index
					h = ctx.Table[k]
				} 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) ---

	} else {
	}

	if uint8(0) /* field version */ <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.properties = nil
		} else {
			// --- [begin][read][struct](AssetProperties) ---
			l := &AssetProperties{}
			buff.ReadInt() // [compatibility, unused]
			errA := l.UnmarshalBinaryWithContext(ctx)
			if errA != nil {
				return errA
			}
			target.properties = l
			// --- [end][read][struct](AssetProperties) ---

		}
	} else {
		target.properties = nil

	}

	if uint8(0) /* field version */ <= version {
		// --- [begin][read][reference](time.Time) ---
		m := &time.Time{}
		n := buff.ReadInt()    // byte array length
		o := buff.ReadBytes(n) // byte array
		errB := m.UnmarshalBinary(o)
		if errB != nil {
			return errB
		}
		target.start = *m
		// --- [end][read][reference](time.Time) ---

	} else {
	}

	if uint8(0) /* field version */ <= version {
		// --- [begin][read][reference](time.Time) ---
		p := &time.Time{}
		q := buff.ReadInt()    // byte array length
		r := buff.ReadBytes(q) // byte array
		errC := p.UnmarshalBinary(r)
		if errC != nil {
			return errC
		}
		target.end = *p
		// --- [end][read][reference](time.Time) ---

	} else {
	}

	if uint8(0) /* field version */ <= version {
		// --- [begin][read][struct](Window) ---
		s := &Window{}
		buff.ReadInt() // [compatibility, unused]
		errD := s.UnmarshalBinaryWithContext(ctx)
		if errD != nil {
			return errD
		}
		target.window = *s
		// --- [end][read][struct](Window) ---

	} else {
	}

	if uint8(0) /* field version */ <= version {
		t := buff.ReadFloat64() // read float64
		target.adjustment = t

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

	if uint8(0) /* field version */ <= version {
		u := buff.ReadFloat64() // read float64
		target.Cost = u

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

	if uint8(0) /* field version */ <= version {
		w := buff.ReadFloat64() // read float64
		target.ByteHours = w

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

	if uint8(0) /* field version */ <= version {
		x := buff.ReadFloat64() // read float64
		target.Local = x

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

	if uint8(0) /* field version */ <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.Breakdown = nil
		} else {
			// --- [begin][read][struct](Breakdown) ---
			y := &Breakdown{}
			buff.ReadInt() // [compatibility, unused]
			errE := y.UnmarshalBinaryWithContext(ctx)
			if errE != nil {
				return errE
			}
			target.Breakdown = y
			// --- [end][read][struct](Breakdown) ---

		}
	} else {
		target.Breakdown = nil

	}

	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 := &EncodingContext{
		Buffer: util.NewBuffer(),
		Table:  nil,
	}

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

	encBytes := ctx.Buffer.Bytes()
	return encBytes, nil
}

// 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
	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 {
	var table []string
	buff := util.NewBufferFromBytes(data)

	// string table header validation
	if isBinaryTag(data, BinaryTagStringTable) {
		buff.ReadBytes(len(BinaryTagStringTable)) // strip tag length
		tl := buff.ReadInt()                      // table length
		if tl > 0 {
			table = make([]string, tl, tl)
			for i := 0; i < tl; i++ {
				table[i] = buff.ReadString()
			}
		}
	}

	ctx := &DecodingContext{
		Buffer: buff,
		Table:  table,
	}

	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 Unmarshaling LoadBalancer. Expected %d or less, got %d", AssetsCodecVersion, version)
	}

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

		}
	} else {
		target.properties = nil

	}

	if uint8(0) /* field version */ <= version {
		// --- [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 i := 0; i < d; i++ {
				var v string
				var f string
				if ctx.IsStringTable() {
					g := buff.ReadInt() // read string index
					f = ctx.Table[g]
				} else {
					f = buff.ReadString() // read string
				}
				e := f
				v = e

				var z string
				var k string
				if ctx.IsStringTable() {
					l := buff.ReadInt() // read string index
					k = ctx.Table[l]
				} else {
					k = buff.ReadString() // read string
				}
				h := k
				z = h

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

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

	} else {
	}

	if uint8(0) /* field version */ <= version {
		// --- [begin][read][reference](time.Time) ---
		m := &time.Time{}
		n := buff.ReadInt()    // byte array length
		o := buff.ReadBytes(n) // byte array
		errB := m.UnmarshalBinary(o)
		if errB != nil {
			return errB
		}
		target.start = *m
		// --- [end][read][reference](time.Time) ---

	} else {
	}

	if uint8(0) /* field version */ <= version {
		// --- [begin][read][reference](time.Time) ---
		p := &time.Time{}
		q := buff.ReadInt()    // byte array length
		r := buff.ReadBytes(q) // byte array
		errC := p.UnmarshalBinary(r)
		if errC != nil {
			return errC
		}
		target.end = *p
		// --- [end][read][reference](time.Time) ---

	} else {
	}

	if uint8(0) /* field version */ <= version {
		// --- [begin][read][struct](Window) ---
		s := &Window{}
		buff.ReadInt() // [compatibility, unused]
		errD := s.UnmarshalBinaryWithContext(ctx)
		if errD != nil {
			return errD
		}
		target.window = *s
		// --- [end][read][struct](Window) ---

	} else {
	}

	if uint8(0) /* field version */ <= version {
		t := buff.ReadFloat64() // read float64
		target.adjustment = t

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

	if uint8(0) /* field version */ <= version {
		u := buff.ReadFloat64() // read float64
		target.Cost = u

	} else {
		target.Cost = float64(0) // 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 := &EncodingContext{
		Buffer: util.NewBuffer(),
		Table:  nil,
	}

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

	encBytes := ctx.Buffer.Bytes()
	return encBytes, nil
}

// 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 {
	var table []string
	buff := util.NewBufferFromBytes(data)

	// string table header validation
	if isBinaryTag(data, BinaryTagStringTable) {
		buff.ReadBytes(len(BinaryTagStringTable)) // strip tag length
		tl := buff.ReadInt()                      // table length
		if tl > 0 {
			table = make([]string, tl, tl)
			for i := 0; i < tl; i++ {
				table[i] = buff.ReadString()
			}
		}
	}

	ctx := &DecodingContext{
		Buffer: buff,
		Table:  table,
	}

	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 Unmarshaling Network. Expected %d or less, got %d", AssetsCodecVersion, version)
	}

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

		}
	} else {
		target.properties = nil

	}

	if uint8(0) /* field version */ <= version {
		// --- [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 i := 0; i < d; i++ {
				var v string
				var f string
				if ctx.IsStringTable() {
					g := buff.ReadInt() // read string index
					f = ctx.Table[g]
				} else {
					f = buff.ReadString() // read string
				}
				e := f
				v = e

				var z string
				var k string
				if ctx.IsStringTable() {
					l := buff.ReadInt() // read string index
					k = ctx.Table[l]
				} else {
					k = buff.ReadString() // read string
				}
				h := k
				z = h

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

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

	} else {
	}

	if uint8(0) /* field version */ <= version {
		// --- [begin][read][reference](time.Time) ---
		m := &time.Time{}
		n := buff.ReadInt()    // byte array length
		o := buff.ReadBytes(n) // byte array
		errB := m.UnmarshalBinary(o)
		if errB != nil {
			return errB
		}
		target.start = *m
		// --- [end][read][reference](time.Time) ---

	} else {
	}

	if uint8(0) /* field version */ <= version {
		// --- [begin][read][reference](time.Time) ---
		p := &time.Time{}
		q := buff.ReadInt()    // byte array length
		r := buff.ReadBytes(q) // byte array
		errC := p.UnmarshalBinary(r)
		if errC != nil {
			return errC
		}
		target.end = *p
		// --- [end][read][reference](time.Time) ---

	} else {
	}

	if uint8(0) /* field version */ <= version {
		// --- [begin][read][struct](Window) ---
		s := &Window{}
		buff.ReadInt() // [compatibility, unused]
		errD := s.UnmarshalBinaryWithContext(ctx)
		if errD != nil {
			return errD
		}
		target.window = *s
		// --- [end][read][struct](Window) ---

	} else {
	}

	if uint8(0) /* field version */ <= version {
		t := buff.ReadFloat64() // read float64
		target.adjustment = t

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

	if uint8(0) /* field version */ <= version {
		u := buff.ReadFloat64() // read float64
		target.Cost = u

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

	return nil
}

//--------------------------------------------------------------------------
//  Node
//--------------------------------------------------------------------------

// MarshalBinary serializes the internal properties of this Node instance
// into a byte array
func (target *Node) MarshalBinary() (data []byte, err error) {
	ctx := &EncodingContext{
		Buffer: util.NewBuffer(),
		Table:  nil,
	}

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

	encBytes := ctx.Buffer.Bytes()
	return encBytes, nil
}

// 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
	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 {
	var table []string
	buff := util.NewBufferFromBytes(data)

	// string table header validation
	if isBinaryTag(data, BinaryTagStringTable) {
		buff.ReadBytes(len(BinaryTagStringTable)) // strip tag length
		tl := buff.ReadInt()                      // table length
		if tl > 0 {
			table = make([]string, tl, tl)
			for i := 0; i < tl; i++ {
				table[i] = buff.ReadString()
			}
		}
	}

	ctx := &DecodingContext{
		Buffer: buff,
		Table:  table,
	}

	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 Unmarshaling Node. Expected %d or less, got %d", AssetsCodecVersion, version)
	}

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

		}
	} else {
		target.properties = nil

	}

	if uint8(0) /* field version */ <= version {
		// --- [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 i := 0; i < d; i++ {
				var v string
				var f string
				if ctx.IsStringTable() {
					g := buff.ReadInt() // read string index
					f = ctx.Table[g]
				} else {
					f = buff.ReadString() // read string
				}
				e := f
				v = e

				var z string
				var k string
				if ctx.IsStringTable() {
					l := buff.ReadInt() // read string index
					k = ctx.Table[l]
				} else {
					k = buff.ReadString() // read string
				}
				h := k
				z = h

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

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

	} else {
	}

	if uint8(0) /* field version */ <= version {
		// --- [begin][read][reference](time.Time) ---
		m := &time.Time{}
		n := buff.ReadInt()    // byte array length
		o := buff.ReadBytes(n) // byte array
		errB := m.UnmarshalBinary(o)
		if errB != nil {
			return errB
		}
		target.start = *m
		// --- [end][read][reference](time.Time) ---

	} else {
	}

	if uint8(0) /* field version */ <= version {
		// --- [begin][read][reference](time.Time) ---
		p := &time.Time{}
		q := buff.ReadInt()    // byte array length
		r := buff.ReadBytes(q) // byte array
		errC := p.UnmarshalBinary(r)
		if errC != nil {
			return errC
		}
		target.end = *p
		// --- [end][read][reference](time.Time) ---

	} else {
	}

	if uint8(0) /* field version */ <= version {
		// --- [begin][read][struct](Window) ---
		s := &Window{}
		buff.ReadInt() // [compatibility, unused]
		errD := s.UnmarshalBinaryWithContext(ctx)
		if errD != nil {
			return errD
		}
		target.window = *s
		// --- [end][read][struct](Window) ---

	} else {
	}

	if uint8(0) /* field version */ <= version {
		t := buff.ReadFloat64() // read float64
		target.adjustment = t

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

	if uint8(0) /* field version */ <= version {
		var w string
		if ctx.IsStringTable() {
			x := buff.ReadInt() // read string index
			w = ctx.Table[x]
		} else {
			w = buff.ReadString() // read string
		}
		u := w
		target.NodeType = u

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

	if uint8(0) /* field version */ <= version {
		y := buff.ReadFloat64() // read float64
		target.CPUCoreHours = y

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

	if uint8(0) /* field version */ <= version {
		aa := buff.ReadFloat64() // read float64
		target.RAMByteHours = aa

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

	if uint8(0) /* field version */ <= version {
		bb := buff.ReadFloat64() // read float64
		target.GPUHours = bb

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

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

		}
	} else {
		target.CPUBreakdown = nil

	}

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

		}
	} else {
		target.RAMBreakdown = nil

	}

	if uint8(0) /* field version */ <= version {
		ee := buff.ReadFloat64() // read float64
		target.CPUCost = ee

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

	if uint8(0) /* field version */ <= version {
		ff := buff.ReadFloat64() // read float64
		target.GPUCost = ff

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

	if uint8(0) /* field version */ <= version {
		gg := buff.ReadFloat64() // read float64
		target.GPUCount = gg

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

	if uint8(0) /* field version */ <= version {
		hh := buff.ReadFloat64() // read float64
		target.RAMCost = hh

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

	if uint8(0) /* field version */ <= version {
		kk := buff.ReadFloat64() // read float64
		target.Discount = kk

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

	if uint8(0) /* field version */ <= version {
		ll := buff.ReadFloat64() // read float64
		target.Preemptible = ll

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

	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 := &EncodingContext{
		Buffer: util.NewBuffer(),
		Table:  nil,
	}

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

	encBytes := ctx.Buffer.Bytes()
	return encBytes, nil
}

// 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
	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 {
	var table []string
	buff := util.NewBufferFromBytes(data)

	// string table header validation
	if isBinaryTag(data, BinaryTagStringTable) {
		buff.ReadBytes(len(BinaryTagStringTable)) // strip tag length
		tl := buff.ReadInt()                      // table length
		if tl > 0 {
			table = make([]string, tl, tl)
			for i := 0; i < tl; i++ {
				table[i] = buff.ReadString()
			}
		}
	}

	ctx := &DecodingContext{
		Buffer: buff,
		Table:  table,
	}

	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 Unmarshaling PVAllocation. Expected %d or less, got %d", AllocationCodecVersion, version)
	}

	if uint8(0) /* field version */ <= version {
		a := buff.ReadFloat64() // read float64
		target.ByteHours = a

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

	if uint8(0) /* field version */ <= version {
		b := buff.ReadFloat64() // read float64
		target.Cost = b

	} else {
		target.Cost = float64(0) // 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 := &EncodingContext{
		Buffer: util.NewBuffer(),
		Table:  nil,
	}

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

	encBytes := ctx.Buffer.Bytes()
	return encBytes, nil
}

// 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 {
	var table []string
	buff := util.NewBufferFromBytes(data)

	// string table header validation
	if isBinaryTag(data, BinaryTagStringTable) {
		buff.ReadBytes(len(BinaryTagStringTable)) // strip tag length
		tl := buff.ReadInt()                      // table length
		if tl > 0 {
			table = make([]string, tl, tl)
			for i := 0; i < tl; i++ {
				table[i] = buff.ReadString()
			}
		}
	}

	ctx := &DecodingContext{
		Buffer: buff,
		Table:  table,
	}

	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 Unmarshaling PVKey. Expected %d or less, got %d", AllocationCodecVersion, version)
	}

	if uint8(0) /* field version */ <= version {
		var b string
		if ctx.IsStringTable() {
			c := buff.ReadInt() // read string index
			b = ctx.Table[c]
		} else {
			b = buff.ReadString() // read string
		}
		a := b
		target.Cluster = a

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

	if uint8(0) /* field version */ <= version {
		var e string
		if ctx.IsStringTable() {
			f := buff.ReadInt() // read string index
			e = ctx.Table[f]
		} else {
			e = buff.ReadString() // read string
		}
		d := e
		target.Name = d

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

	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 := &EncodingContext{
		Buffer: util.NewBuffer(),
		Table:  nil,
	}

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

	encBytes := ctx.Buffer.Bytes()
	return encBytes, nil
}

// 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
	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 {
	var table []string
	buff := util.NewBufferFromBytes(data)

	// string table header validation
	if isBinaryTag(data, BinaryTagStringTable) {
		buff.ReadBytes(len(BinaryTagStringTable)) // strip tag length
		tl := buff.ReadInt()                      // table length
		if tl > 0 {
			table = make([]string, tl, tl)
			for i := 0; i < tl; i++ {
				table[i] = buff.ReadString()
			}
		}
	}

	ctx := &DecodingContext{
		Buffer: buff,
		Table:  table,
	}

	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 Unmarshaling RawAllocationOnlyData. Expected %d or less, got %d", AllocationCodecVersion, version)
	}

	if uint8(0) /* field version */ <= version {
		a := buff.ReadFloat64() // read float64
		target.CPUCoreUsageMax = a

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

	if uint8(0) /* field version */ <= version {
		b := buff.ReadFloat64() // read float64
		target.RAMBytesUsageMax = b

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

	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 := &EncodingContext{
		Buffer: util.NewBuffer(),
		Table:  nil,
	}

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

	encBytes := ctx.Buffer.Bytes()
	return encBytes, nil
}

// 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 {
	var table []string
	buff := util.NewBufferFromBytes(data)

	// string table header validation
	if isBinaryTag(data, BinaryTagStringTable) {
		buff.ReadBytes(len(BinaryTagStringTable)) // strip tag length
		tl := buff.ReadInt()                      // table length
		if tl > 0 {
			table = make([]string, tl, tl)
			for i := 0; i < tl; i++ {
				table[i] = buff.ReadString()
			}
		}
	}

	ctx := &DecodingContext{
		Buffer: buff,
		Table:  table,
	}

	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 Unmarshaling SharedAsset. Expected %d or less, got %d", AssetsCodecVersion, version)
	}

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

		}
	} else {
		target.properties = nil

	}

	if uint8(0) /* field version */ <= version {
		// --- [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 i := 0; i < d; i++ {
				var v string
				var f string
				if ctx.IsStringTable() {
					g := buff.ReadInt() // read string index
					f = ctx.Table[g]
				} else {
					f = buff.ReadString() // read string
				}
				e := f
				v = e

				var z string
				var k string
				if ctx.IsStringTable() {
					l := buff.ReadInt() // read string index
					k = ctx.Table[l]
				} else {
					k = buff.ReadString() // read string
				}
				h := k
				z = h

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

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

	} else {
	}

	if uint8(0) /* field version */ <= version {
		// --- [begin][read][struct](Window) ---
		m := &Window{}
		buff.ReadInt() // [compatibility, unused]
		errB := m.UnmarshalBinaryWithContext(ctx)
		if errB != nil {
			return errB
		}
		target.window = *m
		// --- [end][read][struct](Window) ---

	} else {
	}

	if uint8(0) /* field version */ <= version {
		n := buff.ReadFloat64() // read float64
		target.Cost = n

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

	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 := &EncodingContext{
		Buffer: util.NewBuffer(),
		Table:  nil,
	}

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

	encBytes := ctx.Buffer.Bytes()
	return encBytes, nil
}

// 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 {
	var table []string
	buff := util.NewBufferFromBytes(data)

	// string table header validation
	if isBinaryTag(data, BinaryTagStringTable) {
		buff.ReadBytes(len(BinaryTagStringTable)) // strip tag length
		tl := buff.ReadInt()                      // table length
		if tl > 0 {
			table = make([]string, tl, tl)
			for i := 0; i < tl; i++ {
				table[i] = buff.ReadString()
			}
		}
	}

	ctx := &DecodingContext{
		Buffer: buff,
		Table:  table,
	}

	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 Unmarshaling Window. Expected %d or less, got %d", DefaultCodecVersion, version)
	}

	if uint8(0) /* field version */ <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.start = nil
		} else {
			// --- [begin][read][reference](time.Time) ---
			a := &time.Time{}
			b := buff.ReadInt()    // byte array length
			c := buff.ReadBytes(b) // byte array
			errA := a.UnmarshalBinary(c)
			if errA != nil {
				return errA
			}
			target.start = a
			// --- [end][read][reference](time.Time) ---

		}
	} else {
		target.start = nil

	}

	if uint8(0) /* field version */ <= version {
		if buff.ReadUInt8() == uint8(0) {
			target.end = nil
		} else {
			// --- [begin][read][reference](time.Time) ---
			d := &time.Time{}
			e := buff.ReadInt()    // byte array length
			f := buff.ReadBytes(e) // byte array
			errB := d.UnmarshalBinary(f)
			if errB != nil {
				return errB
			}
			target.end = d
			// --- [end][read][reference](time.Time) ---

		}
	} else {
		target.end = nil

	}

	return nil
}