cbor_gen.go

// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT.

package bucket

import (
	"fmt"
	"io"
	"math"
	"sort"

	cid "github.com/ipfs/go-cid"
	cbg "github.com/whyrusleeping/cbor-gen"
	xerrors "golang.org/x/xerrors"
)

var _ = xerrors.Errorf
var _ = cid.Undef
var _ = math.E
var _ = sort.Sort

func (t *ObjectManifest) MarshalCBOR(w io.Writer) error {
	if t == nil {
		_, err := w.Write(cbg.CborNull)
		return err
	}

	cw := cbg.NewCborWriter(w)

	if _, err := cw.Write([]byte{178}); err != nil {
		return err
	}

	// t.Body (bucket.Body) (struct)
	if len("b") > 1000000 {
		return xerrors.Errorf("Value in field \"b\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("b"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("b")); err != nil {
		return err
	}

	if err := t.Body.MarshalCBOR(cw); err != nil {
		return err
	}

	// t.ETag (string) (string)
	if len("e") > 1000000 {
		return xerrors.Errorf("Value in field \"e\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("e"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("e")); err != nil {
		return err
	}

	if len(t.ETag) > 1000000 {
		return xerrors.Errorf("Value in field t.ETag was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.ETag))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string(t.ETag)); err != nil {
		return err
	}

	// t.Key (string) (string)
	if len("k") > 1000000 {
		return xerrors.Errorf("Value in field \"k\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("k"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("k")); err != nil {
		return err
	}

	if len(t.Key) > 1000000 {
		return xerrors.Errorf("Value in field t.Key was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string(t.Key)); err != nil {
		return err
	}

	// t.Created (int64) (int64)
	if len("t") > 1000000 {
		return xerrors.Errorf("Value in field \"t\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("t"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("t")); err != nil {
		return err
	}

	if t.Created >= 0 {
		if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Created)); err != nil {
			return err
		}
	} else {
		if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Created-1)); err != nil {
			return err
		}
	}

	// t.ChecksumAlgorithm (string) (string)
	if len("ca") > 1000000 {
		return xerrors.Errorf("Value in field \"ca\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ca"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("ca")); err != nil {
		return err
	}

	if len(t.ChecksumAlgorithm) > 1000000 {
		return xerrors.Errorf("Value in field t.ChecksumAlgorithm was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.ChecksumAlgorithm))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string(t.ChecksumAlgorithm)); err != nil {
		return err
	}

	// t.CacheControl (string) (string)
	if len("cc") > 1000000 {
		return xerrors.Errorf("Value in field \"cc\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("cc"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("cc")); err != nil {
		return err
	}

	if len(t.CacheControl) > 1000000 {
		return xerrors.Errorf("Value in field t.CacheControl was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CacheControl))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string(t.CacheControl)); err != nil {
		return err
	}

	// t.ContentDisposition (string) (string)
	if len("cd") > 1000000 {
		return xerrors.Errorf("Value in field \"cd\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("cd"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("cd")); err != nil {
		return err
	}

	if len(t.ContentDisposition) > 1000000 {
		return xerrors.Errorf("Value in field t.ContentDisposition was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.ContentDisposition))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string(t.ContentDisposition)); err != nil {
		return err
	}

	// t.ContentEncoding (string) (string)
	if len("ce") > 1000000 {
		return xerrors.Errorf("Value in field \"ce\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ce"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("ce")); err != nil {
		return err
	}

	if len(t.ContentEncoding) > 1000000 {
		return xerrors.Errorf("Value in field t.ContentEncoding was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.ContentEncoding))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string(t.ContentEncoding)); err != nil {
		return err
	}

	// t.Checksum (string) (string)
	if len("ck") > 1000000 {
		return xerrors.Errorf("Value in field \"ck\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ck"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("ck")); err != nil {
		return err
	}

	if len(t.Checksum) > 1000000 {
		return xerrors.Errorf("Value in field t.Checksum was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Checksum))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string(t.Checksum)); err != nil {
		return err
	}

	// t.ContentLanguage (string) (string)
	if len("cl") > 1000000 {
		return xerrors.Errorf("Value in field \"cl\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("cl"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("cl")); err != nil {
		return err
	}

	if len(t.ContentLanguage) > 1000000 {
		return xerrors.Errorf("Value in field t.ContentLanguage was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.ContentLanguage))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string(t.ContentLanguage)); err != nil {
		return err
	}

	// t.ContentType (string) (string)
	if len("ct") > 1000000 {
		return xerrors.Errorf("Value in field \"ct\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ct"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("ct")); err != nil {
		return err
	}

	if len(t.ContentType) > 1000000 {
		return xerrors.Errorf("Value in field t.ContentType was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.ContentType))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string(t.ContentType)); err != nil {
		return err
	}

	// t.ChecksumType (string) (string)
	if len("cy") > 1000000 {
		return xerrors.Errorf("Value in field \"cy\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("cy"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("cy")); err != nil {
		return err
	}

	if len(t.ChecksumType) > 1000000 {
		return xerrors.Errorf("Value in field t.ChecksumType was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.ChecksumType))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string(t.ChecksumType)); err != nil {
		return err
	}

	// t.DeleteMarker (bool) (bool)
	if len("dm") > 1000000 {
		return xerrors.Errorf("Value in field \"dm\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("dm"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("dm")); err != nil {
		return err
	}

	if err := cbg.WriteBool(w, t.DeleteMarker); err != nil {
		return err
	}

	// t.Expires (string) (string)
	if len("ex") > 1000000 {
		return xerrors.Errorf("Value in field \"ex\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ex"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("ex")); err != nil {
		return err
	}

	if len(t.Expires) > 1000000 {
		return xerrors.Errorf("Value in field t.Expires was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Expires))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string(t.Expires)); err != nil {
		return err
	}

	// t.Metadata (map[string]string) (map)
	if len("md") > 1000000 {
		return xerrors.Errorf("Value in field \"md\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("md"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("md")); err != nil {
		return err
	}

	{
		if len(t.Metadata) > 4096 {
			return xerrors.Errorf("cannot marshal t.Metadata map too large")
		}

		if err := cw.WriteMajorTypeHeader(cbg.MajMap, uint64(len(t.Metadata))); err != nil {
			return err
		}

		keys := make([]string, 0, len(t.Metadata))
		for k := range t.Metadata {
			keys = append(keys, k)
		}
		sort.Strings(keys)
		for _, k := range keys {
			v := t.Metadata[k]

			if len(k) > 1000000 {
				return xerrors.Errorf("Value in field k was too long")
			}

			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(k))); err != nil {
				return err
			}
			if _, err := cw.WriteString(string(k)); err != nil {
				return err
			}

			if len(v) > 1000000 {
				return xerrors.Errorf("Value in field v was too long")
			}

			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
				return err
			}
			if _, err := cw.WriteString(string(v)); err != nil {
				return err
			}

		}
	}

	// t.Seq (uint64) (uint64)
	if len("sq") > 1000000 {
		return xerrors.Errorf("Value in field \"sq\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sq"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("sq")); err != nil {
		return err
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Seq)); err != nil {
		return err
	}

	// t.VersionID (string) (string)
	if len("vi") > 1000000 {
		return xerrors.Errorf("Value in field \"vi\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("vi"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("vi")); err != nil {
		return err
	}

	if len(t.VersionID) > 1000000 {
		return xerrors.Errorf("Value in field t.VersionID was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.VersionID))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string(t.VersionID)); err != nil {
		return err
	}

	// t.WebsiteRedirectLocation (string) (string)
	if len("wr") > 1000000 {
		return xerrors.Errorf("Value in field \"wr\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("wr"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("wr")); err != nil {
		return err
	}

	if len(t.WebsiteRedirectLocation) > 1000000 {
		return xerrors.Errorf("Value in field t.WebsiteRedirectLocation was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.WebsiteRedirectLocation))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string(t.WebsiteRedirectLocation)); err != nil {
		return err
	}
	return nil
}

func (t *ObjectManifest) UnmarshalCBOR(r io.Reader) (err error) {
	*t = ObjectManifest{}

	cr := cbg.NewCborReader(r)

	maj, extra, err := cr.ReadHeader()
	if err != nil {
		return err
	}
	defer func() {
		if err == io.EOF {
			err = io.ErrUnexpectedEOF
		}
	}()

	if maj != cbg.MajMap {
		return fmt.Errorf("cbor input should be of type map")
	}

	if extra > cbg.MaxLength {
		return fmt.Errorf("ObjectManifest: map struct too large (%d)", extra)
	}

	n := extra

	nameBuf := make([]byte, 2)
	for i := uint64(0); i < n; i++ {
		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
		if err != nil {
			return err
		}

		if !ok {
			// Field doesn't exist on this type, so ignore it
			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
				return err
			}
			continue
		}

		switch string(nameBuf[:nameLen]) {
		// t.Body (bucket.Body) (struct)
		case "b":

			{

				if err := t.Body.UnmarshalCBOR(cr); err != nil {
					return xerrors.Errorf("unmarshaling t.Body: %w", err)
				}

			}
			// t.ETag (string) (string)
		case "e":

			{
				sval, err := cbg.ReadStringWithMax(cr, 1000000)
				if err != nil {
					return err
				}

				t.ETag = string(sval)
			}
			// t.Key (string) (string)
		case "k":

			{
				sval, err := cbg.ReadStringWithMax(cr, 1000000)
				if err != nil {
					return err
				}

				t.Key = string(sval)
			}
			// t.Created (int64) (int64)
		case "t":
			{
				maj, extra, err := cr.ReadHeader()
				if err != nil {
					return err
				}
				var extraI int64
				switch maj {
				case cbg.MajUnsignedInt:
					extraI = int64(extra)
					if extraI < 0 {
						return fmt.Errorf("int64 positive overflow")
					}
				case cbg.MajNegativeInt:
					extraI = int64(extra)
					if extraI < 0 {
						return fmt.Errorf("int64 negative overflow")
					}
					extraI = -1 - extraI
				default:
					return fmt.Errorf("wrong type for int64 field: %d", maj)
				}

				t.Created = int64(extraI)
			}
			// t.ChecksumAlgorithm (string) (string)
		case "ca":

			{
				sval, err := cbg.ReadStringWithMax(cr, 1000000)
				if err != nil {
					return err
				}

				t.ChecksumAlgorithm = string(sval)
			}
			// t.CacheControl (string) (string)
		case "cc":

			{
				sval, err := cbg.ReadStringWithMax(cr, 1000000)
				if err != nil {
					return err
				}

				t.CacheControl = string(sval)
			}
			// t.ContentDisposition (string) (string)
		case "cd":

			{
				sval, err := cbg.ReadStringWithMax(cr, 1000000)
				if err != nil {
					return err
				}

				t.ContentDisposition = string(sval)
			}
			// t.ContentEncoding (string) (string)
		case "ce":

			{
				sval, err := cbg.ReadStringWithMax(cr, 1000000)
				if err != nil {
					return err
				}

				t.ContentEncoding = string(sval)
			}
			// t.Checksum (string) (string)
		case "ck":

			{
				sval, err := cbg.ReadStringWithMax(cr, 1000000)
				if err != nil {
					return err
				}

				t.Checksum = string(sval)
			}
			// t.ContentLanguage (string) (string)
		case "cl":

			{
				sval, err := cbg.ReadStringWithMax(cr, 1000000)
				if err != nil {
					return err
				}

				t.ContentLanguage = string(sval)
			}
			// t.ContentType (string) (string)
		case "ct":

			{
				sval, err := cbg.ReadStringWithMax(cr, 1000000)
				if err != nil {
					return err
				}

				t.ContentType = string(sval)
			}
			// t.ChecksumType (string) (string)
		case "cy":

			{
				sval, err := cbg.ReadStringWithMax(cr, 1000000)
				if err != nil {
					return err
				}

				t.ChecksumType = string(sval)
			}
			// t.DeleteMarker (bool) (bool)
		case "dm":

			maj, extra, err = cr.ReadHeader()
			if err != nil {
				return err
			}
			if maj != cbg.MajOther {
				return fmt.Errorf("booleans must be major type 7")
			}
			switch extra {
			case 20:
				t.DeleteMarker = false
			case 21:
				t.DeleteMarker = true
			default:
				return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
			}
			// t.Expires (string) (string)
		case "ex":

			{
				sval, err := cbg.ReadStringWithMax(cr, 1000000)
				if err != nil {
					return err
				}

				t.Expires = string(sval)
			}
			// t.Metadata (map[string]string) (map)
		case "md":

			maj, extra, err = cr.ReadHeader()
			if err != nil {
				return err
			}
			if maj != cbg.MajMap {
				return fmt.Errorf("expected a map (major type 5)")
			}
			if extra > 4096 {
				return fmt.Errorf("t.Metadata: map too large")
			}

			t.Metadata = make(map[string]string, extra)

			for i, l := 0, int(extra); i < l; i++ {

				var k string

				{
					sval, err := cbg.ReadStringWithMax(cr, 1000000)
					if err != nil {
						return err
					}

					k = string(sval)
				}

				var v string

				{
					sval, err := cbg.ReadStringWithMax(cr, 1000000)
					if err != nil {
						return err
					}

					v = string(sval)
				}

				t.Metadata[k] = v

			}
			// t.Seq (uint64) (uint64)
		case "sq":

			{

				maj, extra, err = cr.ReadHeader()
				if err != nil {
					return err
				}
				if maj != cbg.MajUnsignedInt {
					return fmt.Errorf("wrong type for uint64 field")
				}
				t.Seq = uint64(extra)

			}
			// t.VersionID (string) (string)
		case "vi":

			{
				sval, err := cbg.ReadStringWithMax(cr, 1000000)
				if err != nil {
					return err
				}

				t.VersionID = string(sval)
			}
			// t.WebsiteRedirectLocation (string) (string)
		case "wr":

			{
				sval, err := cbg.ReadStringWithMax(cr, 1000000)
				if err != nil {
					return err
				}

				t.WebsiteRedirectLocation = string(sval)
			}

		default:
			// Field doesn't exist on this type, so ignore it
			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
				return err
			}
		}
	}

	return nil
}
func (t *Body) MarshalCBOR(w io.Writer) error {
	if t == nil {
		_, err := w.Write(cbg.CborNull)
		return err
	}

	cw := cbg.NewCborWriter(w)

	if _, err := cw.Write([]byte{166}); err != nil {
		return err
	}

	// t.SHA256 ([]uint8) (slice)
	if len("h") > 1000000 {
		return xerrors.Errorf("Value in field \"h\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("h"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("h")); err != nil {
		return err
	}

	if len(t.SHA256) > 2097152 {
		return xerrors.Errorf("Byte array in field t.SHA256 was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.SHA256))); err != nil {
		return err
	}

	if _, err := cw.Write(t.SHA256); err != nil {
		return err
	}

	// t.MD5 ([]uint8) (slice)
	if len("m") > 1000000 {
		return xerrors.Errorf("Value in field \"m\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("m"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("m")); err != nil {
		return err
	}

	if len(t.MD5) > 2097152 {
		return xerrors.Errorf("Byte array in field t.MD5 was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.MD5))); err != nil {
		return err
	}

	if _, err := cw.Write(t.MD5); err != nil {
		return err
	}

	// t.Size (int64) (int64)
	if len("s") > 1000000 {
		return xerrors.Errorf("Value in field \"s\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("s"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("s")); err != nil {
		return err
	}

	if t.Size >= 0 {
		if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Size)); err != nil {
			return err
		}
	} else {
		if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Size-1)); err != nil {
			return err
		}
	}

	// t.Blobs ([]bucket.BlobRef) (slice)
	if len("bl") > 1000000 {
		return xerrors.Errorf("Value in field \"bl\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("bl"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("bl")); err != nil {
		return err
	}

	if len(t.Blobs) > 8192 {
		return xerrors.Errorf("Slice value in field t.Blobs was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Blobs))); err != nil {
		return err
	}
	for _, v := range t.Blobs {
		if err := v.MarshalCBOR(cw); err != nil {
			return err
		}

	}

	// t.IndexRoot (cid.Cid) (struct)
	if len("ir") > 1000000 {
		return xerrors.Errorf("Value in field \"ir\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ir"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("ir")); err != nil {
		return err
	}

	if t.IndexRoot == nil {
		if _, err := cw.Write(cbg.CborNull); err != nil {
			return err
		}
	} else {
		if err := cbg.WriteCid(cw, *t.IndexRoot); err != nil {
			return xerrors.Errorf("failed to write cid field t.IndexRoot: %w", err)
		}
	}

	// t.PartSizes ([]int64) (slice)
	if len("ps") > 1000000 {
		return xerrors.Errorf("Value in field \"ps\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ps"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("ps")); err != nil {
		return err
	}

	if len(t.PartSizes) > 8192 {
		return xerrors.Errorf("Slice value in field t.PartSizes was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.PartSizes))); err != nil {
		return err
	}
	for _, v := range t.PartSizes {
		if v >= 0 {
			if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(v)); err != nil {
				return err
			}
		} else {
			if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-v-1)); err != nil {
				return err
			}
		}

	}
	return nil
}

func (t *Body) UnmarshalCBOR(r io.Reader) (err error) {
	*t = Body{}

	cr := cbg.NewCborReader(r)

	maj, extra, err := cr.ReadHeader()
	if err != nil {
		return err
	}
	defer func() {
		if err == io.EOF {
			err = io.ErrUnexpectedEOF
		}
	}()

	if maj != cbg.MajMap {
		return fmt.Errorf("cbor input should be of type map")
	}

	if extra > cbg.MaxLength {
		return fmt.Errorf("Body: map struct too large (%d)", extra)
	}

	n := extra

	nameBuf := make([]byte, 2)
	for i := uint64(0); i < n; i++ {
		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
		if err != nil {
			return err
		}

		if !ok {
			// Field doesn't exist on this type, so ignore it
			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
				return err
			}
			continue
		}

		switch string(nameBuf[:nameLen]) {
		// t.SHA256 ([]uint8) (slice)
		case "h":

			maj, extra, err = cr.ReadHeader()
			if err != nil {
				return err
			}

			if extra > 2097152 {
				return fmt.Errorf("t.SHA256: byte array too large (%d)", extra)
			}
			if maj != cbg.MajByteString {
				return fmt.Errorf("expected byte array")
			}

			if extra > 0 {
				t.SHA256 = make([]uint8, extra)
			}

			if _, err := io.ReadFull(cr, t.SHA256); err != nil {
				return err
			}

			// t.MD5 ([]uint8) (slice)
		case "m":

			maj, extra, err = cr.ReadHeader()
			if err != nil {
				return err
			}

			if extra > 2097152 {
				return fmt.Errorf("t.MD5: byte array too large (%d)", extra)
			}
			if maj != cbg.MajByteString {
				return fmt.Errorf("expected byte array")
			}

			if extra > 0 {
				t.MD5 = make([]uint8, extra)
			}

			if _, err := io.ReadFull(cr, t.MD5); err != nil {
				return err
			}

			// t.Size (int64) (int64)
		case "s":
			{
				maj, extra, err := cr.ReadHeader()
				if err != nil {
					return err
				}
				var extraI int64
				switch maj {
				case cbg.MajUnsignedInt:
					extraI = int64(extra)
					if extraI < 0 {
						return fmt.Errorf("int64 positive overflow")
					}
				case cbg.MajNegativeInt:
					extraI = int64(extra)
					if extraI < 0 {
						return fmt.Errorf("int64 negative overflow")
					}
					extraI = -1 - extraI
				default:
					return fmt.Errorf("wrong type for int64 field: %d", maj)
				}

				t.Size = int64(extraI)
			}
			// t.Blobs ([]bucket.BlobRef) (slice)
		case "bl":

			maj, extra, err = cr.ReadHeader()
			if err != nil {
				return err
			}

			if extra > 8192 {
				return fmt.Errorf("t.Blobs: array too large (%d)", extra)
			}

			if maj != cbg.MajArray {
				return fmt.Errorf("expected cbor array")
			}

			if extra > 0 {
				t.Blobs = make([]BlobRef, extra)
			}

			for i := 0; i < int(extra); i++ {
				{
					var maj byte
					var extra uint64
					var err error
					_ = maj
					_ = extra
					_ = err

					{

						if err := t.Blobs[i].UnmarshalCBOR(cr); err != nil {
							return xerrors.Errorf("unmarshaling t.Blobs[i]: %w", err)
						}

					}

				}
			}
			// t.IndexRoot (cid.Cid) (struct)
		case "ir":

			{

				b, err := cr.ReadByte()
				if err != nil {
					return err
				}
				if b != cbg.CborNull[0] {
					if err := cr.UnreadByte(); err != nil {
						return err
					}

					c, err := cbg.ReadCid(cr)
					if err != nil {
						return xerrors.Errorf("failed to read cid field t.IndexRoot: %w", err)
					}

					t.IndexRoot = &c
				}

			}
			// t.PartSizes ([]int64) (slice)
		case "ps":

			maj, extra, err = cr.ReadHeader()
			if err != nil {
				return err
			}

			if extra > 8192 {
				return fmt.Errorf("t.PartSizes: array too large (%d)", extra)
			}

			if maj != cbg.MajArray {
				return fmt.Errorf("expected cbor array")
			}

			if extra > 0 {
				t.PartSizes = make([]int64, extra)
			}

			for i := 0; i < int(extra); i++ {
				{
					var maj byte
					var extra uint64
					var err error
					_ = maj
					_ = extra
					_ = err
					{
						maj, extra, err := cr.ReadHeader()
						if err != nil {
							return err
						}
						var extraI int64
						switch maj {
						case cbg.MajUnsignedInt:
							extraI = int64(extra)
							if extraI < 0 {
								return fmt.Errorf("int64 positive overflow")
							}
						case cbg.MajNegativeInt:
							extraI = int64(extra)
							if extraI < 0 {
								return fmt.Errorf("int64 negative overflow")
							}
							extraI = -1 - extraI
						default:
							return fmt.Errorf("wrong type for int64 field: %d", maj)
						}

						t.PartSizes[i] = int64(extraI)
					}

				}
			}

		default:
			// Field doesn't exist on this type, so ignore it
			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
				return err
			}
		}
	}

	return nil
}
func (t *BlobRef) MarshalCBOR(w io.Writer) error {
	if t == nil {
		_, err := w.Write(cbg.CborNull)
		return err
	}

	cw := cbg.NewCborWriter(w)

	if _, err := cw.Write([]byte{163}); err != nil {
		return err
	}

	// t.Digest ([]uint8) (slice)
	if len("d") > 1000000 {
		return xerrors.Errorf("Value in field \"d\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("d"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("d")); err != nil {
		return err
	}

	if len(t.Digest) > 2097152 {
		return xerrors.Errorf("Byte array in field t.Digest was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Digest))); err != nil {
		return err
	}

	if _, err := cw.Write(t.Digest); err != nil {
		return err
	}

	// t.Length (int64) (int64)
	if len("l") > 1000000 {
		return xerrors.Errorf("Value in field \"l\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("l"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("l")); err != nil {
		return err
	}

	if t.Length >= 0 {
		if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Length)); err != nil {
			return err
		}
	} else {
		if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Length-1)); err != nil {
			return err
		}
	}

	// t.Offset (int64) (int64)
	if len("o") > 1000000 {
		return xerrors.Errorf("Value in field \"o\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("o"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("o")); err != nil {
		return err
	}

	if t.Offset >= 0 {
		if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Offset)); err != nil {
			return err
		}
	} else {
		if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Offset-1)); err != nil {
			return err
		}
	}

	return nil
}

func (t *BlobRef) UnmarshalCBOR(r io.Reader) (err error) {
	*t = BlobRef{}

	cr := cbg.NewCborReader(r)

	maj, extra, err := cr.ReadHeader()
	if err != nil {
		return err
	}
	defer func() {
		if err == io.EOF {
			err = io.ErrUnexpectedEOF
		}
	}()

	if maj != cbg.MajMap {
		return fmt.Errorf("cbor input should be of type map")
	}

	if extra > cbg.MaxLength {
		return fmt.Errorf("BlobRef: map struct too large (%d)", extra)
	}

	n := extra

	nameBuf := make([]byte, 1)
	for i := uint64(0); i < n; i++ {
		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
		if err != nil {
			return err
		}

		if !ok {
			// Field doesn't exist on this type, so ignore it
			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
				return err
			}
			continue
		}

		switch string(nameBuf[:nameLen]) {
		// t.Digest ([]uint8) (slice)
		case "d":

			maj, extra, err = cr.ReadHeader()
			if err != nil {
				return err
			}

			if extra > 2097152 {
				return fmt.Errorf("t.Digest: byte array too large (%d)", extra)
			}
			if maj != cbg.MajByteString {
				return fmt.Errorf("expected byte array")
			}

			if extra > 0 {
				t.Digest = make([]uint8, extra)
			}

			if _, err := io.ReadFull(cr, t.Digest); err != nil {
				return err
			}

			// t.Length (int64) (int64)
		case "l":
			{
				maj, extra, err := cr.ReadHeader()
				if err != nil {
					return err
				}
				var extraI int64
				switch maj {
				case cbg.MajUnsignedInt:
					extraI = int64(extra)
					if extraI < 0 {
						return fmt.Errorf("int64 positive overflow")
					}
				case cbg.MajNegativeInt:
					extraI = int64(extra)
					if extraI < 0 {
						return fmt.Errorf("int64 negative overflow")
					}
					extraI = -1 - extraI
				default:
					return fmt.Errorf("wrong type for int64 field: %d", maj)
				}

				t.Length = int64(extraI)
			}
			// t.Offset (int64) (int64)
		case "o":
			{
				maj, extra, err := cr.ReadHeader()
				if err != nil {
					return err
				}
				var extraI int64
				switch maj {
				case cbg.MajUnsignedInt:
					extraI = int64(extra)
					if extraI < 0 {
						return fmt.Errorf("int64 positive overflow")
					}
				case cbg.MajNegativeInt:
					extraI = int64(extra)
					if extraI < 0 {
						return fmt.Errorf("int64 negative overflow")
					}
					extraI = -1 - extraI
				default:
					return fmt.Errorf("wrong type for int64 field: %d", maj)
				}

				t.Offset = int64(extraI)
			}

		default:
			// Field doesn't exist on this type, so ignore it
			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
				return err
			}
		}
	}

	return nil
}
func (t *ObjectLeaf) MarshalCBOR(w io.Writer) error {
	if t == nil {
		_, err := w.Write(cbg.CborNull)
		return err
	}

	cw := cbg.NewCborWriter(w)

	if _, err := cw.Write([]byte{164}); err != nil {
		return err
	}

	// t.Current (bucket.VersionNode) (struct)
	if len("c") > 1000000 {
		return xerrors.Errorf("Value in field \"c\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("c"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("c")); err != nil {
		return err
	}

	if err := t.Current.MarshalCBOR(cw); err != nil {
		return err
	}

	// t.NullSeq (uint64) (uint64)
	if len("n") > 1000000 {
		return xerrors.Errorf("Value in field \"n\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("n"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("n")); err != nil {
		return err
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.NullSeq)); err != nil {
		return err
	}

	// t.Prev (cid.Cid) (struct)
	if len("p") > 1000000 {
		return xerrors.Errorf("Value in field \"p\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("p"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("p")); err != nil {
		return err
	}

	if t.Prev == nil {
		if _, err := cw.Write(cbg.CborNull); err != nil {
			return err
		}
	} else {
		if err := cbg.WriteCid(cw, *t.Prev); err != nil {
			return xerrors.Errorf("failed to write cid field t.Prev: %w", err)
		}
	}

	// t.State (cid.Cid) (struct)
	if len("st") > 1000000 {
		return xerrors.Errorf("Value in field \"st\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("st"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("st")); err != nil {
		return err
	}

	if t.State == nil {
		if _, err := cw.Write(cbg.CborNull); err != nil {
			return err
		}
	} else {
		if err := cbg.WriteCid(cw, *t.State); err != nil {
			return xerrors.Errorf("failed to write cid field t.State: %w", err)
		}
	}

	return nil
}

func (t *ObjectLeaf) UnmarshalCBOR(r io.Reader) (err error) {
	*t = ObjectLeaf{}

	cr := cbg.NewCborReader(r)

	maj, extra, err := cr.ReadHeader()
	if err != nil {
		return err
	}
	defer func() {
		if err == io.EOF {
			err = io.ErrUnexpectedEOF
		}
	}()

	if maj != cbg.MajMap {
		return fmt.Errorf("cbor input should be of type map")
	}

	if extra > cbg.MaxLength {
		return fmt.Errorf("ObjectLeaf: map struct too large (%d)", extra)
	}

	n := extra

	nameBuf := make([]byte, 2)
	for i := uint64(0); i < n; i++ {
		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
		if err != nil {
			return err
		}

		if !ok {
			// Field doesn't exist on this type, so ignore it
			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
				return err
			}
			continue
		}

		switch string(nameBuf[:nameLen]) {
		// t.Current (bucket.VersionNode) (struct)
		case "c":

			{

				if err := t.Current.UnmarshalCBOR(cr); err != nil {
					return xerrors.Errorf("unmarshaling t.Current: %w", err)
				}

			}
			// t.NullSeq (uint64) (uint64)
		case "n":

			{

				maj, extra, err = cr.ReadHeader()
				if err != nil {
					return err
				}
				if maj != cbg.MajUnsignedInt {
					return fmt.Errorf("wrong type for uint64 field")
				}
				t.NullSeq = uint64(extra)

			}
			// t.Prev (cid.Cid) (struct)
		case "p":

			{

				b, err := cr.ReadByte()
				if err != nil {
					return err
				}
				if b != cbg.CborNull[0] {
					if err := cr.UnreadByte(); err != nil {
						return err
					}

					c, err := cbg.ReadCid(cr)
					if err != nil {
						return xerrors.Errorf("failed to read cid field t.Prev: %w", err)
					}

					t.Prev = &c
				}

			}
			// t.State (cid.Cid) (struct)
		case "st":

			{

				b, err := cr.ReadByte()
				if err != nil {
					return err
				}
				if b != cbg.CborNull[0] {
					if err := cr.UnreadByte(); err != nil {
						return err
					}

					c, err := cbg.ReadCid(cr)
					if err != nil {
						return xerrors.Errorf("failed to read cid field t.State: %w", err)
					}

					t.State = &c
				}

			}

		default:
			// Field doesn't exist on this type, so ignore it
			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
				return err
			}
		}
	}

	return nil
}
func (t *VersionNode) MarshalCBOR(w io.Writer) error {
	if t == nil {
		_, err := w.Write(cbg.CborNull)
		return err
	}

	cw := cbg.NewCborWriter(w)

	if _, err := cw.Write([]byte{163}); err != nil {
		return err
	}

	// t.Manifest (cid.Cid) (struct)
	if len("m") > 1000000 {
		return xerrors.Errorf("Value in field \"m\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("m"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("m")); err != nil {
		return err
	}

	if err := cbg.WriteCid(cw, t.Manifest); err != nil {
		return xerrors.Errorf("failed to write cid field t.Manifest: %w", err)
	}

	// t.Seq (uint64) (uint64)
	if len("s") > 1000000 {
		return xerrors.Errorf("Value in field \"s\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("s"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("s")); err != nil {
		return err
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Seq)); err != nil {
		return err
	}

	// t.VersionID (string) (string)
	if len("v") > 1000000 {
		return xerrors.Errorf("Value in field \"v\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("v"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("v")); err != nil {
		return err
	}

	if len(t.VersionID) > 1000000 {
		return xerrors.Errorf("Value in field t.VersionID was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.VersionID))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string(t.VersionID)); err != nil {
		return err
	}
	return nil
}

func (t *VersionNode) UnmarshalCBOR(r io.Reader) (err error) {
	*t = VersionNode{}

	cr := cbg.NewCborReader(r)

	maj, extra, err := cr.ReadHeader()
	if err != nil {
		return err
	}
	defer func() {
		if err == io.EOF {
			err = io.ErrUnexpectedEOF
		}
	}()

	if maj != cbg.MajMap {
		return fmt.Errorf("cbor input should be of type map")
	}

	if extra > cbg.MaxLength {
		return fmt.Errorf("VersionNode: map struct too large (%d)", extra)
	}

	n := extra

	nameBuf := make([]byte, 1)
	for i := uint64(0); i < n; i++ {
		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
		if err != nil {
			return err
		}

		if !ok {
			// Field doesn't exist on this type, so ignore it
			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
				return err
			}
			continue
		}

		switch string(nameBuf[:nameLen]) {
		// t.Manifest (cid.Cid) (struct)
		case "m":

			{

				c, err := cbg.ReadCid(cr)
				if err != nil {
					return xerrors.Errorf("failed to read cid field t.Manifest: %w", err)
				}

				t.Manifest = c

			}
			// t.Seq (uint64) (uint64)
		case "s":

			{

				maj, extra, err = cr.ReadHeader()
				if err != nil {
					return err
				}
				if maj != cbg.MajUnsignedInt {
					return fmt.Errorf("wrong type for uint64 field")
				}
				t.Seq = uint64(extra)

			}
			// t.VersionID (string) (string)
		case "v":

			{
				sval, err := cbg.ReadStringWithMax(cr, 1000000)
				if err != nil {
					return err
				}

				t.VersionID = string(sval)
			}

		default:
			// Field doesn't exist on this type, so ignore it
			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
				return err
			}
		}
	}

	return nil
}
func (t *ValueUnion) MarshalCBOR(w io.Writer) error {
	if t == nil {
		_, err := w.Write(cbg.CborNull)
		return err
	}

	cw := cbg.NewCborWriter(w)
	fieldCount := 2

	if t.Manifest == nil {
		fieldCount--
	}

	if t.Leaf == nil {
		fieldCount--
	}

	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
		return err
	}

	// t.Leaf (bucket.ObjectLeaf) (struct)
	if t.Leaf != nil {

		if len("/objectleaf/0") > 1000000 {
			return xerrors.Errorf("Value in field \"/objectleaf/0\" was too long")
		}

		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("/objectleaf/0"))); err != nil {
			return err
		}
		if _, err := cw.WriteString(string("/objectleaf/0")); err != nil {
			return err
		}

		if err := t.Leaf.MarshalCBOR(cw); err != nil {
			return err
		}
	}

	// t.Manifest (bucket.ObjectManifest) (struct)
	if t.Manifest != nil {

		if len("/objectmanifest/0") > 1000000 {
			return xerrors.Errorf("Value in field \"/objectmanifest/0\" was too long")
		}

		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("/objectmanifest/0"))); err != nil {
			return err
		}
		if _, err := cw.WriteString(string("/objectmanifest/0")); err != nil {
			return err
		}

		if err := t.Manifest.MarshalCBOR(cw); err != nil {
			return err
		}
	}
	return nil
}

func (t *ValueUnion) UnmarshalCBOR(r io.Reader) (err error) {
	*t = ValueUnion{}

	cr := cbg.NewCborReader(r)

	maj, extra, err := cr.ReadHeader()
	if err != nil {
		return err
	}
	defer func() {
		if err == io.EOF {
			err = io.ErrUnexpectedEOF
		}
	}()

	if maj != cbg.MajMap {
		return fmt.Errorf("cbor input should be of type map")
	}

	if extra > cbg.MaxLength {
		return fmt.Errorf("ValueUnion: map struct too large (%d)", extra)
	}

	n := extra

	nameBuf := make([]byte, 17)
	for i := uint64(0); i < n; i++ {
		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
		if err != nil {
			return err
		}

		if !ok {
			// Field doesn't exist on this type, so ignore it
			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
				return err
			}
			continue
		}

		switch string(nameBuf[:nameLen]) {
		// t.Leaf (bucket.ObjectLeaf) (struct)
		case "/objectleaf/0":

			{

				b, err := cr.ReadByte()
				if err != nil {
					return err
				}
				if b != cbg.CborNull[0] {
					if err := cr.UnreadByte(); err != nil {
						return err
					}
					t.Leaf = new(ObjectLeaf)
					if err := t.Leaf.UnmarshalCBOR(cr); err != nil {
						return xerrors.Errorf("unmarshaling t.Leaf pointer: %w", err)
					}
				}

			}
			// t.Manifest (bucket.ObjectManifest) (struct)
		case "/objectmanifest/0":

			{

				b, err := cr.ReadByte()
				if err != nil {
					return err
				}
				if b != cbg.CborNull[0] {
					if err := cr.UnreadByte(); err != nil {
						return err
					}
					t.Manifest = new(ObjectManifest)
					if err := t.Manifest.UnmarshalCBOR(cr); err != nil {
						return xerrors.Errorf("unmarshaling t.Manifest pointer: %w", err)
					}
				}

			}

		default:
			// Field doesn't exist on this type, so ignore it
			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
				return err
			}
		}
	}

	return nil
}
func (t *VersionState) MarshalCBOR(w io.Writer) error {
	if t == nil {
		_, err := w.Write(cbg.CborNull)
		return err
	}

	cw := cbg.NewCborWriter(w)

	if _, err := cw.Write([]byte{163}); err != nil {
		return err
	}

	// t.LegalHold (uint8) (uint8)
	if len("h") > 1000000 {
		return xerrors.Errorf("Value in field \"h\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("h"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("h")); err != nil {
		return err
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.LegalHold)); err != nil {
		return err
	}

	// t.Retention ([]uint8) (slice)
	if len("r") > 1000000 {
		return xerrors.Errorf("Value in field \"r\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("r"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("r")); err != nil {
		return err
	}

	if len(t.Retention) > 2097152 {
		return xerrors.Errorf("Byte array in field t.Retention was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Retention))); err != nil {
		return err
	}

	if _, err := cw.Write(t.Retention); err != nil {
		return err
	}

	// t.Tags (map[string]string) (map)
	if len("t") > 1000000 {
		return xerrors.Errorf("Value in field \"t\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("t"))); err != nil {
		return err
	}
	if _, err := cw.WriteString(string("t")); err != nil {
		return err
	}

	{
		if len(t.Tags) > 4096 {
			return xerrors.Errorf("cannot marshal t.Tags map too large")
		}

		if err := cw.WriteMajorTypeHeader(cbg.MajMap, uint64(len(t.Tags))); err != nil {
			return err
		}

		keys := make([]string, 0, len(t.Tags))
		for k := range t.Tags {
			keys = append(keys, k)
		}
		sort.Strings(keys)
		for _, k := range keys {
			v := t.Tags[k]

			if len(k) > 1000000 {
				return xerrors.Errorf("Value in field k was too long")
			}

			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(k))); err != nil {
				return err
			}
			if _, err := cw.WriteString(string(k)); err != nil {
				return err
			}

			if len(v) > 1000000 {
				return xerrors.Errorf("Value in field v was too long")
			}

			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
				return err
			}
			if _, err := cw.WriteString(string(v)); err != nil {
				return err
			}

		}
	}
	return nil
}

func (t *VersionState) UnmarshalCBOR(r io.Reader) (err error) {
	*t = VersionState{}

	cr := cbg.NewCborReader(r)

	maj, extra, err := cr.ReadHeader()
	if err != nil {
		return err
	}
	defer func() {
		if err == io.EOF {
			err = io.ErrUnexpectedEOF
		}
	}()

	if maj != cbg.MajMap {
		return fmt.Errorf("cbor input should be of type map")
	}

	if extra > cbg.MaxLength {
		return fmt.Errorf("VersionState: map struct too large (%d)", extra)
	}

	n := extra

	nameBuf := make([]byte, 1)
	for i := uint64(0); i < n; i++ {
		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
		if err != nil {
			return err
		}

		if !ok {
			// Field doesn't exist on this type, so ignore it
			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
				return err
			}
			continue
		}

		switch string(nameBuf[:nameLen]) {
		// t.LegalHold (uint8) (uint8)
		case "h":

			maj, extra, err = cr.ReadHeader()
			if err != nil {
				return err
			}
			if maj != cbg.MajUnsignedInt {
				return fmt.Errorf("wrong type for uint8 field")
			}
			if extra > math.MaxUint8 {
				return fmt.Errorf("integer in input was too large for uint8 field")
			}
			t.LegalHold = uint8(extra)
			// t.Retention ([]uint8) (slice)
		case "r":

			maj, extra, err = cr.ReadHeader()
			if err != nil {
				return err
			}

			if extra > 2097152 {
				return fmt.Errorf("t.Retention: byte array too large (%d)", extra)
			}
			if maj != cbg.MajByteString {
				return fmt.Errorf("expected byte array")
			}

			if extra > 0 {
				t.Retention = make([]uint8, extra)
			}

			if _, err := io.ReadFull(cr, t.Retention); err != nil {
				return err
			}

			// t.Tags (map[string]string) (map)
		case "t":

			maj, extra, err = cr.ReadHeader()
			if err != nil {
				return err
			}
			if maj != cbg.MajMap {
				return fmt.Errorf("expected a map (major type 5)")
			}
			if extra > 4096 {
				return fmt.Errorf("t.Tags: map too large")
			}

			t.Tags = make(map[string]string, extra)

			for i, l := 0, int(extra); i < l; i++ {

				var k string

				{
					sval, err := cbg.ReadStringWithMax(cr, 1000000)
					if err != nil {
						return err
					}

					k = string(sval)
				}

				var v string

				{
					sval, err := cbg.ReadStringWithMax(cr, 1000000)
					if err != nil {
						return err
					}

					v = string(sval)
				}

				t.Tags[k] = v

			}

		default:
			// Field doesn't exist on this type, so ignore it
			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
				return err
			}
		}
	}

	return nil
}
func (t *StateUnion) MarshalCBOR(w io.Writer) error {
	if t == nil {
		_, err := w.Write(cbg.CborNull)
		return err
	}

	cw := cbg.NewCborWriter(w)
	fieldCount := 1

	if t.State == nil {
		fieldCount--
	}

	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
		return err
	}

	// t.State (bucket.VersionState) (struct)
	if t.State != nil {

		if len("/versionstate/0") > 1000000 {
			return xerrors.Errorf("Value in field \"/versionstate/0\" was too long")
		}

		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("/versionstate/0"))); err != nil {
			return err
		}
		if _, err := cw.WriteString(string("/versionstate/0")); err != nil {
			return err
		}

		if err := t.State.MarshalCBOR(cw); err != nil {
			return err
		}
	}
	return nil
}

func (t *StateUnion) UnmarshalCBOR(r io.Reader) (err error) {
	*t = StateUnion{}

	cr := cbg.NewCborReader(r)

	maj, extra, err := cr.ReadHeader()
	if err != nil {
		return err
	}
	defer func() {
		if err == io.EOF {
			err = io.ErrUnexpectedEOF
		}
	}()

	if maj != cbg.MajMap {
		return fmt.Errorf("cbor input should be of type map")
	}

	if extra > cbg.MaxLength {
		return fmt.Errorf("StateUnion: map struct too large (%d)", extra)
	}

	n := extra

	nameBuf := make([]byte, 15)
	for i := uint64(0); i < n; i++ {
		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
		if err != nil {
			return err
		}

		if !ok {
			// Field doesn't exist on this type, so ignore it
			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
				return err
			}
			continue
		}

		switch string(nameBuf[:nameLen]) {
		// t.State (bucket.VersionState) (struct)
		case "/versionstate/0":

			{

				b, err := cr.ReadByte()
				if err != nil {
					return err
				}
				if b != cbg.CborNull[0] {
					if err := cr.UnreadByte(); err != nil {
						return err
					}
					t.State = new(VersionState)
					if err := t.State.UnmarshalCBOR(cr); err != nil {
						return xerrors.Errorf("unmarshaling t.State pointer: %w", err)
					}
				}

			}

		default:
			// Field doesn't exist on this type, so ignore it
			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
				return err
			}
		}
	}

	return nil
}