api/tangled/cbor_gen.go at sl/git-objects

besaid.zone / core
forked from tangled.org/core
fork
Monorepo for Tangled
fork
core / api / tangled / cbor_gen.go
at sl/git-objects 9833 lines 211 kB view raw
wrap content
boltless.me appview,lexicons: atprotate the mentions & references 5mo ago
3b2409e9
   1// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT.
   2
   3package tangled
   4
   5import (
   6	"fmt"
   7	"io"
   8	"math"
   9	"sort"
  10
  11	util "github.com/bluesky-social/indigo/lex/util"
  12	cid "github.com/ipfs/go-cid"
  13	cbg "github.com/whyrusleeping/cbor-gen"
  14	xerrors "golang.org/x/xerrors"
  15)
  16
  17var _ = xerrors.Errorf
  18var _ = cid.Undef
  19var _ = math.E
  20var _ = sort.Sort
  21
  22func (t *ActorProfile) MarshalCBOR(w io.Writer) error {
  23	if t == nil {
  24		_, err := w.Write(cbg.CborNull)
  25		return err
  26	}
  27
  28	cw := cbg.NewCborWriter(w)
  29	fieldCount := 8
  30
  31	if t.Description == nil {
  32		fieldCount--
  33	}
  34
  35	if t.Links == nil {
  36		fieldCount--
  37	}
  38
  39	if t.Location == nil {
  40		fieldCount--
  41	}
  42
  43	if t.PinnedRepositories == nil {
  44		fieldCount--
  45	}
  46
  47	if t.Pronouns == nil {
  48		fieldCount--
  49	}
  50
  51	if t.Stats == nil {
  52		fieldCount--
  53	}
  54
  55	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
  56		return err
  57	}
  58
  59	// t.LexiconTypeID (string) (string)
  60	if len("$type") > 1000000 {
  61		return xerrors.Errorf("Value in field \"$type\" was too long")
  62	}
  63
  64	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
  65		return err
  66	}
  67	if _, err := cw.WriteString(string("$type")); err != nil {
  68		return err
  69	}
  70
  71	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.actor.profile"))); err != nil {
  72		return err
  73	}
  74	if _, err := cw.WriteString(string("sh.tangled.actor.profile")); err != nil {
  75		return err
  76	}
  77
  78	// t.Links ([]string) (slice)
  79	if t.Links != nil {
  80
  81		if len("links") > 1000000 {
  82			return xerrors.Errorf("Value in field \"links\" was too long")
  83		}
  84
  85		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("links"))); err != nil {
  86			return err
  87		}
  88		if _, err := cw.WriteString(string("links")); err != nil {
  89			return err
  90		}
  91
  92		if len(t.Links) > 8192 {
  93			return xerrors.Errorf("Slice value in field t.Links was too long")
  94		}
  95
  96		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Links))); err != nil {
  97			return err
  98		}
  99		for _, v := range t.Links {
 100			if len(v) > 1000000 {
 101				return xerrors.Errorf("Value in field v was too long")
 102			}
 103
 104			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
 105				return err
 106			}
 107			if _, err := cw.WriteString(string(v)); err != nil {
 108				return err
 109			}
 110
 111		}
 112	}
 113
 114	// t.Stats ([]string) (slice)
 115	if t.Stats != nil {
 116
 117		if len("stats") > 1000000 {
 118			return xerrors.Errorf("Value in field \"stats\" was too long")
 119		}
 120
 121		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("stats"))); err != nil {
 122			return err
 123		}
 124		if _, err := cw.WriteString(string("stats")); err != nil {
 125			return err
 126		}
 127
 128		if len(t.Stats) > 8192 {
 129			return xerrors.Errorf("Slice value in field t.Stats was too long")
 130		}
 131
 132		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Stats))); err != nil {
 133			return err
 134		}
 135		for _, v := range t.Stats {
 136			if len(v) > 1000000 {
 137				return xerrors.Errorf("Value in field v was too long")
 138			}
 139
 140			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
 141				return err
 142			}
 143			if _, err := cw.WriteString(string(v)); err != nil {
 144				return err
 145			}
 146
 147		}
 148	}
 149
 150	// t.Bluesky (bool) (bool)
 151	if len("bluesky") > 1000000 {
 152		return xerrors.Errorf("Value in field \"bluesky\" was too long")
 153	}
 154
 155	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("bluesky"))); err != nil {
 156		return err
 157	}
 158	if _, err := cw.WriteString(string("bluesky")); err != nil {
 159		return err
 160	}
 161
 162	if err := cbg.WriteBool(w, t.Bluesky); err != nil {
 163		return err
 164	}
 165
 166	// t.Location (string) (string)
 167	if t.Location != nil {
 168
 169		if len("location") > 1000000 {
 170			return xerrors.Errorf("Value in field \"location\" was too long")
 171		}
 172
 173		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("location"))); err != nil {
 174			return err
 175		}
 176		if _, err := cw.WriteString(string("location")); err != nil {
 177			return err
 178		}
 179
 180		if t.Location == nil {
 181			if _, err := cw.Write(cbg.CborNull); err != nil {
 182				return err
 183			}
 184		} else {
 185			if len(*t.Location) > 1000000 {
 186				return xerrors.Errorf("Value in field t.Location was too long")
 187			}
 188
 189			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Location))); err != nil {
 190				return err
 191			}
 192			if _, err := cw.WriteString(string(*t.Location)); err != nil {
 193				return err
 194			}
 195		}
 196	}
 197
 198	// t.Pronouns (string) (string)
 199	if t.Pronouns != nil {
 200
 201		if len("pronouns") > 1000000 {
 202			return xerrors.Errorf("Value in field \"pronouns\" was too long")
 203		}
 204
 205		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pronouns"))); err != nil {
 206			return err
 207		}
 208		if _, err := cw.WriteString(string("pronouns")); err != nil {
 209			return err
 210		}
 211
 212		if t.Pronouns == nil {
 213			if _, err := cw.Write(cbg.CborNull); err != nil {
 214				return err
 215			}
 216		} else {
 217			if len(*t.Pronouns) > 1000000 {
 218				return xerrors.Errorf("Value in field t.Pronouns was too long")
 219			}
 220
 221			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Pronouns))); err != nil {
 222				return err
 223			}
 224			if _, err := cw.WriteString(string(*t.Pronouns)); err != nil {
 225				return err
 226			}
 227		}
 228	}
 229
 230	// t.Description (string) (string)
 231	if t.Description != nil {
 232
 233		if len("description") > 1000000 {
 234			return xerrors.Errorf("Value in field \"description\" was too long")
 235		}
 236
 237		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
 238			return err
 239		}
 240		if _, err := cw.WriteString(string("description")); err != nil {
 241			return err
 242		}
 243
 244		if t.Description == nil {
 245			if _, err := cw.Write(cbg.CborNull); err != nil {
 246				return err
 247			}
 248		} else {
 249			if len(*t.Description) > 1000000 {
 250				return xerrors.Errorf("Value in field t.Description was too long")
 251			}
 252
 253			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil {
 254				return err
 255			}
 256			if _, err := cw.WriteString(string(*t.Description)); err != nil {
 257				return err
 258			}
 259		}
 260	}
 261
 262	// t.PinnedRepositories ([]string) (slice)
 263	if t.PinnedRepositories != nil {
 264
 265		if len("pinnedRepositories") > 1000000 {
 266			return xerrors.Errorf("Value in field \"pinnedRepositories\" was too long")
 267		}
 268
 269		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pinnedRepositories"))); err != nil {
 270			return err
 271		}
 272		if _, err := cw.WriteString(string("pinnedRepositories")); err != nil {
 273			return err
 274		}
 275
 276		if len(t.PinnedRepositories) > 8192 {
 277			return xerrors.Errorf("Slice value in field t.PinnedRepositories was too long")
 278		}
 279
 280		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.PinnedRepositories))); err != nil {
 281			return err
 282		}
 283		for _, v := range t.PinnedRepositories {
 284			if len(v) > 1000000 {
 285				return xerrors.Errorf("Value in field v was too long")
 286			}
 287
 288			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
 289				return err
 290			}
 291			if _, err := cw.WriteString(string(v)); err != nil {
 292				return err
 293			}
 294
 295		}
 296	}
 297	return nil
 298}
 299
 300func (t *ActorProfile) UnmarshalCBOR(r io.Reader) (err error) {
 301	*t = ActorProfile{}
 302
 303	cr := cbg.NewCborReader(r)
 304
 305	maj, extra, err := cr.ReadHeader()
 306	if err != nil {
 307		return err
 308	}
 309	defer func() {
 310		if err == io.EOF {
 311			err = io.ErrUnexpectedEOF
 312		}
 313	}()
 314
 315	if maj != cbg.MajMap {
 316		return fmt.Errorf("cbor input should be of type map")
 317	}
 318
 319	if extra > cbg.MaxLength {
 320		return fmt.Errorf("ActorProfile: map struct too large (%d)", extra)
 321	}
 322
 323	n := extra
 324
 325	nameBuf := make([]byte, 18)
 326	for i := uint64(0); i < n; i++ {
 327		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
 328		if err != nil {
 329			return err
 330		}
 331
 332		if !ok {
 333			// Field doesn't exist on this type, so ignore it
 334			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 335				return err
 336			}
 337			continue
 338		}
 339
 340		switch string(nameBuf[:nameLen]) {
 341		// t.LexiconTypeID (string) (string)
 342		case "$type":
 343
 344			{
 345				sval, err := cbg.ReadStringWithMax(cr, 1000000)
 346				if err != nil {
 347					return err
 348				}
 349
 350				t.LexiconTypeID = string(sval)
 351			}
 352			// t.Links ([]string) (slice)
 353		case "links":
 354
 355			maj, extra, err = cr.ReadHeader()
 356			if err != nil {
 357				return err
 358			}
 359
 360			if extra > 8192 {
 361				return fmt.Errorf("t.Links: array too large (%d)", extra)
 362			}
 363
 364			if maj != cbg.MajArray {
 365				return fmt.Errorf("expected cbor array")
 366			}
 367
 368			if extra > 0 {
 369				t.Links = make([]string, extra)
 370			}
 371
 372			for i := 0; i < int(extra); i++ {
 373				{
 374					var maj byte
 375					var extra uint64
 376					var err error
 377					_ = maj
 378					_ = extra
 379					_ = err
 380
 381					{
 382						sval, err := cbg.ReadStringWithMax(cr, 1000000)
 383						if err != nil {
 384							return err
 385						}
 386
 387						t.Links[i] = string(sval)
 388					}
 389
 390				}
 391			}
 392			// t.Stats ([]string) (slice)
 393		case "stats":
 394
 395			maj, extra, err = cr.ReadHeader()
 396			if err != nil {
 397				return err
 398			}
 399
 400			if extra > 8192 {
 401				return fmt.Errorf("t.Stats: array too large (%d)", extra)
 402			}
 403
 404			if maj != cbg.MajArray {
 405				return fmt.Errorf("expected cbor array")
 406			}
 407
 408			if extra > 0 {
 409				t.Stats = make([]string, extra)
 410			}
 411
 412			for i := 0; i < int(extra); i++ {
 413				{
 414					var maj byte
 415					var extra uint64
 416					var err error
 417					_ = maj
 418					_ = extra
 419					_ = err
 420
 421					{
 422						sval, err := cbg.ReadStringWithMax(cr, 1000000)
 423						if err != nil {
 424							return err
 425						}
 426
 427						t.Stats[i] = string(sval)
 428					}
 429
 430				}
 431			}
 432			// t.Bluesky (bool) (bool)
 433		case "bluesky":
 434
 435			maj, extra, err = cr.ReadHeader()
 436			if err != nil {
 437				return err
 438			}
 439			if maj != cbg.MajOther {
 440				return fmt.Errorf("booleans must be major type 7")
 441			}
 442			switch extra {
 443			case 20:
 444				t.Bluesky = false
 445			case 21:
 446				t.Bluesky = true
 447			default:
 448				return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
 449			}
 450			// t.Location (string) (string)
 451		case "location":
 452
 453			{
 454				b, err := cr.ReadByte()
 455				if err != nil {
 456					return err
 457				}
 458				if b != cbg.CborNull[0] {
 459					if err := cr.UnreadByte(); err != nil {
 460						return err
 461					}
 462
 463					sval, err := cbg.ReadStringWithMax(cr, 1000000)
 464					if err != nil {
 465						return err
 466					}
 467
 468					t.Location = (*string)(&sval)
 469				}
 470			}
 471			// t.Pronouns (string) (string)
 472		case "pronouns":
 473
 474			{
 475				b, err := cr.ReadByte()
 476				if err != nil {
 477					return err
 478				}
 479				if b != cbg.CborNull[0] {
 480					if err := cr.UnreadByte(); err != nil {
 481						return err
 482					}
 483
 484					sval, err := cbg.ReadStringWithMax(cr, 1000000)
 485					if err != nil {
 486						return err
 487					}
 488
 489					t.Pronouns = (*string)(&sval)
 490				}
 491			}
 492			// t.Description (string) (string)
 493		case "description":
 494
 495			{
 496				b, err := cr.ReadByte()
 497				if err != nil {
 498					return err
 499				}
 500				if b != cbg.CborNull[0] {
 501					if err := cr.UnreadByte(); err != nil {
 502						return err
 503					}
 504
 505					sval, err := cbg.ReadStringWithMax(cr, 1000000)
 506					if err != nil {
 507						return err
 508					}
 509
 510					t.Description = (*string)(&sval)
 511				}
 512			}
 513			// t.PinnedRepositories ([]string) (slice)
 514		case "pinnedRepositories":
 515
 516			maj, extra, err = cr.ReadHeader()
 517			if err != nil {
 518				return err
 519			}
 520
 521			if extra > 8192 {
 522				return fmt.Errorf("t.PinnedRepositories: array too large (%d)", extra)
 523			}
 524
 525			if maj != cbg.MajArray {
 526				return fmt.Errorf("expected cbor array")
 527			}
 528
 529			if extra > 0 {
 530				t.PinnedRepositories = make([]string, extra)
 531			}
 532
 533			for i := 0; i < int(extra); i++ {
 534				{
 535					var maj byte
 536					var extra uint64
 537					var err error
 538					_ = maj
 539					_ = extra
 540					_ = err
 541
 542					{
 543						sval, err := cbg.ReadStringWithMax(cr, 1000000)
 544						if err != nil {
 545							return err
 546						}
 547
 548						t.PinnedRepositories[i] = string(sval)
 549					}
 550
 551				}
 552			}
 553
 554		default:
 555			// Field doesn't exist on this type, so ignore it
 556			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
 557				return err
 558			}
 559		}
 560	}
 561
 562	return nil
 563}
 564func (t *FeedReaction) MarshalCBOR(w io.Writer) error {
 565	if t == nil {
 566		_, err := w.Write(cbg.CborNull)
 567		return err
 568	}
 569
 570	cw := cbg.NewCborWriter(w)
 571
 572	if _, err := cw.Write([]byte{164}); err != nil {
 573		return err
 574	}
 575
 576	// t.LexiconTypeID (string) (string)
 577	if len("$type") > 1000000 {
 578		return xerrors.Errorf("Value in field \"$type\" was too long")
 579	}
 580
 581	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
 582		return err
 583	}
 584	if _, err := cw.WriteString(string("$type")); err != nil {
 585		return err
 586	}
 587
 588	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.feed.reaction"))); err != nil {
 589		return err
 590	}
 591	if _, err := cw.WriteString(string("sh.tangled.feed.reaction")); err != nil {
 592		return err
 593	}
 594
 595	// t.Subject (string) (string)
 596	if len("subject") > 1000000 {
 597		return xerrors.Errorf("Value in field \"subject\" was too long")
 598	}
 599
 600	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
 601		return err
 602	}
 603	if _, err := cw.WriteString(string("subject")); err != nil {
 604		return err
 605	}
 606
 607	if len(t.Subject) > 1000000 {
 608		return xerrors.Errorf("Value in field t.Subject was too long")
 609	}
 610
 611	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
 612		return err
 613	}
 614	if _, err := cw.WriteString(string(t.Subject)); err != nil {
 615		return err
 616	}
 617
 618	// t.Reaction (string) (string)
 619	if len("reaction") > 1000000 {
 620		return xerrors.Errorf("Value in field \"reaction\" was too long")
 621	}
 622
 623	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("reaction"))); err != nil {
 624		return err
 625	}
 626	if _, err := cw.WriteString(string("reaction")); err != nil {
 627		return err
 628	}
 629
 630	if len(t.Reaction) > 1000000 {
 631		return xerrors.Errorf("Value in field t.Reaction was too long")
 632	}
 633
 634	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Reaction))); err != nil {
 635		return err
 636	}
 637	if _, err := cw.WriteString(string(t.Reaction)); err != nil {
 638		return err
 639	}
 640
 641	// t.CreatedAt (string) (string)
 642	if len("createdAt") > 1000000 {
 643		return xerrors.Errorf("Value in field \"createdAt\" was too long")
 644	}
 645
 646	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
 647		return err
 648	}
 649	if _, err := cw.WriteString(string("createdAt")); err != nil {
 650		return err
 651	}
 652
 653	if len(t.CreatedAt) > 1000000 {
 654		return xerrors.Errorf("Value in field t.CreatedAt was too long")
 655	}
 656
 657	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
 658		return err
 659	}
 660	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
 661		return err
 662	}
 663	return nil
 664}
 665
 666func (t *FeedReaction) UnmarshalCBOR(r io.Reader) (err error) {
 667	*t = FeedReaction{}
 668
 669	cr := cbg.NewCborReader(r)
 670
 671	maj, extra, err := cr.ReadHeader()
 672	if err != nil {
 673		return err
 674	}
 675	defer func() {
 676		if err == io.EOF {
 677			err = io.ErrUnexpectedEOF
 678		}
 679	}()
 680
 681	if maj != cbg.MajMap {
 682		return fmt.Errorf("cbor input should be of type map")
 683	}
 684
 685	if extra > cbg.MaxLength {
 686		return fmt.Errorf("FeedReaction: map struct too large (%d)", extra)
 687	}
 688
 689	n := extra
 690
 691	nameBuf := make([]byte, 9)
 692	for i := uint64(0); i < n; i++ {
 693		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
 694		if err != nil {
 695			return err
 696		}
 697
 698		if !ok {
 699			// Field doesn't exist on this type, so ignore it
 700			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 701				return err
 702			}
 703			continue
 704		}
 705
 706		switch string(nameBuf[:nameLen]) {
 707		// t.LexiconTypeID (string) (string)
 708		case "$type":
 709
 710			{
 711				sval, err := cbg.ReadStringWithMax(cr, 1000000)
 712				if err != nil {
 713					return err
 714				}
 715
 716				t.LexiconTypeID = string(sval)
 717			}
 718			// t.Subject (string) (string)
 719		case "subject":
 720
 721			{
 722				sval, err := cbg.ReadStringWithMax(cr, 1000000)
 723				if err != nil {
 724					return err
 725				}
 726
 727				t.Subject = string(sval)
 728			}
 729			// t.Reaction (string) (string)
 730		case "reaction":
 731
 732			{
 733				sval, err := cbg.ReadStringWithMax(cr, 1000000)
 734				if err != nil {
 735					return err
 736				}
 737
 738				t.Reaction = string(sval)
 739			}
 740			// t.CreatedAt (string) (string)
 741		case "createdAt":
 742
 743			{
 744				sval, err := cbg.ReadStringWithMax(cr, 1000000)
 745				if err != nil {
 746					return err
 747				}
 748
 749				t.CreatedAt = string(sval)
 750			}
 751
 752		default:
 753			// Field doesn't exist on this type, so ignore it
 754			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
 755				return err
 756			}
 757		}
 758	}
 759
 760	return nil
 761}
 762func (t *FeedStar) MarshalCBOR(w io.Writer) error {
 763	if t == nil {
 764		_, err := w.Write(cbg.CborNull)
 765		return err
 766	}
 767
 768	cw := cbg.NewCborWriter(w)
 769
 770	if _, err := cw.Write([]byte{163}); err != nil {
 771		return err
 772	}
 773
 774	// t.LexiconTypeID (string) (string)
 775	if len("$type") > 1000000 {
 776		return xerrors.Errorf("Value in field \"$type\" was too long")
 777	}
 778
 779	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
 780		return err
 781	}
 782	if _, err := cw.WriteString(string("$type")); err != nil {
 783		return err
 784	}
 785
 786	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.feed.star"))); err != nil {
 787		return err
 788	}
 789	if _, err := cw.WriteString(string("sh.tangled.feed.star")); err != nil {
 790		return err
 791	}
 792
 793	// t.Subject (string) (string)
 794	if len("subject") > 1000000 {
 795		return xerrors.Errorf("Value in field \"subject\" was too long")
 796	}
 797
 798	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
 799		return err
 800	}
 801	if _, err := cw.WriteString(string("subject")); err != nil {
 802		return err
 803	}
 804
 805	if len(t.Subject) > 1000000 {
 806		return xerrors.Errorf("Value in field t.Subject was too long")
 807	}
 808
 809	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
 810		return err
 811	}
 812	if _, err := cw.WriteString(string(t.Subject)); err != nil {
 813		return err
 814	}
 815
 816	// t.CreatedAt (string) (string)
 817	if len("createdAt") > 1000000 {
 818		return xerrors.Errorf("Value in field \"createdAt\" was too long")
 819	}
 820
 821	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
 822		return err
 823	}
 824	if _, err := cw.WriteString(string("createdAt")); err != nil {
 825		return err
 826	}
 827
 828	if len(t.CreatedAt) > 1000000 {
 829		return xerrors.Errorf("Value in field t.CreatedAt was too long")
 830	}
 831
 832	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
 833		return err
 834	}
 835	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
 836		return err
 837	}
 838	return nil
 839}
 840
 841func (t *FeedStar) UnmarshalCBOR(r io.Reader) (err error) {
 842	*t = FeedStar{}
 843
 844	cr := cbg.NewCborReader(r)
 845
 846	maj, extra, err := cr.ReadHeader()
 847	if err != nil {
 848		return err
 849	}
 850	defer func() {
 851		if err == io.EOF {
 852			err = io.ErrUnexpectedEOF
 853		}
 854	}()
 855
 856	if maj != cbg.MajMap {
 857		return fmt.Errorf("cbor input should be of type map")
 858	}
 859
 860	if extra > cbg.MaxLength {
 861		return fmt.Errorf("FeedStar: map struct too large (%d)", extra)
 862	}
 863
 864	n := extra
 865
 866	nameBuf := make([]byte, 9)
 867	for i := uint64(0); i < n; i++ {
 868		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
 869		if err != nil {
 870			return err
 871		}
 872
 873		if !ok {
 874			// Field doesn't exist on this type, so ignore it
 875			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 876				return err
 877			}
 878			continue
 879		}
 880
 881		switch string(nameBuf[:nameLen]) {
 882		// t.LexiconTypeID (string) (string)
 883		case "$type":
 884
 885			{
 886				sval, err := cbg.ReadStringWithMax(cr, 1000000)
 887				if err != nil {
 888					return err
 889				}
 890
 891				t.LexiconTypeID = string(sval)
 892			}
 893			// t.Subject (string) (string)
 894		case "subject":
 895
 896			{
 897				sval, err := cbg.ReadStringWithMax(cr, 1000000)
 898				if err != nil {
 899					return err
 900				}
 901
 902				t.Subject = string(sval)
 903			}
 904			// t.CreatedAt (string) (string)
 905		case "createdAt":
 906
 907			{
 908				sval, err := cbg.ReadStringWithMax(cr, 1000000)
 909				if err != nil {
 910					return err
 911				}
 912
 913				t.CreatedAt = string(sval)
 914			}
 915
 916		default:
 917			// Field doesn't exist on this type, so ignore it
 918			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
 919				return err
 920			}
 921		}
 922	}
 923
 924	return nil
 925}
 926func (t *GitRefUpdate) MarshalCBOR(w io.Writer) error {
 927	if t == nil {
 928		_, err := w.Write(cbg.CborNull)
 929		return err
 930	}
 931
 932	cw := cbg.NewCborWriter(w)
 933
 934	if _, err := cw.Write([]byte{168}); err != nil {
 935		return err
 936	}
 937
 938	// t.Ref (string) (string)
 939	if len("ref") > 1000000 {
 940		return xerrors.Errorf("Value in field \"ref\" was too long")
 941	}
 942
 943	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ref"))); err != nil {
 944		return err
 945	}
 946	if _, err := cw.WriteString(string("ref")); err != nil {
 947		return err
 948	}
 949
 950	if len(t.Ref) > 1000000 {
 951		return xerrors.Errorf("Value in field t.Ref was too long")
 952	}
 953
 954	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Ref))); err != nil {
 955		return err
 956	}
 957	if _, err := cw.WriteString(string(t.Ref)); err != nil {
 958		return err
 959	}
 960
 961	// t.Meta (tangled.GitRefUpdate_Meta) (struct)
 962	if len("meta") > 1000000 {
 963		return xerrors.Errorf("Value in field \"meta\" was too long")
 964	}
 965
 966	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("meta"))); err != nil {
 967		return err
 968	}
 969	if _, err := cw.WriteString(string("meta")); err != nil {
 970		return err
 971	}
 972
 973	if err := t.Meta.MarshalCBOR(cw); err != nil {
 974		return err
 975	}
 976
 977	// t.LexiconTypeID (string) (string)
 978	if len("$type") > 1000000 {
 979		return xerrors.Errorf("Value in field \"$type\" was too long")
 980	}
 981
 982	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
 983		return err
 984	}
 985	if _, err := cw.WriteString(string("$type")); err != nil {
 986		return err
 987	}
 988
 989	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.git.refUpdate"))); err != nil {
 990		return err
 991	}
 992	if _, err := cw.WriteString(string("sh.tangled.git.refUpdate")); err != nil {
 993		return err
 994	}
 995
 996	// t.NewSha (string) (string)
 997	if len("newSha") > 1000000 {
 998		return xerrors.Errorf("Value in field \"newSha\" was too long")
 999	}
1000
1001	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("newSha"))); err != nil {
1002		return err
1003	}
1004	if _, err := cw.WriteString(string("newSha")); err != nil {
1005		return err
1006	}
1007
1008	if len(t.NewSha) > 1000000 {
1009		return xerrors.Errorf("Value in field t.NewSha was too long")
1010	}
1011
1012	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.NewSha))); err != nil {
1013		return err
1014	}
1015	if _, err := cw.WriteString(string(t.NewSha)); err != nil {
1016		return err
1017	}
1018
1019	// t.OldSha (string) (string)
1020	if len("oldSha") > 1000000 {
1021		return xerrors.Errorf("Value in field \"oldSha\" was too long")
1022	}
1023
1024	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("oldSha"))); err != nil {
1025		return err
1026	}
1027	if _, err := cw.WriteString(string("oldSha")); err != nil {
1028		return err
1029	}
1030
1031	if len(t.OldSha) > 1000000 {
1032		return xerrors.Errorf("Value in field t.OldSha was too long")
1033	}
1034
1035	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.OldSha))); err != nil {
1036		return err
1037	}
1038	if _, err := cw.WriteString(string(t.OldSha)); err != nil {
1039		return err
1040	}
1041
1042	// t.RepoDid (string) (string)
1043	if len("repoDid") > 1000000 {
1044		return xerrors.Errorf("Value in field \"repoDid\" was too long")
1045	}
1046
1047	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil {
1048		return err
1049	}
1050	if _, err := cw.WriteString(string("repoDid")); err != nil {
1051		return err
1052	}
1053
1054	if len(t.RepoDid) > 1000000 {
1055		return xerrors.Errorf("Value in field t.RepoDid was too long")
1056	}
1057
1058	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.RepoDid))); err != nil {
1059		return err
1060	}
1061	if _, err := cw.WriteString(string(t.RepoDid)); err != nil {
1062		return err
1063	}
1064
1065	// t.RepoName (string) (string)
1066	if len("repoName") > 1000000 {
1067		return xerrors.Errorf("Value in field \"repoName\" was too long")
1068	}
1069
1070	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoName"))); err != nil {
1071		return err
1072	}
1073	if _, err := cw.WriteString(string("repoName")); err != nil {
1074		return err
1075	}
1076
1077	if len(t.RepoName) > 1000000 {
1078		return xerrors.Errorf("Value in field t.RepoName was too long")
1079	}
1080
1081	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.RepoName))); err != nil {
1082		return err
1083	}
1084	if _, err := cw.WriteString(string(t.RepoName)); err != nil {
1085		return err
1086	}
1087
1088	// t.CommitterDid (string) (string)
1089	if len("committerDid") > 1000000 {
1090		return xerrors.Errorf("Value in field \"committerDid\" was too long")
1091	}
1092
1093	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("committerDid"))); err != nil {
1094		return err
1095	}
1096	if _, err := cw.WriteString(string("committerDid")); err != nil {
1097		return err
1098	}
1099
1100	if len(t.CommitterDid) > 1000000 {
1101		return xerrors.Errorf("Value in field t.CommitterDid was too long")
1102	}
1103
1104	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CommitterDid))); err != nil {
1105		return err
1106	}
1107	if _, err := cw.WriteString(string(t.CommitterDid)); err != nil {
1108		return err
1109	}
1110	return nil
1111}
1112
1113func (t *GitRefUpdate) UnmarshalCBOR(r io.Reader) (err error) {
1114	*t = GitRefUpdate{}
1115
1116	cr := cbg.NewCborReader(r)
1117
1118	maj, extra, err := cr.ReadHeader()
1119	if err != nil {
1120		return err
1121	}
1122	defer func() {
1123		if err == io.EOF {
1124			err = io.ErrUnexpectedEOF
1125		}
1126	}()
1127
1128	if maj != cbg.MajMap {
1129		return fmt.Errorf("cbor input should be of type map")
1130	}
1131
1132	if extra > cbg.MaxLength {
1133		return fmt.Errorf("GitRefUpdate: map struct too large (%d)", extra)
1134	}
1135
1136	n := extra
1137
1138	nameBuf := make([]byte, 12)
1139	for i := uint64(0); i < n; i++ {
1140		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1141		if err != nil {
1142			return err
1143		}
1144
1145		if !ok {
1146			// Field doesn't exist on this type, so ignore it
1147			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1148				return err
1149			}
1150			continue
1151		}
1152
1153		switch string(nameBuf[:nameLen]) {
1154		// t.Ref (string) (string)
1155		case "ref":
1156
1157			{
1158				sval, err := cbg.ReadStringWithMax(cr, 1000000)
1159				if err != nil {
1160					return err
1161				}
1162
1163				t.Ref = string(sval)
1164			}
1165			// t.Meta (tangled.GitRefUpdate_Meta) (struct)
1166		case "meta":
1167
1168			{
1169
1170				b, err := cr.ReadByte()
1171				if err != nil {
1172					return err
1173				}
1174				if b != cbg.CborNull[0] {
1175					if err := cr.UnreadByte(); err != nil {
1176						return err
1177					}
1178					t.Meta = new(GitRefUpdate_Meta)
1179					if err := t.Meta.UnmarshalCBOR(cr); err != nil {
1180						return xerrors.Errorf("unmarshaling t.Meta pointer: %w", err)
1181					}
1182				}
1183
1184			}
1185			// t.LexiconTypeID (string) (string)
1186		case "$type":
1187
1188			{
1189				sval, err := cbg.ReadStringWithMax(cr, 1000000)
1190				if err != nil {
1191					return err
1192				}
1193
1194				t.LexiconTypeID = string(sval)
1195			}
1196			// t.NewSha (string) (string)
1197		case "newSha":
1198
1199			{
1200				sval, err := cbg.ReadStringWithMax(cr, 1000000)
1201				if err != nil {
1202					return err
1203				}
1204
1205				t.NewSha = string(sval)
1206			}
1207			// t.OldSha (string) (string)
1208		case "oldSha":
1209
1210			{
1211				sval, err := cbg.ReadStringWithMax(cr, 1000000)
1212				if err != nil {
1213					return err
1214				}
1215
1216				t.OldSha = string(sval)
1217			}
1218			// t.RepoDid (string) (string)
1219		case "repoDid":
1220
1221			{
1222				sval, err := cbg.ReadStringWithMax(cr, 1000000)
1223				if err != nil {
1224					return err
1225				}
1226
1227				t.RepoDid = string(sval)
1228			}
1229			// t.RepoName (string) (string)
1230		case "repoName":
1231
1232			{
1233				sval, err := cbg.ReadStringWithMax(cr, 1000000)
1234				if err != nil {
1235					return err
1236				}
1237
1238				t.RepoName = string(sval)
1239			}
1240			// t.CommitterDid (string) (string)
1241		case "committerDid":
1242
1243			{
1244				sval, err := cbg.ReadStringWithMax(cr, 1000000)
1245				if err != nil {
1246					return err
1247				}
1248
1249				t.CommitterDid = string(sval)
1250			}
1251
1252		default:
1253			// Field doesn't exist on this type, so ignore it
1254			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1255				return err
1256			}
1257		}
1258	}
1259
1260	return nil
1261}
1262func (t *GitRefUpdate_CommitCountBreakdown) MarshalCBOR(w io.Writer) error {
1263	if t == nil {
1264		_, err := w.Write(cbg.CborNull)
1265		return err
1266	}
1267
1268	cw := cbg.NewCborWriter(w)
1269	fieldCount := 1
1270
1271	if t.ByEmail == nil {
1272		fieldCount--
1273	}
1274
1275	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
1276		return err
1277	}
1278
1279	// t.ByEmail ([]*tangled.GitRefUpdate_IndividualEmailCommitCount) (slice)
1280	if t.ByEmail != nil {
1281
1282		if len("byEmail") > 1000000 {
1283			return xerrors.Errorf("Value in field \"byEmail\" was too long")
1284		}
1285
1286		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("byEmail"))); err != nil {
1287			return err
1288		}
1289		if _, err := cw.WriteString(string("byEmail")); err != nil {
1290			return err
1291		}
1292
1293		if len(t.ByEmail) > 8192 {
1294			return xerrors.Errorf("Slice value in field t.ByEmail was too long")
1295		}
1296
1297		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.ByEmail))); err != nil {
1298			return err
1299		}
1300		for _, v := range t.ByEmail {
1301			if err := v.MarshalCBOR(cw); err != nil {
1302				return err
1303			}
1304
1305		}
1306	}
1307	return nil
1308}
1309
1310func (t *GitRefUpdate_CommitCountBreakdown) UnmarshalCBOR(r io.Reader) (err error) {
1311	*t = GitRefUpdate_CommitCountBreakdown{}
1312
1313	cr := cbg.NewCborReader(r)
1314
1315	maj, extra, err := cr.ReadHeader()
1316	if err != nil {
1317		return err
1318	}
1319	defer func() {
1320		if err == io.EOF {
1321			err = io.ErrUnexpectedEOF
1322		}
1323	}()
1324
1325	if maj != cbg.MajMap {
1326		return fmt.Errorf("cbor input should be of type map")
1327	}
1328
1329	if extra > cbg.MaxLength {
1330		return fmt.Errorf("GitRefUpdate_CommitCountBreakdown: map struct too large (%d)", extra)
1331	}
1332
1333	n := extra
1334
1335	nameBuf := make([]byte, 7)
1336	for i := uint64(0); i < n; i++ {
1337		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1338		if err != nil {
1339			return err
1340		}
1341
1342		if !ok {
1343			// Field doesn't exist on this type, so ignore it
1344			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1345				return err
1346			}
1347			continue
1348		}
1349
1350		switch string(nameBuf[:nameLen]) {
1351		// t.ByEmail ([]*tangled.GitRefUpdate_IndividualEmailCommitCount) (slice)
1352		case "byEmail":
1353
1354			maj, extra, err = cr.ReadHeader()
1355			if err != nil {
1356				return err
1357			}
1358
1359			if extra > 8192 {
1360				return fmt.Errorf("t.ByEmail: array too large (%d)", extra)
1361			}
1362
1363			if maj != cbg.MajArray {
1364				return fmt.Errorf("expected cbor array")
1365			}
1366
1367			if extra > 0 {
1368				t.ByEmail = make([]*GitRefUpdate_IndividualEmailCommitCount, extra)
1369			}
1370
1371			for i := 0; i < int(extra); i++ {
1372				{
1373					var maj byte
1374					var extra uint64
1375					var err error
1376					_ = maj
1377					_ = extra
1378					_ = err
1379
1380					{
1381
1382						b, err := cr.ReadByte()
1383						if err != nil {
1384							return err
1385						}
1386						if b != cbg.CborNull[0] {
1387							if err := cr.UnreadByte(); err != nil {
1388								return err
1389							}
1390							t.ByEmail[i] = new(GitRefUpdate_IndividualEmailCommitCount)
1391							if err := t.ByEmail[i].UnmarshalCBOR(cr); err != nil {
1392								return xerrors.Errorf("unmarshaling t.ByEmail[i] pointer: %w", err)
1393							}
1394						}
1395
1396					}
1397
1398				}
1399			}
1400
1401		default:
1402			// Field doesn't exist on this type, so ignore it
1403			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1404				return err
1405			}
1406		}
1407	}
1408
1409	return nil
1410}
1411func (t *GitRefUpdate_IndividualEmailCommitCount) MarshalCBOR(w io.Writer) error {
1412	if t == nil {
1413		_, err := w.Write(cbg.CborNull)
1414		return err
1415	}
1416
1417	cw := cbg.NewCborWriter(w)
1418
1419	if _, err := cw.Write([]byte{162}); err != nil {
1420		return err
1421	}
1422
1423	// t.Count (int64) (int64)
1424	if len("count") > 1000000 {
1425		return xerrors.Errorf("Value in field \"count\" was too long")
1426	}
1427
1428	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("count"))); err != nil {
1429		return err
1430	}
1431	if _, err := cw.WriteString(string("count")); err != nil {
1432		return err
1433	}
1434
1435	if t.Count >= 0 {
1436		if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Count)); err != nil {
1437			return err
1438		}
1439	} else {
1440		if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Count-1)); err != nil {
1441			return err
1442		}
1443	}
1444
1445	// t.Email (string) (string)
1446	if len("email") > 1000000 {
1447		return xerrors.Errorf("Value in field \"email\" was too long")
1448	}
1449
1450	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("email"))); err != nil {
1451		return err
1452	}
1453	if _, err := cw.WriteString(string("email")); err != nil {
1454		return err
1455	}
1456
1457	if len(t.Email) > 1000000 {
1458		return xerrors.Errorf("Value in field t.Email was too long")
1459	}
1460
1461	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Email))); err != nil {
1462		return err
1463	}
1464	if _, err := cw.WriteString(string(t.Email)); err != nil {
1465		return err
1466	}
1467	return nil
1468}
1469
1470func (t *GitRefUpdate_IndividualEmailCommitCount) UnmarshalCBOR(r io.Reader) (err error) {
1471	*t = GitRefUpdate_IndividualEmailCommitCount{}
1472
1473	cr := cbg.NewCborReader(r)
1474
1475	maj, extra, err := cr.ReadHeader()
1476	if err != nil {
1477		return err
1478	}
1479	defer func() {
1480		if err == io.EOF {
1481			err = io.ErrUnexpectedEOF
1482		}
1483	}()
1484
1485	if maj != cbg.MajMap {
1486		return fmt.Errorf("cbor input should be of type map")
1487	}
1488
1489	if extra > cbg.MaxLength {
1490		return fmt.Errorf("GitRefUpdate_IndividualEmailCommitCount: map struct too large (%d)", extra)
1491	}
1492
1493	n := extra
1494
1495	nameBuf := make([]byte, 5)
1496	for i := uint64(0); i < n; i++ {
1497		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1498		if err != nil {
1499			return err
1500		}
1501
1502		if !ok {
1503			// Field doesn't exist on this type, so ignore it
1504			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1505				return err
1506			}
1507			continue
1508		}
1509
1510		switch string(nameBuf[:nameLen]) {
1511		// t.Count (int64) (int64)
1512		case "count":
1513			{
1514				maj, extra, err := cr.ReadHeader()
1515				if err != nil {
1516					return err
1517				}
1518				var extraI int64
1519				switch maj {
1520				case cbg.MajUnsignedInt:
1521					extraI = int64(extra)
1522					if extraI < 0 {
1523						return fmt.Errorf("int64 positive overflow")
1524					}
1525				case cbg.MajNegativeInt:
1526					extraI = int64(extra)
1527					if extraI < 0 {
1528						return fmt.Errorf("int64 negative overflow")
1529					}
1530					extraI = -1 - extraI
1531				default:
1532					return fmt.Errorf("wrong type for int64 field: %d", maj)
1533				}
1534
1535				t.Count = int64(extraI)
1536			}
1537			// t.Email (string) (string)
1538		case "email":
1539
1540			{
1541				sval, err := cbg.ReadStringWithMax(cr, 1000000)
1542				if err != nil {
1543					return err
1544				}
1545
1546				t.Email = string(sval)
1547			}
1548
1549		default:
1550			// Field doesn't exist on this type, so ignore it
1551			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1552				return err
1553			}
1554		}
1555	}
1556
1557	return nil
1558}
1559func (t *GitRefUpdate_IndividualLanguageSize) MarshalCBOR(w io.Writer) error {
1560	if t == nil {
1561		_, err := w.Write(cbg.CborNull)
1562		return err
1563	}
1564
1565	cw := cbg.NewCborWriter(w)
1566
1567	if _, err := cw.Write([]byte{162}); err != nil {
1568		return err
1569	}
1570
1571	// t.Lang (string) (string)
1572	if len("lang") > 1000000 {
1573		return xerrors.Errorf("Value in field \"lang\" was too long")
1574	}
1575
1576	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("lang"))); err != nil {
1577		return err
1578	}
1579	if _, err := cw.WriteString(string("lang")); err != nil {
1580		return err
1581	}
1582
1583	if len(t.Lang) > 1000000 {
1584		return xerrors.Errorf("Value in field t.Lang was too long")
1585	}
1586
1587	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Lang))); err != nil {
1588		return err
1589	}
1590	if _, err := cw.WriteString(string(t.Lang)); err != nil {
1591		return err
1592	}
1593
1594	// t.Size (int64) (int64)
1595	if len("size") > 1000000 {
1596		return xerrors.Errorf("Value in field \"size\" was too long")
1597	}
1598
1599	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("size"))); err != nil {
1600		return err
1601	}
1602	if _, err := cw.WriteString(string("size")); err != nil {
1603		return err
1604	}
1605
1606	if t.Size >= 0 {
1607		if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Size)); err != nil {
1608			return err
1609		}
1610	} else {
1611		if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Size-1)); err != nil {
1612			return err
1613		}
1614	}
1615
1616	return nil
1617}
1618
1619func (t *GitRefUpdate_IndividualLanguageSize) UnmarshalCBOR(r io.Reader) (err error) {
1620	*t = GitRefUpdate_IndividualLanguageSize{}
1621
1622	cr := cbg.NewCborReader(r)
1623
1624	maj, extra, err := cr.ReadHeader()
1625	if err != nil {
1626		return err
1627	}
1628	defer func() {
1629		if err == io.EOF {
1630			err = io.ErrUnexpectedEOF
1631		}
1632	}()
1633
1634	if maj != cbg.MajMap {
1635		return fmt.Errorf("cbor input should be of type map")
1636	}
1637
1638	if extra > cbg.MaxLength {
1639		return fmt.Errorf("GitRefUpdate_IndividualLanguageSize: map struct too large (%d)", extra)
1640	}
1641
1642	n := extra
1643
1644	nameBuf := make([]byte, 4)
1645	for i := uint64(0); i < n; i++ {
1646		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1647		if err != nil {
1648			return err
1649		}
1650
1651		if !ok {
1652			// Field doesn't exist on this type, so ignore it
1653			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1654				return err
1655			}
1656			continue
1657		}
1658
1659		switch string(nameBuf[:nameLen]) {
1660		// t.Lang (string) (string)
1661		case "lang":
1662
1663			{
1664				sval, err := cbg.ReadStringWithMax(cr, 1000000)
1665				if err != nil {
1666					return err
1667				}
1668
1669				t.Lang = string(sval)
1670			}
1671			// t.Size (int64) (int64)
1672		case "size":
1673			{
1674				maj, extra, err := cr.ReadHeader()
1675				if err != nil {
1676					return err
1677				}
1678				var extraI int64
1679				switch maj {
1680				case cbg.MajUnsignedInt:
1681					extraI = int64(extra)
1682					if extraI < 0 {
1683						return fmt.Errorf("int64 positive overflow")
1684					}
1685				case cbg.MajNegativeInt:
1686					extraI = int64(extra)
1687					if extraI < 0 {
1688						return fmt.Errorf("int64 negative overflow")
1689					}
1690					extraI = -1 - extraI
1691				default:
1692					return fmt.Errorf("wrong type for int64 field: %d", maj)
1693				}
1694
1695				t.Size = int64(extraI)
1696			}
1697
1698		default:
1699			// Field doesn't exist on this type, so ignore it
1700			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1701				return err
1702			}
1703		}
1704	}
1705
1706	return nil
1707}
1708func (t *GitRefUpdate_LangBreakdown) MarshalCBOR(w io.Writer) error {
1709	if t == nil {
1710		_, err := w.Write(cbg.CborNull)
1711		return err
1712	}
1713
1714	cw := cbg.NewCborWriter(w)
1715	fieldCount := 1
1716
1717	if t.Inputs == nil {
1718		fieldCount--
1719	}
1720
1721	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
1722		return err
1723	}
1724
1725	// t.Inputs ([]*tangled.GitRefUpdate_IndividualLanguageSize) (slice)
1726	if t.Inputs != nil {
1727
1728		if len("inputs") > 1000000 {
1729			return xerrors.Errorf("Value in field \"inputs\" was too long")
1730		}
1731
1732		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("inputs"))); err != nil {
1733			return err
1734		}
1735		if _, err := cw.WriteString(string("inputs")); err != nil {
1736			return err
1737		}
1738
1739		if len(t.Inputs) > 8192 {
1740			return xerrors.Errorf("Slice value in field t.Inputs was too long")
1741		}
1742
1743		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Inputs))); err != nil {
1744			return err
1745		}
1746		for _, v := range t.Inputs {
1747			if err := v.MarshalCBOR(cw); err != nil {
1748				return err
1749			}
1750
1751		}
1752	}
1753	return nil
1754}
1755
1756func (t *GitRefUpdate_LangBreakdown) UnmarshalCBOR(r io.Reader) (err error) {
1757	*t = GitRefUpdate_LangBreakdown{}
1758
1759	cr := cbg.NewCborReader(r)
1760
1761	maj, extra, err := cr.ReadHeader()
1762	if err != nil {
1763		return err
1764	}
1765	defer func() {
1766		if err == io.EOF {
1767			err = io.ErrUnexpectedEOF
1768		}
1769	}()
1770
1771	if maj != cbg.MajMap {
1772		return fmt.Errorf("cbor input should be of type map")
1773	}
1774
1775	if extra > cbg.MaxLength {
1776		return fmt.Errorf("GitRefUpdate_LangBreakdown: map struct too large (%d)", extra)
1777	}
1778
1779	n := extra
1780
1781	nameBuf := make([]byte, 6)
1782	for i := uint64(0); i < n; i++ {
1783		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1784		if err != nil {
1785			return err
1786		}
1787
1788		if !ok {
1789			// Field doesn't exist on this type, so ignore it
1790			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1791				return err
1792			}
1793			continue
1794		}
1795
1796		switch string(nameBuf[:nameLen]) {
1797		// t.Inputs ([]*tangled.GitRefUpdate_IndividualLanguageSize) (slice)
1798		case "inputs":
1799
1800			maj, extra, err = cr.ReadHeader()
1801			if err != nil {
1802				return err
1803			}
1804
1805			if extra > 8192 {
1806				return fmt.Errorf("t.Inputs: array too large (%d)", extra)
1807			}
1808
1809			if maj != cbg.MajArray {
1810				return fmt.Errorf("expected cbor array")
1811			}
1812
1813			if extra > 0 {
1814				t.Inputs = make([]*GitRefUpdate_IndividualLanguageSize, extra)
1815			}
1816
1817			for i := 0; i < int(extra); i++ {
1818				{
1819					var maj byte
1820					var extra uint64
1821					var err error
1822					_ = maj
1823					_ = extra
1824					_ = err
1825
1826					{
1827
1828						b, err := cr.ReadByte()
1829						if err != nil {
1830							return err
1831						}
1832						if b != cbg.CborNull[0] {
1833							if err := cr.UnreadByte(); err != nil {
1834								return err
1835							}
1836							t.Inputs[i] = new(GitRefUpdate_IndividualLanguageSize)
1837							if err := t.Inputs[i].UnmarshalCBOR(cr); err != nil {
1838								return xerrors.Errorf("unmarshaling t.Inputs[i] pointer: %w", err)
1839							}
1840						}
1841
1842					}
1843
1844				}
1845			}
1846
1847		default:
1848			// Field doesn't exist on this type, so ignore it
1849			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
1850				return err
1851			}
1852		}
1853	}
1854
1855	return nil
1856}
1857func (t *GitRefUpdate_Meta) MarshalCBOR(w io.Writer) error {
1858	if t == nil {
1859		_, err := w.Write(cbg.CborNull)
1860		return err
1861	}
1862
1863	cw := cbg.NewCborWriter(w)
1864	fieldCount := 3
1865
1866	if t.LangBreakdown == nil {
1867		fieldCount--
1868	}
1869
1870	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
1871		return err
1872	}
1873
1874	// t.CommitCount (tangled.GitRefUpdate_CommitCountBreakdown) (struct)
1875	if len("commitCount") > 1000000 {
1876		return xerrors.Errorf("Value in field \"commitCount\" was too long")
1877	}
1878
1879	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("commitCount"))); err != nil {
1880		return err
1881	}
1882	if _, err := cw.WriteString(string("commitCount")); err != nil {
1883		return err
1884	}
1885
1886	if err := t.CommitCount.MarshalCBOR(cw); err != nil {
1887		return err
1888	}
1889
1890	// t.IsDefaultRef (bool) (bool)
1891	if len("isDefaultRef") > 1000000 {
1892		return xerrors.Errorf("Value in field \"isDefaultRef\" was too long")
1893	}
1894
1895	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("isDefaultRef"))); err != nil {
1896		return err
1897	}
1898	if _, err := cw.WriteString(string("isDefaultRef")); err != nil {
1899		return err
1900	}
1901
1902	if err := cbg.WriteBool(w, t.IsDefaultRef); err != nil {
1903		return err
1904	}
1905
1906	// t.LangBreakdown (tangled.GitRefUpdate_LangBreakdown) (struct)
1907	if t.LangBreakdown != nil {
1908
1909		if len("langBreakdown") > 1000000 {
1910			return xerrors.Errorf("Value in field \"langBreakdown\" was too long")
1911		}
1912
1913		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("langBreakdown"))); err != nil {
1914			return err
1915		}
1916		if _, err := cw.WriteString(string("langBreakdown")); err != nil {
1917			return err
1918		}
1919
1920		if err := t.LangBreakdown.MarshalCBOR(cw); err != nil {
1921			return err
1922		}
1923	}
1924	return nil
1925}
1926
1927func (t *GitRefUpdate_Meta) UnmarshalCBOR(r io.Reader) (err error) {
1928	*t = GitRefUpdate_Meta{}
1929
1930	cr := cbg.NewCborReader(r)
1931
1932	maj, extra, err := cr.ReadHeader()
1933	if err != nil {
1934		return err
1935	}
1936	defer func() {
1937		if err == io.EOF {
1938			err = io.ErrUnexpectedEOF
1939		}
1940	}()
1941
1942	if maj != cbg.MajMap {
1943		return fmt.Errorf("cbor input should be of type map")
1944	}
1945
1946	if extra > cbg.MaxLength {
1947		return fmt.Errorf("GitRefUpdate_Meta: map struct too large (%d)", extra)
1948	}
1949
1950	n := extra
1951
1952	nameBuf := make([]byte, 13)
1953	for i := uint64(0); i < n; i++ {
1954		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
1955		if err != nil {
1956			return err
1957		}
1958
1959		if !ok {
1960			// Field doesn't exist on this type, so ignore it
1961			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
1962				return err
1963			}
1964			continue
1965		}
1966
1967		switch string(nameBuf[:nameLen]) {
1968		// t.CommitCount (tangled.GitRefUpdate_CommitCountBreakdown) (struct)
1969		case "commitCount":
1970
1971			{
1972
1973				b, err := cr.ReadByte()
1974				if err != nil {
1975					return err
1976				}
1977				if b != cbg.CborNull[0] {
1978					if err := cr.UnreadByte(); err != nil {
1979						return err
1980					}
1981					t.CommitCount = new(GitRefUpdate_CommitCountBreakdown)
1982					if err := t.CommitCount.UnmarshalCBOR(cr); err != nil {
1983						return xerrors.Errorf("unmarshaling t.CommitCount pointer: %w", err)
1984					}
1985				}
1986
1987			}
1988			// t.IsDefaultRef (bool) (bool)
1989		case "isDefaultRef":
1990
1991			maj, extra, err = cr.ReadHeader()
1992			if err != nil {
1993				return err
1994			}
1995			if maj != cbg.MajOther {
1996				return fmt.Errorf("booleans must be major type 7")
1997			}
1998			switch extra {
1999			case 20:
2000				t.IsDefaultRef = false
2001			case 21:
2002				t.IsDefaultRef = true
2003			default:
2004				return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
2005			}
2006			// t.LangBreakdown (tangled.GitRefUpdate_LangBreakdown) (struct)
2007		case "langBreakdown":
2008
2009			{
2010
2011				b, err := cr.ReadByte()
2012				if err != nil {
2013					return err
2014				}
2015				if b != cbg.CborNull[0] {
2016					if err := cr.UnreadByte(); err != nil {
2017						return err
2018					}
2019					t.LangBreakdown = new(GitRefUpdate_LangBreakdown)
2020					if err := t.LangBreakdown.UnmarshalCBOR(cr); err != nil {
2021						return xerrors.Errorf("unmarshaling t.LangBreakdown pointer: %w", err)
2022					}
2023				}
2024
2025			}
2026
2027		default:
2028			// Field doesn't exist on this type, so ignore it
2029			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2030				return err
2031			}
2032		}
2033	}
2034
2035	return nil
2036}
2037func (t *GraphFollow) MarshalCBOR(w io.Writer) error {
2038	if t == nil {
2039		_, err := w.Write(cbg.CborNull)
2040		return err
2041	}
2042
2043	cw := cbg.NewCborWriter(w)
2044
2045	if _, err := cw.Write([]byte{163}); err != nil {
2046		return err
2047	}
2048
2049	// t.LexiconTypeID (string) (string)
2050	if len("$type") > 1000000 {
2051		return xerrors.Errorf("Value in field \"$type\" was too long")
2052	}
2053
2054	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
2055		return err
2056	}
2057	if _, err := cw.WriteString(string("$type")); err != nil {
2058		return err
2059	}
2060
2061	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.graph.follow"))); err != nil {
2062		return err
2063	}
2064	if _, err := cw.WriteString(string("sh.tangled.graph.follow")); err != nil {
2065		return err
2066	}
2067
2068	// t.Subject (string) (string)
2069	if len("subject") > 1000000 {
2070		return xerrors.Errorf("Value in field \"subject\" was too long")
2071	}
2072
2073	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
2074		return err
2075	}
2076	if _, err := cw.WriteString(string("subject")); err != nil {
2077		return err
2078	}
2079
2080	if len(t.Subject) > 1000000 {
2081		return xerrors.Errorf("Value in field t.Subject was too long")
2082	}
2083
2084	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
2085		return err
2086	}
2087	if _, err := cw.WriteString(string(t.Subject)); err != nil {
2088		return err
2089	}
2090
2091	// t.CreatedAt (string) (string)
2092	if len("createdAt") > 1000000 {
2093		return xerrors.Errorf("Value in field \"createdAt\" was too long")
2094	}
2095
2096	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
2097		return err
2098	}
2099	if _, err := cw.WriteString(string("createdAt")); err != nil {
2100		return err
2101	}
2102
2103	if len(t.CreatedAt) > 1000000 {
2104		return xerrors.Errorf("Value in field t.CreatedAt was too long")
2105	}
2106
2107	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
2108		return err
2109	}
2110	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
2111		return err
2112	}
2113	return nil
2114}
2115
2116func (t *GraphFollow) UnmarshalCBOR(r io.Reader) (err error) {
2117	*t = GraphFollow{}
2118
2119	cr := cbg.NewCborReader(r)
2120
2121	maj, extra, err := cr.ReadHeader()
2122	if err != nil {
2123		return err
2124	}
2125	defer func() {
2126		if err == io.EOF {
2127			err = io.ErrUnexpectedEOF
2128		}
2129	}()
2130
2131	if maj != cbg.MajMap {
2132		return fmt.Errorf("cbor input should be of type map")
2133	}
2134
2135	if extra > cbg.MaxLength {
2136		return fmt.Errorf("GraphFollow: map struct too large (%d)", extra)
2137	}
2138
2139	n := extra
2140
2141	nameBuf := make([]byte, 9)
2142	for i := uint64(0); i < n; i++ {
2143		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2144		if err != nil {
2145			return err
2146		}
2147
2148		if !ok {
2149			// Field doesn't exist on this type, so ignore it
2150			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2151				return err
2152			}
2153			continue
2154		}
2155
2156		switch string(nameBuf[:nameLen]) {
2157		// t.LexiconTypeID (string) (string)
2158		case "$type":
2159
2160			{
2161				sval, err := cbg.ReadStringWithMax(cr, 1000000)
2162				if err != nil {
2163					return err
2164				}
2165
2166				t.LexiconTypeID = string(sval)
2167			}
2168			// t.Subject (string) (string)
2169		case "subject":
2170
2171			{
2172				sval, err := cbg.ReadStringWithMax(cr, 1000000)
2173				if err != nil {
2174					return err
2175				}
2176
2177				t.Subject = string(sval)
2178			}
2179			// t.CreatedAt (string) (string)
2180		case "createdAt":
2181
2182			{
2183				sval, err := cbg.ReadStringWithMax(cr, 1000000)
2184				if err != nil {
2185					return err
2186				}
2187
2188				t.CreatedAt = string(sval)
2189			}
2190
2191		default:
2192			// Field doesn't exist on this type, so ignore it
2193			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2194				return err
2195			}
2196		}
2197	}
2198
2199	return nil
2200}
2201func (t *Knot) MarshalCBOR(w io.Writer) error {
2202	if t == nil {
2203		_, err := w.Write(cbg.CborNull)
2204		return err
2205	}
2206
2207	cw := cbg.NewCborWriter(w)
2208
2209	if _, err := cw.Write([]byte{162}); err != nil {
2210		return err
2211	}
2212
2213	// t.LexiconTypeID (string) (string)
2214	if len("$type") > 1000000 {
2215		return xerrors.Errorf("Value in field \"$type\" was too long")
2216	}
2217
2218	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
2219		return err
2220	}
2221	if _, err := cw.WriteString(string("$type")); err != nil {
2222		return err
2223	}
2224
2225	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.knot"))); err != nil {
2226		return err
2227	}
2228	if _, err := cw.WriteString(string("sh.tangled.knot")); err != nil {
2229		return err
2230	}
2231
2232	// t.CreatedAt (string) (string)
2233	if len("createdAt") > 1000000 {
2234		return xerrors.Errorf("Value in field \"createdAt\" was too long")
2235	}
2236
2237	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
2238		return err
2239	}
2240	if _, err := cw.WriteString(string("createdAt")); err != nil {
2241		return err
2242	}
2243
2244	if len(t.CreatedAt) > 1000000 {
2245		return xerrors.Errorf("Value in field t.CreatedAt was too long")
2246	}
2247
2248	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
2249		return err
2250	}
2251	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
2252		return err
2253	}
2254	return nil
2255}
2256
2257func (t *Knot) UnmarshalCBOR(r io.Reader) (err error) {
2258	*t = Knot{}
2259
2260	cr := cbg.NewCborReader(r)
2261
2262	maj, extra, err := cr.ReadHeader()
2263	if err != nil {
2264		return err
2265	}
2266	defer func() {
2267		if err == io.EOF {
2268			err = io.ErrUnexpectedEOF
2269		}
2270	}()
2271
2272	if maj != cbg.MajMap {
2273		return fmt.Errorf("cbor input should be of type map")
2274	}
2275
2276	if extra > cbg.MaxLength {
2277		return fmt.Errorf("Knot: map struct too large (%d)", extra)
2278	}
2279
2280	n := extra
2281
2282	nameBuf := make([]byte, 9)
2283	for i := uint64(0); i < n; i++ {
2284		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2285		if err != nil {
2286			return err
2287		}
2288
2289		if !ok {
2290			// Field doesn't exist on this type, so ignore it
2291			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2292				return err
2293			}
2294			continue
2295		}
2296
2297		switch string(nameBuf[:nameLen]) {
2298		// t.LexiconTypeID (string) (string)
2299		case "$type":
2300
2301			{
2302				sval, err := cbg.ReadStringWithMax(cr, 1000000)
2303				if err != nil {
2304					return err
2305				}
2306
2307				t.LexiconTypeID = string(sval)
2308			}
2309			// t.CreatedAt (string) (string)
2310		case "createdAt":
2311
2312			{
2313				sval, err := cbg.ReadStringWithMax(cr, 1000000)
2314				if err != nil {
2315					return err
2316				}
2317
2318				t.CreatedAt = string(sval)
2319			}
2320
2321		default:
2322			// Field doesn't exist on this type, so ignore it
2323			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2324				return err
2325			}
2326		}
2327	}
2328
2329	return nil
2330}
2331func (t *KnotMember) MarshalCBOR(w io.Writer) error {
2332	if t == nil {
2333		_, err := w.Write(cbg.CborNull)
2334		return err
2335	}
2336
2337	cw := cbg.NewCborWriter(w)
2338
2339	if _, err := cw.Write([]byte{164}); err != nil {
2340		return err
2341	}
2342
2343	// t.LexiconTypeID (string) (string)
2344	if len("$type") > 1000000 {
2345		return xerrors.Errorf("Value in field \"$type\" was too long")
2346	}
2347
2348	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
2349		return err
2350	}
2351	if _, err := cw.WriteString(string("$type")); err != nil {
2352		return err
2353	}
2354
2355	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.knot.member"))); err != nil {
2356		return err
2357	}
2358	if _, err := cw.WriteString(string("sh.tangled.knot.member")); err != nil {
2359		return err
2360	}
2361
2362	// t.Domain (string) (string)
2363	if len("domain") > 1000000 {
2364		return xerrors.Errorf("Value in field \"domain\" was too long")
2365	}
2366
2367	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("domain"))); err != nil {
2368		return err
2369	}
2370	if _, err := cw.WriteString(string("domain")); err != nil {
2371		return err
2372	}
2373
2374	if len(t.Domain) > 1000000 {
2375		return xerrors.Errorf("Value in field t.Domain was too long")
2376	}
2377
2378	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Domain))); err != nil {
2379		return err
2380	}
2381	if _, err := cw.WriteString(string(t.Domain)); err != nil {
2382		return err
2383	}
2384
2385	// t.Subject (string) (string)
2386	if len("subject") > 1000000 {
2387		return xerrors.Errorf("Value in field \"subject\" was too long")
2388	}
2389
2390	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
2391		return err
2392	}
2393	if _, err := cw.WriteString(string("subject")); err != nil {
2394		return err
2395	}
2396
2397	if len(t.Subject) > 1000000 {
2398		return xerrors.Errorf("Value in field t.Subject was too long")
2399	}
2400
2401	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
2402		return err
2403	}
2404	if _, err := cw.WriteString(string(t.Subject)); err != nil {
2405		return err
2406	}
2407
2408	// t.CreatedAt (string) (string)
2409	if len("createdAt") > 1000000 {
2410		return xerrors.Errorf("Value in field \"createdAt\" was too long")
2411	}
2412
2413	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
2414		return err
2415	}
2416	if _, err := cw.WriteString(string("createdAt")); err != nil {
2417		return err
2418	}
2419
2420	if len(t.CreatedAt) > 1000000 {
2421		return xerrors.Errorf("Value in field t.CreatedAt was too long")
2422	}
2423
2424	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
2425		return err
2426	}
2427	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
2428		return err
2429	}
2430	return nil
2431}
2432
2433func (t *KnotMember) UnmarshalCBOR(r io.Reader) (err error) {
2434	*t = KnotMember{}
2435
2436	cr := cbg.NewCborReader(r)
2437
2438	maj, extra, err := cr.ReadHeader()
2439	if err != nil {
2440		return err
2441	}
2442	defer func() {
2443		if err == io.EOF {
2444			err = io.ErrUnexpectedEOF
2445		}
2446	}()
2447
2448	if maj != cbg.MajMap {
2449		return fmt.Errorf("cbor input should be of type map")
2450	}
2451
2452	if extra > cbg.MaxLength {
2453		return fmt.Errorf("KnotMember: map struct too large (%d)", extra)
2454	}
2455
2456	n := extra
2457
2458	nameBuf := make([]byte, 9)
2459	for i := uint64(0); i < n; i++ {
2460		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2461		if err != nil {
2462			return err
2463		}
2464
2465		if !ok {
2466			// Field doesn't exist on this type, so ignore it
2467			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2468				return err
2469			}
2470			continue
2471		}
2472
2473		switch string(nameBuf[:nameLen]) {
2474		// t.LexiconTypeID (string) (string)
2475		case "$type":
2476
2477			{
2478				sval, err := cbg.ReadStringWithMax(cr, 1000000)
2479				if err != nil {
2480					return err
2481				}
2482
2483				t.LexiconTypeID = string(sval)
2484			}
2485			// t.Domain (string) (string)
2486		case "domain":
2487
2488			{
2489				sval, err := cbg.ReadStringWithMax(cr, 1000000)
2490				if err != nil {
2491					return err
2492				}
2493
2494				t.Domain = string(sval)
2495			}
2496			// t.Subject (string) (string)
2497		case "subject":
2498
2499			{
2500				sval, err := cbg.ReadStringWithMax(cr, 1000000)
2501				if err != nil {
2502					return err
2503				}
2504
2505				t.Subject = string(sval)
2506			}
2507			// t.CreatedAt (string) (string)
2508		case "createdAt":
2509
2510			{
2511				sval, err := cbg.ReadStringWithMax(cr, 1000000)
2512				if err != nil {
2513					return err
2514				}
2515
2516				t.CreatedAt = string(sval)
2517			}
2518
2519		default:
2520			// Field doesn't exist on this type, so ignore it
2521			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2522				return err
2523			}
2524		}
2525	}
2526
2527	return nil
2528}
2529func (t *LabelDefinition) MarshalCBOR(w io.Writer) error {
2530	if t == nil {
2531		_, err := w.Write(cbg.CborNull)
2532		return err
2533	}
2534
2535	cw := cbg.NewCborWriter(w)
2536	fieldCount := 7
2537
2538	if t.Color == nil {
2539		fieldCount--
2540	}
2541
2542	if t.Multiple == nil {
2543		fieldCount--
2544	}
2545
2546	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
2547		return err
2548	}
2549
2550	// t.Name (string) (string)
2551	if len("name") > 1000000 {
2552		return xerrors.Errorf("Value in field \"name\" was too long")
2553	}
2554
2555	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
2556		return err
2557	}
2558	if _, err := cw.WriteString(string("name")); err != nil {
2559		return err
2560	}
2561
2562	if len(t.Name) > 1000000 {
2563		return xerrors.Errorf("Value in field t.Name was too long")
2564	}
2565
2566	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
2567		return err
2568	}
2569	if _, err := cw.WriteString(string(t.Name)); err != nil {
2570		return err
2571	}
2572
2573	// t.LexiconTypeID (string) (string)
2574	if len("$type") > 1000000 {
2575		return xerrors.Errorf("Value in field \"$type\" was too long")
2576	}
2577
2578	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
2579		return err
2580	}
2581	if _, err := cw.WriteString(string("$type")); err != nil {
2582		return err
2583	}
2584
2585	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.label.definition"))); err != nil {
2586		return err
2587	}
2588	if _, err := cw.WriteString(string("sh.tangled.label.definition")); err != nil {
2589		return err
2590	}
2591
2592	// t.Color (string) (string)
2593	if t.Color != nil {
2594
2595		if len("color") > 1000000 {
2596			return xerrors.Errorf("Value in field \"color\" was too long")
2597		}
2598
2599		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("color"))); err != nil {
2600			return err
2601		}
2602		if _, err := cw.WriteString(string("color")); err != nil {
2603			return err
2604		}
2605
2606		if t.Color == nil {
2607			if _, err := cw.Write(cbg.CborNull); err != nil {
2608				return err
2609			}
2610		} else {
2611			if len(*t.Color) > 1000000 {
2612				return xerrors.Errorf("Value in field t.Color was too long")
2613			}
2614
2615			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Color))); err != nil {
2616				return err
2617			}
2618			if _, err := cw.WriteString(string(*t.Color)); err != nil {
2619				return err
2620			}
2621		}
2622	}
2623
2624	// t.Scope ([]string) (slice)
2625	if len("scope") > 1000000 {
2626		return xerrors.Errorf("Value in field \"scope\" was too long")
2627	}
2628
2629	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("scope"))); err != nil {
2630		return err
2631	}
2632	if _, err := cw.WriteString(string("scope")); err != nil {
2633		return err
2634	}
2635
2636	if len(t.Scope) > 8192 {
2637		return xerrors.Errorf("Slice value in field t.Scope was too long")
2638	}
2639
2640	if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Scope))); err != nil {
2641		return err
2642	}
2643	for _, v := range t.Scope {
2644		if len(v) > 1000000 {
2645			return xerrors.Errorf("Value in field v was too long")
2646		}
2647
2648		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
2649			return err
2650		}
2651		if _, err := cw.WriteString(string(v)); err != nil {
2652			return err
2653		}
2654
2655	}
2656
2657	// t.Multiple (bool) (bool)
2658	if t.Multiple != nil {
2659
2660		if len("multiple") > 1000000 {
2661			return xerrors.Errorf("Value in field \"multiple\" was too long")
2662		}
2663
2664		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("multiple"))); err != nil {
2665			return err
2666		}
2667		if _, err := cw.WriteString(string("multiple")); err != nil {
2668			return err
2669		}
2670
2671		if t.Multiple == nil {
2672			if _, err := cw.Write(cbg.CborNull); err != nil {
2673				return err
2674			}
2675		} else {
2676			if err := cbg.WriteBool(w, *t.Multiple); err != nil {
2677				return err
2678			}
2679		}
2680	}
2681
2682	// t.CreatedAt (string) (string)
2683	if len("createdAt") > 1000000 {
2684		return xerrors.Errorf("Value in field \"createdAt\" was too long")
2685	}
2686
2687	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
2688		return err
2689	}
2690	if _, err := cw.WriteString(string("createdAt")); err != nil {
2691		return err
2692	}
2693
2694	if len(t.CreatedAt) > 1000000 {
2695		return xerrors.Errorf("Value in field t.CreatedAt was too long")
2696	}
2697
2698	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
2699		return err
2700	}
2701	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
2702		return err
2703	}
2704
2705	// t.ValueType (tangled.LabelDefinition_ValueType) (struct)
2706	if len("valueType") > 1000000 {
2707		return xerrors.Errorf("Value in field \"valueType\" was too long")
2708	}
2709
2710	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("valueType"))); err != nil {
2711		return err
2712	}
2713	if _, err := cw.WriteString(string("valueType")); err != nil {
2714		return err
2715	}
2716
2717	if err := t.ValueType.MarshalCBOR(cw); err != nil {
2718		return err
2719	}
2720	return nil
2721}
2722
2723func (t *LabelDefinition) UnmarshalCBOR(r io.Reader) (err error) {
2724	*t = LabelDefinition{}
2725
2726	cr := cbg.NewCborReader(r)
2727
2728	maj, extra, err := cr.ReadHeader()
2729	if err != nil {
2730		return err
2731	}
2732	defer func() {
2733		if err == io.EOF {
2734			err = io.ErrUnexpectedEOF
2735		}
2736	}()
2737
2738	if maj != cbg.MajMap {
2739		return fmt.Errorf("cbor input should be of type map")
2740	}
2741
2742	if extra > cbg.MaxLength {
2743		return fmt.Errorf("LabelDefinition: map struct too large (%d)", extra)
2744	}
2745
2746	n := extra
2747
2748	nameBuf := make([]byte, 9)
2749	for i := uint64(0); i < n; i++ {
2750		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
2751		if err != nil {
2752			return err
2753		}
2754
2755		if !ok {
2756			// Field doesn't exist on this type, so ignore it
2757			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
2758				return err
2759			}
2760			continue
2761		}
2762
2763		switch string(nameBuf[:nameLen]) {
2764		// t.Name (string) (string)
2765		case "name":
2766
2767			{
2768				sval, err := cbg.ReadStringWithMax(cr, 1000000)
2769				if err != nil {
2770					return err
2771				}
2772
2773				t.Name = string(sval)
2774			}
2775			// t.LexiconTypeID (string) (string)
2776		case "$type":
2777
2778			{
2779				sval, err := cbg.ReadStringWithMax(cr, 1000000)
2780				if err != nil {
2781					return err
2782				}
2783
2784				t.LexiconTypeID = string(sval)
2785			}
2786			// t.Color (string) (string)
2787		case "color":
2788
2789			{
2790				b, err := cr.ReadByte()
2791				if err != nil {
2792					return err
2793				}
2794				if b != cbg.CborNull[0] {
2795					if err := cr.UnreadByte(); err != nil {
2796						return err
2797					}
2798
2799					sval, err := cbg.ReadStringWithMax(cr, 1000000)
2800					if err != nil {
2801						return err
2802					}
2803
2804					t.Color = (*string)(&sval)
2805				}
2806			}
2807			// t.Scope ([]string) (slice)
2808		case "scope":
2809
2810			maj, extra, err = cr.ReadHeader()
2811			if err != nil {
2812				return err
2813			}
2814
2815			if extra > 8192 {
2816				return fmt.Errorf("t.Scope: array too large (%d)", extra)
2817			}
2818
2819			if maj != cbg.MajArray {
2820				return fmt.Errorf("expected cbor array")
2821			}
2822
2823			if extra > 0 {
2824				t.Scope = make([]string, extra)
2825			}
2826
2827			for i := 0; i < int(extra); i++ {
2828				{
2829					var maj byte
2830					var extra uint64
2831					var err error
2832					_ = maj
2833					_ = extra
2834					_ = err
2835
2836					{
2837						sval, err := cbg.ReadStringWithMax(cr, 1000000)
2838						if err != nil {
2839							return err
2840						}
2841
2842						t.Scope[i] = string(sval)
2843					}
2844
2845				}
2846			}
2847			// t.Multiple (bool) (bool)
2848		case "multiple":
2849
2850			{
2851				b, err := cr.ReadByte()
2852				if err != nil {
2853					return err
2854				}
2855				if b != cbg.CborNull[0] {
2856					if err := cr.UnreadByte(); err != nil {
2857						return err
2858					}
2859
2860					maj, extra, err = cr.ReadHeader()
2861					if err != nil {
2862						return err
2863					}
2864					if maj != cbg.MajOther {
2865						return fmt.Errorf("booleans must be major type 7")
2866					}
2867
2868					var val bool
2869					switch extra {
2870					case 20:
2871						val = false
2872					case 21:
2873						val = true
2874					default:
2875						return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
2876					}
2877					t.Multiple = &val
2878				}
2879			}
2880			// t.CreatedAt (string) (string)
2881		case "createdAt":
2882
2883			{
2884				sval, err := cbg.ReadStringWithMax(cr, 1000000)
2885				if err != nil {
2886					return err
2887				}
2888
2889				t.CreatedAt = string(sval)
2890			}
2891			// t.ValueType (tangled.LabelDefinition_ValueType) (struct)
2892		case "valueType":
2893
2894			{
2895
2896				b, err := cr.ReadByte()
2897				if err != nil {
2898					return err
2899				}
2900				if b != cbg.CborNull[0] {
2901					if err := cr.UnreadByte(); err != nil {
2902						return err
2903					}
2904					t.ValueType = new(LabelDefinition_ValueType)
2905					if err := t.ValueType.UnmarshalCBOR(cr); err != nil {
2906						return xerrors.Errorf("unmarshaling t.ValueType pointer: %w", err)
2907					}
2908				}
2909
2910			}
2911
2912		default:
2913			// Field doesn't exist on this type, so ignore it
2914			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
2915				return err
2916			}
2917		}
2918	}
2919
2920	return nil
2921}
2922func (t *LabelDefinition_ValueType) MarshalCBOR(w io.Writer) error {
2923	if t == nil {
2924		_, err := w.Write(cbg.CborNull)
2925		return err
2926	}
2927
2928	cw := cbg.NewCborWriter(w)
2929	fieldCount := 3
2930
2931	if t.Enum == nil {
2932		fieldCount--
2933	}
2934
2935	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
2936		return err
2937	}
2938
2939	// t.Enum ([]string) (slice)
2940	if t.Enum != nil {
2941
2942		if len("enum") > 1000000 {
2943			return xerrors.Errorf("Value in field \"enum\" was too long")
2944		}
2945
2946		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("enum"))); err != nil {
2947			return err
2948		}
2949		if _, err := cw.WriteString(string("enum")); err != nil {
2950			return err
2951		}
2952
2953		if len(t.Enum) > 8192 {
2954			return xerrors.Errorf("Slice value in field t.Enum was too long")
2955		}
2956
2957		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Enum))); err != nil {
2958			return err
2959		}
2960		for _, v := range t.Enum {
2961			if len(v) > 1000000 {
2962				return xerrors.Errorf("Value in field v was too long")
2963			}
2964
2965			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
2966				return err
2967			}
2968			if _, err := cw.WriteString(string(v)); err != nil {
2969				return err
2970			}
2971
2972		}
2973	}
2974
2975	// t.Type (string) (string)
2976	if len("type") > 1000000 {
2977		return xerrors.Errorf("Value in field \"type\" was too long")
2978	}
2979
2980	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("type"))); err != nil {
2981		return err
2982	}
2983	if _, err := cw.WriteString(string("type")); err != nil {
2984		return err
2985	}
2986
2987	if len(t.Type) > 1000000 {
2988		return xerrors.Errorf("Value in field t.Type was too long")
2989	}
2990
2991	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Type))); err != nil {
2992		return err
2993	}
2994	if _, err := cw.WriteString(string(t.Type)); err != nil {
2995		return err
2996	}
2997
2998	// t.Format (string) (string)
2999	if len("format") > 1000000 {
3000		return xerrors.Errorf("Value in field \"format\" was too long")
3001	}
3002
3003	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("format"))); err != nil {
3004		return err
3005	}
3006	if _, err := cw.WriteString(string("format")); err != nil {
3007		return err
3008	}
3009
3010	if len(t.Format) > 1000000 {
3011		return xerrors.Errorf("Value in field t.Format was too long")
3012	}
3013
3014	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Format))); err != nil {
3015		return err
3016	}
3017	if _, err := cw.WriteString(string(t.Format)); err != nil {
3018		return err
3019	}
3020	return nil
3021}
3022
3023func (t *LabelDefinition_ValueType) UnmarshalCBOR(r io.Reader) (err error) {
3024	*t = LabelDefinition_ValueType{}
3025
3026	cr := cbg.NewCborReader(r)
3027
3028	maj, extra, err := cr.ReadHeader()
3029	if err != nil {
3030		return err
3031	}
3032	defer func() {
3033		if err == io.EOF {
3034			err = io.ErrUnexpectedEOF
3035		}
3036	}()
3037
3038	if maj != cbg.MajMap {
3039		return fmt.Errorf("cbor input should be of type map")
3040	}
3041
3042	if extra > cbg.MaxLength {
3043		return fmt.Errorf("LabelDefinition_ValueType: map struct too large (%d)", extra)
3044	}
3045
3046	n := extra
3047
3048	nameBuf := make([]byte, 6)
3049	for i := uint64(0); i < n; i++ {
3050		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3051		if err != nil {
3052			return err
3053		}
3054
3055		if !ok {
3056			// Field doesn't exist on this type, so ignore it
3057			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3058				return err
3059			}
3060			continue
3061		}
3062
3063		switch string(nameBuf[:nameLen]) {
3064		// t.Enum ([]string) (slice)
3065		case "enum":
3066
3067			maj, extra, err = cr.ReadHeader()
3068			if err != nil {
3069				return err
3070			}
3071
3072			if extra > 8192 {
3073				return fmt.Errorf("t.Enum: array too large (%d)", extra)
3074			}
3075
3076			if maj != cbg.MajArray {
3077				return fmt.Errorf("expected cbor array")
3078			}
3079
3080			if extra > 0 {
3081				t.Enum = make([]string, extra)
3082			}
3083
3084			for i := 0; i < int(extra); i++ {
3085				{
3086					var maj byte
3087					var extra uint64
3088					var err error
3089					_ = maj
3090					_ = extra
3091					_ = err
3092
3093					{
3094						sval, err := cbg.ReadStringWithMax(cr, 1000000)
3095						if err != nil {
3096							return err
3097						}
3098
3099						t.Enum[i] = string(sval)
3100					}
3101
3102				}
3103			}
3104			// t.Type (string) (string)
3105		case "type":
3106
3107			{
3108				sval, err := cbg.ReadStringWithMax(cr, 1000000)
3109				if err != nil {
3110					return err
3111				}
3112
3113				t.Type = string(sval)
3114			}
3115			// t.Format (string) (string)
3116		case "format":
3117
3118			{
3119				sval, err := cbg.ReadStringWithMax(cr, 1000000)
3120				if err != nil {
3121					return err
3122				}
3123
3124				t.Format = string(sval)
3125			}
3126
3127		default:
3128			// Field doesn't exist on this type, so ignore it
3129			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3130				return err
3131			}
3132		}
3133	}
3134
3135	return nil
3136}
3137func (t *LabelOp) MarshalCBOR(w io.Writer) error {
3138	if t == nil {
3139		_, err := w.Write(cbg.CborNull)
3140		return err
3141	}
3142
3143	cw := cbg.NewCborWriter(w)
3144
3145	if _, err := cw.Write([]byte{165}); err != nil {
3146		return err
3147	}
3148
3149	// t.Add ([]*tangled.LabelOp_Operand) (slice)
3150	if len("add") > 1000000 {
3151		return xerrors.Errorf("Value in field \"add\" was too long")
3152	}
3153
3154	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("add"))); err != nil {
3155		return err
3156	}
3157	if _, err := cw.WriteString(string("add")); err != nil {
3158		return err
3159	}
3160
3161	if len(t.Add) > 8192 {
3162		return xerrors.Errorf("Slice value in field t.Add was too long")
3163	}
3164
3165	if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Add))); err != nil {
3166		return err
3167	}
3168	for _, v := range t.Add {
3169		if err := v.MarshalCBOR(cw); err != nil {
3170			return err
3171		}
3172
3173	}
3174
3175	// t.LexiconTypeID (string) (string)
3176	if len("$type") > 1000000 {
3177		return xerrors.Errorf("Value in field \"$type\" was too long")
3178	}
3179
3180	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
3181		return err
3182	}
3183	if _, err := cw.WriteString(string("$type")); err != nil {
3184		return err
3185	}
3186
3187	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.label.op"))); err != nil {
3188		return err
3189	}
3190	if _, err := cw.WriteString(string("sh.tangled.label.op")); err != nil {
3191		return err
3192	}
3193
3194	// t.Delete ([]*tangled.LabelOp_Operand) (slice)
3195	if len("delete") > 1000000 {
3196		return xerrors.Errorf("Value in field \"delete\" was too long")
3197	}
3198
3199	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("delete"))); err != nil {
3200		return err
3201	}
3202	if _, err := cw.WriteString(string("delete")); err != nil {
3203		return err
3204	}
3205
3206	if len(t.Delete) > 8192 {
3207		return xerrors.Errorf("Slice value in field t.Delete was too long")
3208	}
3209
3210	if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Delete))); err != nil {
3211		return err
3212	}
3213	for _, v := range t.Delete {
3214		if err := v.MarshalCBOR(cw); err != nil {
3215			return err
3216		}
3217
3218	}
3219
3220	// t.Subject (string) (string)
3221	if len("subject") > 1000000 {
3222		return xerrors.Errorf("Value in field \"subject\" was too long")
3223	}
3224
3225	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
3226		return err
3227	}
3228	if _, err := cw.WriteString(string("subject")); err != nil {
3229		return err
3230	}
3231
3232	if len(t.Subject) > 1000000 {
3233		return xerrors.Errorf("Value in field t.Subject was too long")
3234	}
3235
3236	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
3237		return err
3238	}
3239	if _, err := cw.WriteString(string(t.Subject)); err != nil {
3240		return err
3241	}
3242
3243	// t.PerformedAt (string) (string)
3244	if len("performedAt") > 1000000 {
3245		return xerrors.Errorf("Value in field \"performedAt\" was too long")
3246	}
3247
3248	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("performedAt"))); err != nil {
3249		return err
3250	}
3251	if _, err := cw.WriteString(string("performedAt")); err != nil {
3252		return err
3253	}
3254
3255	if len(t.PerformedAt) > 1000000 {
3256		return xerrors.Errorf("Value in field t.PerformedAt was too long")
3257	}
3258
3259	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.PerformedAt))); err != nil {
3260		return err
3261	}
3262	if _, err := cw.WriteString(string(t.PerformedAt)); err != nil {
3263		return err
3264	}
3265	return nil
3266}
3267
3268func (t *LabelOp) UnmarshalCBOR(r io.Reader) (err error) {
3269	*t = LabelOp{}
3270
3271	cr := cbg.NewCborReader(r)
3272
3273	maj, extra, err := cr.ReadHeader()
3274	if err != nil {
3275		return err
3276	}
3277	defer func() {
3278		if err == io.EOF {
3279			err = io.ErrUnexpectedEOF
3280		}
3281	}()
3282
3283	if maj != cbg.MajMap {
3284		return fmt.Errorf("cbor input should be of type map")
3285	}
3286
3287	if extra > cbg.MaxLength {
3288		return fmt.Errorf("LabelOp: map struct too large (%d)", extra)
3289	}
3290
3291	n := extra
3292
3293	nameBuf := make([]byte, 11)
3294	for i := uint64(0); i < n; i++ {
3295		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3296		if err != nil {
3297			return err
3298		}
3299
3300		if !ok {
3301			// Field doesn't exist on this type, so ignore it
3302			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3303				return err
3304			}
3305			continue
3306		}
3307
3308		switch string(nameBuf[:nameLen]) {
3309		// t.Add ([]*tangled.LabelOp_Operand) (slice)
3310		case "add":
3311
3312			maj, extra, err = cr.ReadHeader()
3313			if err != nil {
3314				return err
3315			}
3316
3317			if extra > 8192 {
3318				return fmt.Errorf("t.Add: array too large (%d)", extra)
3319			}
3320
3321			if maj != cbg.MajArray {
3322				return fmt.Errorf("expected cbor array")
3323			}
3324
3325			if extra > 0 {
3326				t.Add = make([]*LabelOp_Operand, extra)
3327			}
3328
3329			for i := 0; i < int(extra); i++ {
3330				{
3331					var maj byte
3332					var extra uint64
3333					var err error
3334					_ = maj
3335					_ = extra
3336					_ = err
3337
3338					{
3339
3340						b, err := cr.ReadByte()
3341						if err != nil {
3342							return err
3343						}
3344						if b != cbg.CborNull[0] {
3345							if err := cr.UnreadByte(); err != nil {
3346								return err
3347							}
3348							t.Add[i] = new(LabelOp_Operand)
3349							if err := t.Add[i].UnmarshalCBOR(cr); err != nil {
3350								return xerrors.Errorf("unmarshaling t.Add[i] pointer: %w", err)
3351							}
3352						}
3353
3354					}
3355
3356				}
3357			}
3358			// t.LexiconTypeID (string) (string)
3359		case "$type":
3360
3361			{
3362				sval, err := cbg.ReadStringWithMax(cr, 1000000)
3363				if err != nil {
3364					return err
3365				}
3366
3367				t.LexiconTypeID = string(sval)
3368			}
3369			// t.Delete ([]*tangled.LabelOp_Operand) (slice)
3370		case "delete":
3371
3372			maj, extra, err = cr.ReadHeader()
3373			if err != nil {
3374				return err
3375			}
3376
3377			if extra > 8192 {
3378				return fmt.Errorf("t.Delete: array too large (%d)", extra)
3379			}
3380
3381			if maj != cbg.MajArray {
3382				return fmt.Errorf("expected cbor array")
3383			}
3384
3385			if extra > 0 {
3386				t.Delete = make([]*LabelOp_Operand, extra)
3387			}
3388
3389			for i := 0; i < int(extra); i++ {
3390				{
3391					var maj byte
3392					var extra uint64
3393					var err error
3394					_ = maj
3395					_ = extra
3396					_ = err
3397
3398					{
3399
3400						b, err := cr.ReadByte()
3401						if err != nil {
3402							return err
3403						}
3404						if b != cbg.CborNull[0] {
3405							if err := cr.UnreadByte(); err != nil {
3406								return err
3407							}
3408							t.Delete[i] = new(LabelOp_Operand)
3409							if err := t.Delete[i].UnmarshalCBOR(cr); err != nil {
3410								return xerrors.Errorf("unmarshaling t.Delete[i] pointer: %w", err)
3411							}
3412						}
3413
3414					}
3415
3416				}
3417			}
3418			// t.Subject (string) (string)
3419		case "subject":
3420
3421			{
3422				sval, err := cbg.ReadStringWithMax(cr, 1000000)
3423				if err != nil {
3424					return err
3425				}
3426
3427				t.Subject = string(sval)
3428			}
3429			// t.PerformedAt (string) (string)
3430		case "performedAt":
3431
3432			{
3433				sval, err := cbg.ReadStringWithMax(cr, 1000000)
3434				if err != nil {
3435					return err
3436				}
3437
3438				t.PerformedAt = string(sval)
3439			}
3440
3441		default:
3442			// Field doesn't exist on this type, so ignore it
3443			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3444				return err
3445			}
3446		}
3447	}
3448
3449	return nil
3450}
3451func (t *LabelOp_Operand) MarshalCBOR(w io.Writer) error {
3452	if t == nil {
3453		_, err := w.Write(cbg.CborNull)
3454		return err
3455	}
3456
3457	cw := cbg.NewCborWriter(w)
3458
3459	if _, err := cw.Write([]byte{162}); err != nil {
3460		return err
3461	}
3462
3463	// t.Key (string) (string)
3464	if len("key") > 1000000 {
3465		return xerrors.Errorf("Value in field \"key\" was too long")
3466	}
3467
3468	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
3469		return err
3470	}
3471	if _, err := cw.WriteString(string("key")); err != nil {
3472		return err
3473	}
3474
3475	if len(t.Key) > 1000000 {
3476		return xerrors.Errorf("Value in field t.Key was too long")
3477	}
3478
3479	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
3480		return err
3481	}
3482	if _, err := cw.WriteString(string(t.Key)); err != nil {
3483		return err
3484	}
3485
3486	// t.Value (string) (string)
3487	if len("value") > 1000000 {
3488		return xerrors.Errorf("Value in field \"value\" was too long")
3489	}
3490
3491	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil {
3492		return err
3493	}
3494	if _, err := cw.WriteString(string("value")); err != nil {
3495		return err
3496	}
3497
3498	if len(t.Value) > 1000000 {
3499		return xerrors.Errorf("Value in field t.Value was too long")
3500	}
3501
3502	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil {
3503		return err
3504	}
3505	if _, err := cw.WriteString(string(t.Value)); err != nil {
3506		return err
3507	}
3508	return nil
3509}
3510
3511func (t *LabelOp_Operand) UnmarshalCBOR(r io.Reader) (err error) {
3512	*t = LabelOp_Operand{}
3513
3514	cr := cbg.NewCborReader(r)
3515
3516	maj, extra, err := cr.ReadHeader()
3517	if err != nil {
3518		return err
3519	}
3520	defer func() {
3521		if err == io.EOF {
3522			err = io.ErrUnexpectedEOF
3523		}
3524	}()
3525
3526	if maj != cbg.MajMap {
3527		return fmt.Errorf("cbor input should be of type map")
3528	}
3529
3530	if extra > cbg.MaxLength {
3531		return fmt.Errorf("LabelOp_Operand: map struct too large (%d)", extra)
3532	}
3533
3534	n := extra
3535
3536	nameBuf := make([]byte, 5)
3537	for i := uint64(0); i < n; i++ {
3538		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3539		if err != nil {
3540			return err
3541		}
3542
3543		if !ok {
3544			// Field doesn't exist on this type, so ignore it
3545			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3546				return err
3547			}
3548			continue
3549		}
3550
3551		switch string(nameBuf[:nameLen]) {
3552		// t.Key (string) (string)
3553		case "key":
3554
3555			{
3556				sval, err := cbg.ReadStringWithMax(cr, 1000000)
3557				if err != nil {
3558					return err
3559				}
3560
3561				t.Key = string(sval)
3562			}
3563			// t.Value (string) (string)
3564		case "value":
3565
3566			{
3567				sval, err := cbg.ReadStringWithMax(cr, 1000000)
3568				if err != nil {
3569					return err
3570				}
3571
3572				t.Value = string(sval)
3573			}
3574
3575		default:
3576			// Field doesn't exist on this type, so ignore it
3577			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3578				return err
3579			}
3580		}
3581	}
3582
3583	return nil
3584}
3585func (t *Pipeline) MarshalCBOR(w io.Writer) error {
3586	if t == nil {
3587		_, err := w.Write(cbg.CborNull)
3588		return err
3589	}
3590
3591	cw := cbg.NewCborWriter(w)
3592
3593	if _, err := cw.Write([]byte{163}); err != nil {
3594		return err
3595	}
3596
3597	// t.LexiconTypeID (string) (string)
3598	if len("$type") > 1000000 {
3599		return xerrors.Errorf("Value in field \"$type\" was too long")
3600	}
3601
3602	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
3603		return err
3604	}
3605	if _, err := cw.WriteString(string("$type")); err != nil {
3606		return err
3607	}
3608
3609	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pipeline"))); err != nil {
3610		return err
3611	}
3612	if _, err := cw.WriteString(string("sh.tangled.pipeline")); err != nil {
3613		return err
3614	}
3615
3616	// t.Workflows ([]*tangled.Pipeline_Workflow) (slice)
3617	if len("workflows") > 1000000 {
3618		return xerrors.Errorf("Value in field \"workflows\" was too long")
3619	}
3620
3621	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflows"))); err != nil {
3622		return err
3623	}
3624	if _, err := cw.WriteString(string("workflows")); err != nil {
3625		return err
3626	}
3627
3628	if len(t.Workflows) > 8192 {
3629		return xerrors.Errorf("Slice value in field t.Workflows was too long")
3630	}
3631
3632	if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Workflows))); err != nil {
3633		return err
3634	}
3635	for _, v := range t.Workflows {
3636		if err := v.MarshalCBOR(cw); err != nil {
3637			return err
3638		}
3639
3640	}
3641
3642	// t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct)
3643	if len("triggerMetadata") > 1000000 {
3644		return xerrors.Errorf("Value in field \"triggerMetadata\" was too long")
3645	}
3646
3647	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("triggerMetadata"))); err != nil {
3648		return err
3649	}
3650	if _, err := cw.WriteString(string("triggerMetadata")); err != nil {
3651		return err
3652	}
3653
3654	if err := t.TriggerMetadata.MarshalCBOR(cw); err != nil {
3655		return err
3656	}
3657	return nil
3658}
3659
3660func (t *Pipeline) UnmarshalCBOR(r io.Reader) (err error) {
3661	*t = Pipeline{}
3662
3663	cr := cbg.NewCborReader(r)
3664
3665	maj, extra, err := cr.ReadHeader()
3666	if err != nil {
3667		return err
3668	}
3669	defer func() {
3670		if err == io.EOF {
3671			err = io.ErrUnexpectedEOF
3672		}
3673	}()
3674
3675	if maj != cbg.MajMap {
3676		return fmt.Errorf("cbor input should be of type map")
3677	}
3678
3679	if extra > cbg.MaxLength {
3680		return fmt.Errorf("Pipeline: map struct too large (%d)", extra)
3681	}
3682
3683	n := extra
3684
3685	nameBuf := make([]byte, 15)
3686	for i := uint64(0); i < n; i++ {
3687		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3688		if err != nil {
3689			return err
3690		}
3691
3692		if !ok {
3693			// Field doesn't exist on this type, so ignore it
3694			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3695				return err
3696			}
3697			continue
3698		}
3699
3700		switch string(nameBuf[:nameLen]) {
3701		// t.LexiconTypeID (string) (string)
3702		case "$type":
3703
3704			{
3705				sval, err := cbg.ReadStringWithMax(cr, 1000000)
3706				if err != nil {
3707					return err
3708				}
3709
3710				t.LexiconTypeID = string(sval)
3711			}
3712			// t.Workflows ([]*tangled.Pipeline_Workflow) (slice)
3713		case "workflows":
3714
3715			maj, extra, err = cr.ReadHeader()
3716			if err != nil {
3717				return err
3718			}
3719
3720			if extra > 8192 {
3721				return fmt.Errorf("t.Workflows: array too large (%d)", extra)
3722			}
3723
3724			if maj != cbg.MajArray {
3725				return fmt.Errorf("expected cbor array")
3726			}
3727
3728			if extra > 0 {
3729				t.Workflows = make([]*Pipeline_Workflow, extra)
3730			}
3731
3732			for i := 0; i < int(extra); i++ {
3733				{
3734					var maj byte
3735					var extra uint64
3736					var err error
3737					_ = maj
3738					_ = extra
3739					_ = err
3740
3741					{
3742
3743						b, err := cr.ReadByte()
3744						if err != nil {
3745							return err
3746						}
3747						if b != cbg.CborNull[0] {
3748							if err := cr.UnreadByte(); err != nil {
3749								return err
3750							}
3751							t.Workflows[i] = new(Pipeline_Workflow)
3752							if err := t.Workflows[i].UnmarshalCBOR(cr); err != nil {
3753								return xerrors.Errorf("unmarshaling t.Workflows[i] pointer: %w", err)
3754							}
3755						}
3756
3757					}
3758
3759				}
3760			}
3761			// t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct)
3762		case "triggerMetadata":
3763
3764			{
3765
3766				b, err := cr.ReadByte()
3767				if err != nil {
3768					return err
3769				}
3770				if b != cbg.CborNull[0] {
3771					if err := cr.UnreadByte(); err != nil {
3772						return err
3773					}
3774					t.TriggerMetadata = new(Pipeline_TriggerMetadata)
3775					if err := t.TriggerMetadata.UnmarshalCBOR(cr); err != nil {
3776						return xerrors.Errorf("unmarshaling t.TriggerMetadata pointer: %w", err)
3777					}
3778				}
3779
3780			}
3781
3782		default:
3783			// Field doesn't exist on this type, so ignore it
3784			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3785				return err
3786			}
3787		}
3788	}
3789
3790	return nil
3791}
3792func (t *Pipeline_CloneOpts) MarshalCBOR(w io.Writer) error {
3793	if t == nil {
3794		_, err := w.Write(cbg.CborNull)
3795		return err
3796	}
3797
3798	cw := cbg.NewCborWriter(w)
3799
3800	if _, err := cw.Write([]byte{163}); err != nil {
3801		return err
3802	}
3803
3804	// t.Skip (bool) (bool)
3805	if len("skip") > 1000000 {
3806		return xerrors.Errorf("Value in field \"skip\" was too long")
3807	}
3808
3809	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("skip"))); err != nil {
3810		return err
3811	}
3812	if _, err := cw.WriteString(string("skip")); err != nil {
3813		return err
3814	}
3815
3816	if err := cbg.WriteBool(w, t.Skip); err != nil {
3817		return err
3818	}
3819
3820	// t.Depth (int64) (int64)
3821	if len("depth") > 1000000 {
3822		return xerrors.Errorf("Value in field \"depth\" was too long")
3823	}
3824
3825	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("depth"))); err != nil {
3826		return err
3827	}
3828	if _, err := cw.WriteString(string("depth")); err != nil {
3829		return err
3830	}
3831
3832	if t.Depth >= 0 {
3833		if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Depth)); err != nil {
3834			return err
3835		}
3836	} else {
3837		if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Depth-1)); err != nil {
3838			return err
3839		}
3840	}
3841
3842	// t.Submodules (bool) (bool)
3843	if len("submodules") > 1000000 {
3844		return xerrors.Errorf("Value in field \"submodules\" was too long")
3845	}
3846
3847	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("submodules"))); err != nil {
3848		return err
3849	}
3850	if _, err := cw.WriteString(string("submodules")); err != nil {
3851		return err
3852	}
3853
3854	if err := cbg.WriteBool(w, t.Submodules); err != nil {
3855		return err
3856	}
3857	return nil
3858}
3859
3860func (t *Pipeline_CloneOpts) UnmarshalCBOR(r io.Reader) (err error) {
3861	*t = Pipeline_CloneOpts{}
3862
3863	cr := cbg.NewCborReader(r)
3864
3865	maj, extra, err := cr.ReadHeader()
3866	if err != nil {
3867		return err
3868	}
3869	defer func() {
3870		if err == io.EOF {
3871			err = io.ErrUnexpectedEOF
3872		}
3873	}()
3874
3875	if maj != cbg.MajMap {
3876		return fmt.Errorf("cbor input should be of type map")
3877	}
3878
3879	if extra > cbg.MaxLength {
3880		return fmt.Errorf("Pipeline_CloneOpts: map struct too large (%d)", extra)
3881	}
3882
3883	n := extra
3884
3885	nameBuf := make([]byte, 10)
3886	for i := uint64(0); i < n; i++ {
3887		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
3888		if err != nil {
3889			return err
3890		}
3891
3892		if !ok {
3893			// Field doesn't exist on this type, so ignore it
3894			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
3895				return err
3896			}
3897			continue
3898		}
3899
3900		switch string(nameBuf[:nameLen]) {
3901		// t.Skip (bool) (bool)
3902		case "skip":
3903
3904			maj, extra, err = cr.ReadHeader()
3905			if err != nil {
3906				return err
3907			}
3908			if maj != cbg.MajOther {
3909				return fmt.Errorf("booleans must be major type 7")
3910			}
3911			switch extra {
3912			case 20:
3913				t.Skip = false
3914			case 21:
3915				t.Skip = true
3916			default:
3917				return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
3918			}
3919			// t.Depth (int64) (int64)
3920		case "depth":
3921			{
3922				maj, extra, err := cr.ReadHeader()
3923				if err != nil {
3924					return err
3925				}
3926				var extraI int64
3927				switch maj {
3928				case cbg.MajUnsignedInt:
3929					extraI = int64(extra)
3930					if extraI < 0 {
3931						return fmt.Errorf("int64 positive overflow")
3932					}
3933				case cbg.MajNegativeInt:
3934					extraI = int64(extra)
3935					if extraI < 0 {
3936						return fmt.Errorf("int64 negative overflow")
3937					}
3938					extraI = -1 - extraI
3939				default:
3940					return fmt.Errorf("wrong type for int64 field: %d", maj)
3941				}
3942
3943				t.Depth = int64(extraI)
3944			}
3945			// t.Submodules (bool) (bool)
3946		case "submodules":
3947
3948			maj, extra, err = cr.ReadHeader()
3949			if err != nil {
3950				return err
3951			}
3952			if maj != cbg.MajOther {
3953				return fmt.Errorf("booleans must be major type 7")
3954			}
3955			switch extra {
3956			case 20:
3957				t.Submodules = false
3958			case 21:
3959				t.Submodules = true
3960			default:
3961				return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
3962			}
3963
3964		default:
3965			// Field doesn't exist on this type, so ignore it
3966			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
3967				return err
3968			}
3969		}
3970	}
3971
3972	return nil
3973}
3974func (t *Pipeline_ManualTriggerData) MarshalCBOR(w io.Writer) error {
3975	if t == nil {
3976		_, err := w.Write(cbg.CborNull)
3977		return err
3978	}
3979
3980	cw := cbg.NewCborWriter(w)
3981	fieldCount := 1
3982
3983	if t.Inputs == nil {
3984		fieldCount--
3985	}
3986
3987	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
3988		return err
3989	}
3990
3991	// t.Inputs ([]*tangled.Pipeline_Pair) (slice)
3992	if t.Inputs != nil {
3993
3994		if len("inputs") > 1000000 {
3995			return xerrors.Errorf("Value in field \"inputs\" was too long")
3996		}
3997
3998		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("inputs"))); err != nil {
3999			return err
4000		}
4001		if _, err := cw.WriteString(string("inputs")); err != nil {
4002			return err
4003		}
4004
4005		if len(t.Inputs) > 8192 {
4006			return xerrors.Errorf("Slice value in field t.Inputs was too long")
4007		}
4008
4009		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Inputs))); err != nil {
4010			return err
4011		}
4012		for _, v := range t.Inputs {
4013			if err := v.MarshalCBOR(cw); err != nil {
4014				return err
4015			}
4016
4017		}
4018	}
4019	return nil
4020}
4021
4022func (t *Pipeline_ManualTriggerData) UnmarshalCBOR(r io.Reader) (err error) {
4023	*t = Pipeline_ManualTriggerData{}
4024
4025	cr := cbg.NewCborReader(r)
4026
4027	maj, extra, err := cr.ReadHeader()
4028	if err != nil {
4029		return err
4030	}
4031	defer func() {
4032		if err == io.EOF {
4033			err = io.ErrUnexpectedEOF
4034		}
4035	}()
4036
4037	if maj != cbg.MajMap {
4038		return fmt.Errorf("cbor input should be of type map")
4039	}
4040
4041	if extra > cbg.MaxLength {
4042		return fmt.Errorf("Pipeline_ManualTriggerData: map struct too large (%d)", extra)
4043	}
4044
4045	n := extra
4046
4047	nameBuf := make([]byte, 6)
4048	for i := uint64(0); i < n; i++ {
4049		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4050		if err != nil {
4051			return err
4052		}
4053
4054		if !ok {
4055			// Field doesn't exist on this type, so ignore it
4056			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4057				return err
4058			}
4059			continue
4060		}
4061
4062		switch string(nameBuf[:nameLen]) {
4063		// t.Inputs ([]*tangled.Pipeline_Pair) (slice)
4064		case "inputs":
4065
4066			maj, extra, err = cr.ReadHeader()
4067			if err != nil {
4068				return err
4069			}
4070
4071			if extra > 8192 {
4072				return fmt.Errorf("t.Inputs: array too large (%d)", extra)
4073			}
4074
4075			if maj != cbg.MajArray {
4076				return fmt.Errorf("expected cbor array")
4077			}
4078
4079			if extra > 0 {
4080				t.Inputs = make([]*Pipeline_Pair, extra)
4081			}
4082
4083			for i := 0; i < int(extra); i++ {
4084				{
4085					var maj byte
4086					var extra uint64
4087					var err error
4088					_ = maj
4089					_ = extra
4090					_ = err
4091
4092					{
4093
4094						b, err := cr.ReadByte()
4095						if err != nil {
4096							return err
4097						}
4098						if b != cbg.CborNull[0] {
4099							if err := cr.UnreadByte(); err != nil {
4100								return err
4101							}
4102							t.Inputs[i] = new(Pipeline_Pair)
4103							if err := t.Inputs[i].UnmarshalCBOR(cr); err != nil {
4104								return xerrors.Errorf("unmarshaling t.Inputs[i] pointer: %w", err)
4105							}
4106						}
4107
4108					}
4109
4110				}
4111			}
4112
4113		default:
4114			// Field doesn't exist on this type, so ignore it
4115			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4116				return err
4117			}
4118		}
4119	}
4120
4121	return nil
4122}
4123func (t *Pipeline_Pair) MarshalCBOR(w io.Writer) error {
4124	if t == nil {
4125		_, err := w.Write(cbg.CborNull)
4126		return err
4127	}
4128
4129	cw := cbg.NewCborWriter(w)
4130
4131	if _, err := cw.Write([]byte{162}); err != nil {
4132		return err
4133	}
4134
4135	// t.Key (string) (string)
4136	if len("key") > 1000000 {
4137		return xerrors.Errorf("Value in field \"key\" was too long")
4138	}
4139
4140	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
4141		return err
4142	}
4143	if _, err := cw.WriteString(string("key")); err != nil {
4144		return err
4145	}
4146
4147	if len(t.Key) > 1000000 {
4148		return xerrors.Errorf("Value in field t.Key was too long")
4149	}
4150
4151	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
4152		return err
4153	}
4154	if _, err := cw.WriteString(string(t.Key)); err != nil {
4155		return err
4156	}
4157
4158	// t.Value (string) (string)
4159	if len("value") > 1000000 {
4160		return xerrors.Errorf("Value in field \"value\" was too long")
4161	}
4162
4163	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil {
4164		return err
4165	}
4166	if _, err := cw.WriteString(string("value")); err != nil {
4167		return err
4168	}
4169
4170	if len(t.Value) > 1000000 {
4171		return xerrors.Errorf("Value in field t.Value was too long")
4172	}
4173
4174	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil {
4175		return err
4176	}
4177	if _, err := cw.WriteString(string(t.Value)); err != nil {
4178		return err
4179	}
4180	return nil
4181}
4182
4183func (t *Pipeline_Pair) UnmarshalCBOR(r io.Reader) (err error) {
4184	*t = Pipeline_Pair{}
4185
4186	cr := cbg.NewCborReader(r)
4187
4188	maj, extra, err := cr.ReadHeader()
4189	if err != nil {
4190		return err
4191	}
4192	defer func() {
4193		if err == io.EOF {
4194			err = io.ErrUnexpectedEOF
4195		}
4196	}()
4197
4198	if maj != cbg.MajMap {
4199		return fmt.Errorf("cbor input should be of type map")
4200	}
4201
4202	if extra > cbg.MaxLength {
4203		return fmt.Errorf("Pipeline_Pair: map struct too large (%d)", extra)
4204	}
4205
4206	n := extra
4207
4208	nameBuf := make([]byte, 5)
4209	for i := uint64(0); i < n; i++ {
4210		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4211		if err != nil {
4212			return err
4213		}
4214
4215		if !ok {
4216			// Field doesn't exist on this type, so ignore it
4217			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4218				return err
4219			}
4220			continue
4221		}
4222
4223		switch string(nameBuf[:nameLen]) {
4224		// t.Key (string) (string)
4225		case "key":
4226
4227			{
4228				sval, err := cbg.ReadStringWithMax(cr, 1000000)
4229				if err != nil {
4230					return err
4231				}
4232
4233				t.Key = string(sval)
4234			}
4235			// t.Value (string) (string)
4236		case "value":
4237
4238			{
4239				sval, err := cbg.ReadStringWithMax(cr, 1000000)
4240				if err != nil {
4241					return err
4242				}
4243
4244				t.Value = string(sval)
4245			}
4246
4247		default:
4248			// Field doesn't exist on this type, so ignore it
4249			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4250				return err
4251			}
4252		}
4253	}
4254
4255	return nil
4256}
4257func (t *Pipeline_PullRequestTriggerData) MarshalCBOR(w io.Writer) error {
4258	if t == nil {
4259		_, err := w.Write(cbg.CborNull)
4260		return err
4261	}
4262
4263	cw := cbg.NewCborWriter(w)
4264
4265	if _, err := cw.Write([]byte{164}); err != nil {
4266		return err
4267	}
4268
4269	// t.Action (string) (string)
4270	if len("action") > 1000000 {
4271		return xerrors.Errorf("Value in field \"action\" was too long")
4272	}
4273
4274	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("action"))); err != nil {
4275		return err
4276	}
4277	if _, err := cw.WriteString(string("action")); err != nil {
4278		return err
4279	}
4280
4281	if len(t.Action) > 1000000 {
4282		return xerrors.Errorf("Value in field t.Action was too long")
4283	}
4284
4285	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Action))); err != nil {
4286		return err
4287	}
4288	if _, err := cw.WriteString(string(t.Action)); err != nil {
4289		return err
4290	}
4291
4292	// t.SourceSha (string) (string)
4293	if len("sourceSha") > 1000000 {
4294		return xerrors.Errorf("Value in field \"sourceSha\" was too long")
4295	}
4296
4297	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sourceSha"))); err != nil {
4298		return err
4299	}
4300	if _, err := cw.WriteString(string("sourceSha")); err != nil {
4301		return err
4302	}
4303
4304	if len(t.SourceSha) > 1000000 {
4305		return xerrors.Errorf("Value in field t.SourceSha was too long")
4306	}
4307
4308	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.SourceSha))); err != nil {
4309		return err
4310	}
4311	if _, err := cw.WriteString(string(t.SourceSha)); err != nil {
4312		return err
4313	}
4314
4315	// t.SourceBranch (string) (string)
4316	if len("sourceBranch") > 1000000 {
4317		return xerrors.Errorf("Value in field \"sourceBranch\" was too long")
4318	}
4319
4320	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sourceBranch"))); err != nil {
4321		return err
4322	}
4323	if _, err := cw.WriteString(string("sourceBranch")); err != nil {
4324		return err
4325	}
4326
4327	if len(t.SourceBranch) > 1000000 {
4328		return xerrors.Errorf("Value in field t.SourceBranch was too long")
4329	}
4330
4331	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.SourceBranch))); err != nil {
4332		return err
4333	}
4334	if _, err := cw.WriteString(string(t.SourceBranch)); err != nil {
4335		return err
4336	}
4337
4338	// t.TargetBranch (string) (string)
4339	if len("targetBranch") > 1000000 {
4340		return xerrors.Errorf("Value in field \"targetBranch\" was too long")
4341	}
4342
4343	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetBranch"))); err != nil {
4344		return err
4345	}
4346	if _, err := cw.WriteString(string("targetBranch")); err != nil {
4347		return err
4348	}
4349
4350	if len(t.TargetBranch) > 1000000 {
4351		return xerrors.Errorf("Value in field t.TargetBranch was too long")
4352	}
4353
4354	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetBranch))); err != nil {
4355		return err
4356	}
4357	if _, err := cw.WriteString(string(t.TargetBranch)); err != nil {
4358		return err
4359	}
4360	return nil
4361}
4362
4363func (t *Pipeline_PullRequestTriggerData) UnmarshalCBOR(r io.Reader) (err error) {
4364	*t = Pipeline_PullRequestTriggerData{}
4365
4366	cr := cbg.NewCborReader(r)
4367
4368	maj, extra, err := cr.ReadHeader()
4369	if err != nil {
4370		return err
4371	}
4372	defer func() {
4373		if err == io.EOF {
4374			err = io.ErrUnexpectedEOF
4375		}
4376	}()
4377
4378	if maj != cbg.MajMap {
4379		return fmt.Errorf("cbor input should be of type map")
4380	}
4381
4382	if extra > cbg.MaxLength {
4383		return fmt.Errorf("Pipeline_PullRequestTriggerData: map struct too large (%d)", extra)
4384	}
4385
4386	n := extra
4387
4388	nameBuf := make([]byte, 12)
4389	for i := uint64(0); i < n; i++ {
4390		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4391		if err != nil {
4392			return err
4393		}
4394
4395		if !ok {
4396			// Field doesn't exist on this type, so ignore it
4397			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4398				return err
4399			}
4400			continue
4401		}
4402
4403		switch string(nameBuf[:nameLen]) {
4404		// t.Action (string) (string)
4405		case "action":
4406
4407			{
4408				sval, err := cbg.ReadStringWithMax(cr, 1000000)
4409				if err != nil {
4410					return err
4411				}
4412
4413				t.Action = string(sval)
4414			}
4415			// t.SourceSha (string) (string)
4416		case "sourceSha":
4417
4418			{
4419				sval, err := cbg.ReadStringWithMax(cr, 1000000)
4420				if err != nil {
4421					return err
4422				}
4423
4424				t.SourceSha = string(sval)
4425			}
4426			// t.SourceBranch (string) (string)
4427		case "sourceBranch":
4428
4429			{
4430				sval, err := cbg.ReadStringWithMax(cr, 1000000)
4431				if err != nil {
4432					return err
4433				}
4434
4435				t.SourceBranch = string(sval)
4436			}
4437			// t.TargetBranch (string) (string)
4438		case "targetBranch":
4439
4440			{
4441				sval, err := cbg.ReadStringWithMax(cr, 1000000)
4442				if err != nil {
4443					return err
4444				}
4445
4446				t.TargetBranch = string(sval)
4447			}
4448
4449		default:
4450			// Field doesn't exist on this type, so ignore it
4451			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4452				return err
4453			}
4454		}
4455	}
4456
4457	return nil
4458}
4459func (t *Pipeline_PushTriggerData) MarshalCBOR(w io.Writer) error {
4460	if t == nil {
4461		_, err := w.Write(cbg.CborNull)
4462		return err
4463	}
4464
4465	cw := cbg.NewCborWriter(w)
4466
4467	if _, err := cw.Write([]byte{163}); err != nil {
4468		return err
4469	}
4470
4471	// t.Ref (string) (string)
4472	if len("ref") > 1000000 {
4473		return xerrors.Errorf("Value in field \"ref\" was too long")
4474	}
4475
4476	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ref"))); err != nil {
4477		return err
4478	}
4479	if _, err := cw.WriteString(string("ref")); err != nil {
4480		return err
4481	}
4482
4483	if len(t.Ref) > 1000000 {
4484		return xerrors.Errorf("Value in field t.Ref was too long")
4485	}
4486
4487	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Ref))); err != nil {
4488		return err
4489	}
4490	if _, err := cw.WriteString(string(t.Ref)); err != nil {
4491		return err
4492	}
4493
4494	// t.NewSha (string) (string)
4495	if len("newSha") > 1000000 {
4496		return xerrors.Errorf("Value in field \"newSha\" was too long")
4497	}
4498
4499	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("newSha"))); err != nil {
4500		return err
4501	}
4502	if _, err := cw.WriteString(string("newSha")); err != nil {
4503		return err
4504	}
4505
4506	if len(t.NewSha) > 1000000 {
4507		return xerrors.Errorf("Value in field t.NewSha was too long")
4508	}
4509
4510	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.NewSha))); err != nil {
4511		return err
4512	}
4513	if _, err := cw.WriteString(string(t.NewSha)); err != nil {
4514		return err
4515	}
4516
4517	// t.OldSha (string) (string)
4518	if len("oldSha") > 1000000 {
4519		return xerrors.Errorf("Value in field \"oldSha\" was too long")
4520	}
4521
4522	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("oldSha"))); err != nil {
4523		return err
4524	}
4525	if _, err := cw.WriteString(string("oldSha")); err != nil {
4526		return err
4527	}
4528
4529	if len(t.OldSha) > 1000000 {
4530		return xerrors.Errorf("Value in field t.OldSha was too long")
4531	}
4532
4533	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.OldSha))); err != nil {
4534		return err
4535	}
4536	if _, err := cw.WriteString(string(t.OldSha)); err != nil {
4537		return err
4538	}
4539	return nil
4540}
4541
4542func (t *Pipeline_PushTriggerData) UnmarshalCBOR(r io.Reader) (err error) {
4543	*t = Pipeline_PushTriggerData{}
4544
4545	cr := cbg.NewCborReader(r)
4546
4547	maj, extra, err := cr.ReadHeader()
4548	if err != nil {
4549		return err
4550	}
4551	defer func() {
4552		if err == io.EOF {
4553			err = io.ErrUnexpectedEOF
4554		}
4555	}()
4556
4557	if maj != cbg.MajMap {
4558		return fmt.Errorf("cbor input should be of type map")
4559	}
4560
4561	if extra > cbg.MaxLength {
4562		return fmt.Errorf("Pipeline_PushTriggerData: map struct too large (%d)", extra)
4563	}
4564
4565	n := extra
4566
4567	nameBuf := make([]byte, 6)
4568	for i := uint64(0); i < n; i++ {
4569		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4570		if err != nil {
4571			return err
4572		}
4573
4574		if !ok {
4575			// Field doesn't exist on this type, so ignore it
4576			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4577				return err
4578			}
4579			continue
4580		}
4581
4582		switch string(nameBuf[:nameLen]) {
4583		// t.Ref (string) (string)
4584		case "ref":
4585
4586			{
4587				sval, err := cbg.ReadStringWithMax(cr, 1000000)
4588				if err != nil {
4589					return err
4590				}
4591
4592				t.Ref = string(sval)
4593			}
4594			// t.NewSha (string) (string)
4595		case "newSha":
4596
4597			{
4598				sval, err := cbg.ReadStringWithMax(cr, 1000000)
4599				if err != nil {
4600					return err
4601				}
4602
4603				t.NewSha = string(sval)
4604			}
4605			// t.OldSha (string) (string)
4606		case "oldSha":
4607
4608			{
4609				sval, err := cbg.ReadStringWithMax(cr, 1000000)
4610				if err != nil {
4611					return err
4612				}
4613
4614				t.OldSha = string(sval)
4615			}
4616
4617		default:
4618			// Field doesn't exist on this type, so ignore it
4619			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4620				return err
4621			}
4622		}
4623	}
4624
4625	return nil
4626}
4627func (t *PipelineStatus) MarshalCBOR(w io.Writer) error {
4628	if t == nil {
4629		_, err := w.Write(cbg.CborNull)
4630		return err
4631	}
4632
4633	cw := cbg.NewCborWriter(w)
4634	fieldCount := 7
4635
4636	if t.Error == nil {
4637		fieldCount--
4638	}
4639
4640	if t.ExitCode == nil {
4641		fieldCount--
4642	}
4643
4644	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
4645		return err
4646	}
4647
4648	// t.LexiconTypeID (string) (string)
4649	if len("$type") > 1000000 {
4650		return xerrors.Errorf("Value in field \"$type\" was too long")
4651	}
4652
4653	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
4654		return err
4655	}
4656	if _, err := cw.WriteString(string("$type")); err != nil {
4657		return err
4658	}
4659
4660	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pipeline.status"))); err != nil {
4661		return err
4662	}
4663	if _, err := cw.WriteString(string("sh.tangled.pipeline.status")); err != nil {
4664		return err
4665	}
4666
4667	// t.Error (string) (string)
4668	if t.Error != nil {
4669
4670		if len("error") > 1000000 {
4671			return xerrors.Errorf("Value in field \"error\" was too long")
4672		}
4673
4674		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("error"))); err != nil {
4675			return err
4676		}
4677		if _, err := cw.WriteString(string("error")); err != nil {
4678			return err
4679		}
4680
4681		if t.Error == nil {
4682			if _, err := cw.Write(cbg.CborNull); err != nil {
4683				return err
4684			}
4685		} else {
4686			if len(*t.Error) > 1000000 {
4687				return xerrors.Errorf("Value in field t.Error was too long")
4688			}
4689
4690			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Error))); err != nil {
4691				return err
4692			}
4693			if _, err := cw.WriteString(string(*t.Error)); err != nil {
4694				return err
4695			}
4696		}
4697	}
4698
4699	// t.Status (string) (string)
4700	if len("status") > 1000000 {
4701		return xerrors.Errorf("Value in field \"status\" was too long")
4702	}
4703
4704	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {
4705		return err
4706	}
4707	if _, err := cw.WriteString(string("status")); err != nil {
4708		return err
4709	}
4710
4711	if len(t.Status) > 1000000 {
4712		return xerrors.Errorf("Value in field t.Status was too long")
4713	}
4714
4715	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil {
4716		return err
4717	}
4718	if _, err := cw.WriteString(string(t.Status)); err != nil {
4719		return err
4720	}
4721
4722	// t.ExitCode (int64) (int64)
4723	if t.ExitCode != nil {
4724
4725		if len("exitCode") > 1000000 {
4726			return xerrors.Errorf("Value in field \"exitCode\" was too long")
4727		}
4728
4729		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("exitCode"))); err != nil {
4730			return err
4731		}
4732		if _, err := cw.WriteString(string("exitCode")); err != nil {
4733			return err
4734		}
4735
4736		if t.ExitCode == nil {
4737			if _, err := cw.Write(cbg.CborNull); err != nil {
4738				return err
4739			}
4740		} else {
4741			if *t.ExitCode >= 0 {
4742				if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.ExitCode)); err != nil {
4743					return err
4744				}
4745			} else {
4746				if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.ExitCode-1)); err != nil {
4747					return err
4748				}
4749			}
4750		}
4751
4752	}
4753
4754	// t.Pipeline (string) (string)
4755	if len("pipeline") > 1000000 {
4756		return xerrors.Errorf("Value in field \"pipeline\" was too long")
4757	}
4758
4759	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pipeline"))); err != nil {
4760		return err
4761	}
4762	if _, err := cw.WriteString(string("pipeline")); err != nil {
4763		return err
4764	}
4765
4766	if len(t.Pipeline) > 1000000 {
4767		return xerrors.Errorf("Value in field t.Pipeline was too long")
4768	}
4769
4770	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pipeline))); err != nil {
4771		return err
4772	}
4773	if _, err := cw.WriteString(string(t.Pipeline)); err != nil {
4774		return err
4775	}
4776
4777	// t.Workflow (string) (string)
4778	if len("workflow") > 1000000 {
4779		return xerrors.Errorf("Value in field \"workflow\" was too long")
4780	}
4781
4782	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflow"))); err != nil {
4783		return err
4784	}
4785	if _, err := cw.WriteString(string("workflow")); err != nil {
4786		return err
4787	}
4788
4789	if len(t.Workflow) > 1000000 {
4790		return xerrors.Errorf("Value in field t.Workflow was too long")
4791	}
4792
4793	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Workflow))); err != nil {
4794		return err
4795	}
4796	if _, err := cw.WriteString(string(t.Workflow)); err != nil {
4797		return err
4798	}
4799
4800	// t.CreatedAt (string) (string)
4801	if len("createdAt") > 1000000 {
4802		return xerrors.Errorf("Value in field \"createdAt\" was too long")
4803	}
4804
4805	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
4806		return err
4807	}
4808	if _, err := cw.WriteString(string("createdAt")); err != nil {
4809		return err
4810	}
4811
4812	if len(t.CreatedAt) > 1000000 {
4813		return xerrors.Errorf("Value in field t.CreatedAt was too long")
4814	}
4815
4816	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
4817		return err
4818	}
4819	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
4820		return err
4821	}
4822	return nil
4823}
4824
4825func (t *PipelineStatus) UnmarshalCBOR(r io.Reader) (err error) {
4826	*t = PipelineStatus{}
4827
4828	cr := cbg.NewCborReader(r)
4829
4830	maj, extra, err := cr.ReadHeader()
4831	if err != nil {
4832		return err
4833	}
4834	defer func() {
4835		if err == io.EOF {
4836			err = io.ErrUnexpectedEOF
4837		}
4838	}()
4839
4840	if maj != cbg.MajMap {
4841		return fmt.Errorf("cbor input should be of type map")
4842	}
4843
4844	if extra > cbg.MaxLength {
4845		return fmt.Errorf("PipelineStatus: map struct too large (%d)", extra)
4846	}
4847
4848	n := extra
4849
4850	nameBuf := make([]byte, 9)
4851	for i := uint64(0); i < n; i++ {
4852		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
4853		if err != nil {
4854			return err
4855		}
4856
4857		if !ok {
4858			// Field doesn't exist on this type, so ignore it
4859			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
4860				return err
4861			}
4862			continue
4863		}
4864
4865		switch string(nameBuf[:nameLen]) {
4866		// t.LexiconTypeID (string) (string)
4867		case "$type":
4868
4869			{
4870				sval, err := cbg.ReadStringWithMax(cr, 1000000)
4871				if err != nil {
4872					return err
4873				}
4874
4875				t.LexiconTypeID = string(sval)
4876			}
4877			// t.Error (string) (string)
4878		case "error":
4879
4880			{
4881				b, err := cr.ReadByte()
4882				if err != nil {
4883					return err
4884				}
4885				if b != cbg.CborNull[0] {
4886					if err := cr.UnreadByte(); err != nil {
4887						return err
4888					}
4889
4890					sval, err := cbg.ReadStringWithMax(cr, 1000000)
4891					if err != nil {
4892						return err
4893					}
4894
4895					t.Error = (*string)(&sval)
4896				}
4897			}
4898			// t.Status (string) (string)
4899		case "status":
4900
4901			{
4902				sval, err := cbg.ReadStringWithMax(cr, 1000000)
4903				if err != nil {
4904					return err
4905				}
4906
4907				t.Status = string(sval)
4908			}
4909			// t.ExitCode (int64) (int64)
4910		case "exitCode":
4911			{
4912
4913				b, err := cr.ReadByte()
4914				if err != nil {
4915					return err
4916				}
4917				if b != cbg.CborNull[0] {
4918					if err := cr.UnreadByte(); err != nil {
4919						return err
4920					}
4921					maj, extra, err := cr.ReadHeader()
4922					if err != nil {
4923						return err
4924					}
4925					var extraI int64
4926					switch maj {
4927					case cbg.MajUnsignedInt:
4928						extraI = int64(extra)
4929						if extraI < 0 {
4930							return fmt.Errorf("int64 positive overflow")
4931						}
4932					case cbg.MajNegativeInt:
4933						extraI = int64(extra)
4934						if extraI < 0 {
4935							return fmt.Errorf("int64 negative overflow")
4936						}
4937						extraI = -1 - extraI
4938					default:
4939						return fmt.Errorf("wrong type for int64 field: %d", maj)
4940					}
4941
4942					t.ExitCode = (*int64)(&extraI)
4943				}
4944			}
4945			// t.Pipeline (string) (string)
4946		case "pipeline":
4947
4948			{
4949				sval, err := cbg.ReadStringWithMax(cr, 1000000)
4950				if err != nil {
4951					return err
4952				}
4953
4954				t.Pipeline = string(sval)
4955			}
4956			// t.Workflow (string) (string)
4957		case "workflow":
4958
4959			{
4960				sval, err := cbg.ReadStringWithMax(cr, 1000000)
4961				if err != nil {
4962					return err
4963				}
4964
4965				t.Workflow = string(sval)
4966			}
4967			// t.CreatedAt (string) (string)
4968		case "createdAt":
4969
4970			{
4971				sval, err := cbg.ReadStringWithMax(cr, 1000000)
4972				if err != nil {
4973					return err
4974				}
4975
4976				t.CreatedAt = string(sval)
4977			}
4978
4979		default:
4980			// Field doesn't exist on this type, so ignore it
4981			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
4982				return err
4983			}
4984		}
4985	}
4986
4987	return nil
4988}
4989func (t *Pipeline_TriggerMetadata) MarshalCBOR(w io.Writer) error {
4990	if t == nil {
4991		_, err := w.Write(cbg.CborNull)
4992		return err
4993	}
4994
4995	cw := cbg.NewCborWriter(w)
4996	fieldCount := 5
4997
4998	if t.Manual == nil {
4999		fieldCount--
5000	}
5001
5002	if t.PullRequest == nil {
5003		fieldCount--
5004	}
5005
5006	if t.Push == nil {
5007		fieldCount--
5008	}
5009
5010	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
5011		return err
5012	}
5013
5014	// t.Kind (string) (string)
5015	if len("kind") > 1000000 {
5016		return xerrors.Errorf("Value in field \"kind\" was too long")
5017	}
5018
5019	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("kind"))); err != nil {
5020		return err
5021	}
5022	if _, err := cw.WriteString(string("kind")); err != nil {
5023		return err
5024	}
5025
5026	if len(t.Kind) > 1000000 {
5027		return xerrors.Errorf("Value in field t.Kind was too long")
5028	}
5029
5030	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Kind))); err != nil {
5031		return err
5032	}
5033	if _, err := cw.WriteString(string(t.Kind)); err != nil {
5034		return err
5035	}
5036
5037	// t.Push (tangled.Pipeline_PushTriggerData) (struct)
5038	if t.Push != nil {
5039
5040		if len("push") > 1000000 {
5041			return xerrors.Errorf("Value in field \"push\" was too long")
5042		}
5043
5044		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("push"))); err != nil {
5045			return err
5046		}
5047		if _, err := cw.WriteString(string("push")); err != nil {
5048			return err
5049		}
5050
5051		if err := t.Push.MarshalCBOR(cw); err != nil {
5052			return err
5053		}
5054	}
5055
5056	// t.Repo (tangled.Pipeline_TriggerRepo) (struct)
5057	if len("repo") > 1000000 {
5058		return xerrors.Errorf("Value in field \"repo\" was too long")
5059	}
5060
5061	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
5062		return err
5063	}
5064	if _, err := cw.WriteString(string("repo")); err != nil {
5065		return err
5066	}
5067
5068	if err := t.Repo.MarshalCBOR(cw); err != nil {
5069		return err
5070	}
5071
5072	// t.Manual (tangled.Pipeline_ManualTriggerData) (struct)
5073	if t.Manual != nil {
5074
5075		if len("manual") > 1000000 {
5076			return xerrors.Errorf("Value in field \"manual\" was too long")
5077		}
5078
5079		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("manual"))); err != nil {
5080			return err
5081		}
5082		if _, err := cw.WriteString(string("manual")); err != nil {
5083			return err
5084		}
5085
5086		if err := t.Manual.MarshalCBOR(cw); err != nil {
5087			return err
5088		}
5089	}
5090
5091	// t.PullRequest (tangled.Pipeline_PullRequestTriggerData) (struct)
5092	if t.PullRequest != nil {
5093
5094		if len("pullRequest") > 1000000 {
5095			return xerrors.Errorf("Value in field \"pullRequest\" was too long")
5096		}
5097
5098		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pullRequest"))); err != nil {
5099			return err
5100		}
5101		if _, err := cw.WriteString(string("pullRequest")); err != nil {
5102			return err
5103		}
5104
5105		if err := t.PullRequest.MarshalCBOR(cw); err != nil {
5106			return err
5107		}
5108	}
5109	return nil
5110}
5111
5112func (t *Pipeline_TriggerMetadata) UnmarshalCBOR(r io.Reader) (err error) {
5113	*t = Pipeline_TriggerMetadata{}
5114
5115	cr := cbg.NewCborReader(r)
5116
5117	maj, extra, err := cr.ReadHeader()
5118	if err != nil {
5119		return err
5120	}
5121	defer func() {
5122		if err == io.EOF {
5123			err = io.ErrUnexpectedEOF
5124		}
5125	}()
5126
5127	if maj != cbg.MajMap {
5128		return fmt.Errorf("cbor input should be of type map")
5129	}
5130
5131	if extra > cbg.MaxLength {
5132		return fmt.Errorf("Pipeline_TriggerMetadata: map struct too large (%d)", extra)
5133	}
5134
5135	n := extra
5136
5137	nameBuf := make([]byte, 11)
5138	for i := uint64(0); i < n; i++ {
5139		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5140		if err != nil {
5141			return err
5142		}
5143
5144		if !ok {
5145			// Field doesn't exist on this type, so ignore it
5146			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5147				return err
5148			}
5149			continue
5150		}
5151
5152		switch string(nameBuf[:nameLen]) {
5153		// t.Kind (string) (string)
5154		case "kind":
5155
5156			{
5157				sval, err := cbg.ReadStringWithMax(cr, 1000000)
5158				if err != nil {
5159					return err
5160				}
5161
5162				t.Kind = string(sval)
5163			}
5164			// t.Push (tangled.Pipeline_PushTriggerData) (struct)
5165		case "push":
5166
5167			{
5168
5169				b, err := cr.ReadByte()
5170				if err != nil {
5171					return err
5172				}
5173				if b != cbg.CborNull[0] {
5174					if err := cr.UnreadByte(); err != nil {
5175						return err
5176					}
5177					t.Push = new(Pipeline_PushTriggerData)
5178					if err := t.Push.UnmarshalCBOR(cr); err != nil {
5179						return xerrors.Errorf("unmarshaling t.Push pointer: %w", err)
5180					}
5181				}
5182
5183			}
5184			// t.Repo (tangled.Pipeline_TriggerRepo) (struct)
5185		case "repo":
5186
5187			{
5188
5189				b, err := cr.ReadByte()
5190				if err != nil {
5191					return err
5192				}
5193				if b != cbg.CborNull[0] {
5194					if err := cr.UnreadByte(); err != nil {
5195						return err
5196					}
5197					t.Repo = new(Pipeline_TriggerRepo)
5198					if err := t.Repo.UnmarshalCBOR(cr); err != nil {
5199						return xerrors.Errorf("unmarshaling t.Repo pointer: %w", err)
5200					}
5201				}
5202
5203			}
5204			// t.Manual (tangled.Pipeline_ManualTriggerData) (struct)
5205		case "manual":
5206
5207			{
5208
5209				b, err := cr.ReadByte()
5210				if err != nil {
5211					return err
5212				}
5213				if b != cbg.CborNull[0] {
5214					if err := cr.UnreadByte(); err != nil {
5215						return err
5216					}
5217					t.Manual = new(Pipeline_ManualTriggerData)
5218					if err := t.Manual.UnmarshalCBOR(cr); err != nil {
5219						return xerrors.Errorf("unmarshaling t.Manual pointer: %w", err)
5220					}
5221				}
5222
5223			}
5224			// t.PullRequest (tangled.Pipeline_PullRequestTriggerData) (struct)
5225		case "pullRequest":
5226
5227			{
5228
5229				b, err := cr.ReadByte()
5230				if err != nil {
5231					return err
5232				}
5233				if b != cbg.CborNull[0] {
5234					if err := cr.UnreadByte(); err != nil {
5235						return err
5236					}
5237					t.PullRequest = new(Pipeline_PullRequestTriggerData)
5238					if err := t.PullRequest.UnmarshalCBOR(cr); err != nil {
5239						return xerrors.Errorf("unmarshaling t.PullRequest pointer: %w", err)
5240					}
5241				}
5242
5243			}
5244
5245		default:
5246			// Field doesn't exist on this type, so ignore it
5247			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5248				return err
5249			}
5250		}
5251	}
5252
5253	return nil
5254}
5255func (t *Pipeline_TriggerRepo) MarshalCBOR(w io.Writer) error {
5256	if t == nil {
5257		_, err := w.Write(cbg.CborNull)
5258		return err
5259	}
5260
5261	cw := cbg.NewCborWriter(w)
5262
5263	if _, err := cw.Write([]byte{164}); err != nil {
5264		return err
5265	}
5266
5267	// t.Did (string) (string)
5268	if len("did") > 1000000 {
5269		return xerrors.Errorf("Value in field \"did\" was too long")
5270	}
5271
5272	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("did"))); err != nil {
5273		return err
5274	}
5275	if _, err := cw.WriteString(string("did")); err != nil {
5276		return err
5277	}
5278
5279	if len(t.Did) > 1000000 {
5280		return xerrors.Errorf("Value in field t.Did was too long")
5281	}
5282
5283	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Did))); err != nil {
5284		return err
5285	}
5286	if _, err := cw.WriteString(string(t.Did)); err != nil {
5287		return err
5288	}
5289
5290	// t.Knot (string) (string)
5291	if len("knot") > 1000000 {
5292		return xerrors.Errorf("Value in field \"knot\" was too long")
5293	}
5294
5295	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil {
5296		return err
5297	}
5298	if _, err := cw.WriteString(string("knot")); err != nil {
5299		return err
5300	}
5301
5302	if len(t.Knot) > 1000000 {
5303		return xerrors.Errorf("Value in field t.Knot was too long")
5304	}
5305
5306	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil {
5307		return err
5308	}
5309	if _, err := cw.WriteString(string(t.Knot)); err != nil {
5310		return err
5311	}
5312
5313	// t.Repo (string) (string)
5314	if len("repo") > 1000000 {
5315		return xerrors.Errorf("Value in field \"repo\" was too long")
5316	}
5317
5318	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
5319		return err
5320	}
5321	if _, err := cw.WriteString(string("repo")); err != nil {
5322		return err
5323	}
5324
5325	if len(t.Repo) > 1000000 {
5326		return xerrors.Errorf("Value in field t.Repo was too long")
5327	}
5328
5329	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
5330		return err
5331	}
5332	if _, err := cw.WriteString(string(t.Repo)); err != nil {
5333		return err
5334	}
5335
5336	// t.DefaultBranch (string) (string)
5337	if len("defaultBranch") > 1000000 {
5338		return xerrors.Errorf("Value in field \"defaultBranch\" was too long")
5339	}
5340
5341	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("defaultBranch"))); err != nil {
5342		return err
5343	}
5344	if _, err := cw.WriteString(string("defaultBranch")); err != nil {
5345		return err
5346	}
5347
5348	if len(t.DefaultBranch) > 1000000 {
5349		return xerrors.Errorf("Value in field t.DefaultBranch was too long")
5350	}
5351
5352	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.DefaultBranch))); err != nil {
5353		return err
5354	}
5355	if _, err := cw.WriteString(string(t.DefaultBranch)); err != nil {
5356		return err
5357	}
5358	return nil
5359}
5360
5361func (t *Pipeline_TriggerRepo) UnmarshalCBOR(r io.Reader) (err error) {
5362	*t = Pipeline_TriggerRepo{}
5363
5364	cr := cbg.NewCborReader(r)
5365
5366	maj, extra, err := cr.ReadHeader()
5367	if err != nil {
5368		return err
5369	}
5370	defer func() {
5371		if err == io.EOF {
5372			err = io.ErrUnexpectedEOF
5373		}
5374	}()
5375
5376	if maj != cbg.MajMap {
5377		return fmt.Errorf("cbor input should be of type map")
5378	}
5379
5380	if extra > cbg.MaxLength {
5381		return fmt.Errorf("Pipeline_TriggerRepo: map struct too large (%d)", extra)
5382	}
5383
5384	n := extra
5385
5386	nameBuf := make([]byte, 13)
5387	for i := uint64(0); i < n; i++ {
5388		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5389		if err != nil {
5390			return err
5391		}
5392
5393		if !ok {
5394			// Field doesn't exist on this type, so ignore it
5395			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5396				return err
5397			}
5398			continue
5399		}
5400
5401		switch string(nameBuf[:nameLen]) {
5402		// t.Did (string) (string)
5403		case "did":
5404
5405			{
5406				sval, err := cbg.ReadStringWithMax(cr, 1000000)
5407				if err != nil {
5408					return err
5409				}
5410
5411				t.Did = string(sval)
5412			}
5413			// t.Knot (string) (string)
5414		case "knot":
5415
5416			{
5417				sval, err := cbg.ReadStringWithMax(cr, 1000000)
5418				if err != nil {
5419					return err
5420				}
5421
5422				t.Knot = string(sval)
5423			}
5424			// t.Repo (string) (string)
5425		case "repo":
5426
5427			{
5428				sval, err := cbg.ReadStringWithMax(cr, 1000000)
5429				if err != nil {
5430					return err
5431				}
5432
5433				t.Repo = string(sval)
5434			}
5435			// t.DefaultBranch (string) (string)
5436		case "defaultBranch":
5437
5438			{
5439				sval, err := cbg.ReadStringWithMax(cr, 1000000)
5440				if err != nil {
5441					return err
5442				}
5443
5444				t.DefaultBranch = string(sval)
5445			}
5446
5447		default:
5448			// Field doesn't exist on this type, so ignore it
5449			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5450				return err
5451			}
5452		}
5453	}
5454
5455	return nil
5456}
5457func (t *Pipeline_Workflow) MarshalCBOR(w io.Writer) error {
5458	if t == nil {
5459		_, err := w.Write(cbg.CborNull)
5460		return err
5461	}
5462
5463	cw := cbg.NewCborWriter(w)
5464
5465	if _, err := cw.Write([]byte{164}); err != nil {
5466		return err
5467	}
5468
5469	// t.Raw (string) (string)
5470	if len("raw") > 1000000 {
5471		return xerrors.Errorf("Value in field \"raw\" was too long")
5472	}
5473
5474	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("raw"))); err != nil {
5475		return err
5476	}
5477	if _, err := cw.WriteString(string("raw")); err != nil {
5478		return err
5479	}
5480
5481	if len(t.Raw) > 1000000 {
5482		return xerrors.Errorf("Value in field t.Raw was too long")
5483	}
5484
5485	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Raw))); err != nil {
5486		return err
5487	}
5488	if _, err := cw.WriteString(string(t.Raw)); err != nil {
5489		return err
5490	}
5491
5492	// t.Name (string) (string)
5493	if len("name") > 1000000 {
5494		return xerrors.Errorf("Value in field \"name\" was too long")
5495	}
5496
5497	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
5498		return err
5499	}
5500	if _, err := cw.WriteString(string("name")); err != nil {
5501		return err
5502	}
5503
5504	if len(t.Name) > 1000000 {
5505		return xerrors.Errorf("Value in field t.Name was too long")
5506	}
5507
5508	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
5509		return err
5510	}
5511	if _, err := cw.WriteString(string(t.Name)); err != nil {
5512		return err
5513	}
5514
5515	// t.Clone (tangled.Pipeline_CloneOpts) (struct)
5516	if len("clone") > 1000000 {
5517		return xerrors.Errorf("Value in field \"clone\" was too long")
5518	}
5519
5520	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("clone"))); err != nil {
5521		return err
5522	}
5523	if _, err := cw.WriteString(string("clone")); err != nil {
5524		return err
5525	}
5526
5527	if err := t.Clone.MarshalCBOR(cw); err != nil {
5528		return err
5529	}
5530
5531	// t.Engine (string) (string)
5532	if len("engine") > 1000000 {
5533		return xerrors.Errorf("Value in field \"engine\" was too long")
5534	}
5535
5536	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("engine"))); err != nil {
5537		return err
5538	}
5539	if _, err := cw.WriteString(string("engine")); err != nil {
5540		return err
5541	}
5542
5543	if len(t.Engine) > 1000000 {
5544		return xerrors.Errorf("Value in field t.Engine was too long")
5545	}
5546
5547	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Engine))); err != nil {
5548		return err
5549	}
5550	if _, err := cw.WriteString(string(t.Engine)); err != nil {
5551		return err
5552	}
5553	return nil
5554}
5555
5556func (t *Pipeline_Workflow) UnmarshalCBOR(r io.Reader) (err error) {
5557	*t = Pipeline_Workflow{}
5558
5559	cr := cbg.NewCborReader(r)
5560
5561	maj, extra, err := cr.ReadHeader()
5562	if err != nil {
5563		return err
5564	}
5565	defer func() {
5566		if err == io.EOF {
5567			err = io.ErrUnexpectedEOF
5568		}
5569	}()
5570
5571	if maj != cbg.MajMap {
5572		return fmt.Errorf("cbor input should be of type map")
5573	}
5574
5575	if extra > cbg.MaxLength {
5576		return fmt.Errorf("Pipeline_Workflow: map struct too large (%d)", extra)
5577	}
5578
5579	n := extra
5580
5581	nameBuf := make([]byte, 6)
5582	for i := uint64(0); i < n; i++ {
5583		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5584		if err != nil {
5585			return err
5586		}
5587
5588		if !ok {
5589			// Field doesn't exist on this type, so ignore it
5590			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5591				return err
5592			}
5593			continue
5594		}
5595
5596		switch string(nameBuf[:nameLen]) {
5597		// t.Raw (string) (string)
5598		case "raw":
5599
5600			{
5601				sval, err := cbg.ReadStringWithMax(cr, 1000000)
5602				if err != nil {
5603					return err
5604				}
5605
5606				t.Raw = string(sval)
5607			}
5608			// t.Name (string) (string)
5609		case "name":
5610
5611			{
5612				sval, err := cbg.ReadStringWithMax(cr, 1000000)
5613				if err != nil {
5614					return err
5615				}
5616
5617				t.Name = string(sval)
5618			}
5619			// t.Clone (tangled.Pipeline_CloneOpts) (struct)
5620		case "clone":
5621
5622			{
5623
5624				b, err := cr.ReadByte()
5625				if err != nil {
5626					return err
5627				}
5628				if b != cbg.CborNull[0] {
5629					if err := cr.UnreadByte(); err != nil {
5630						return err
5631					}
5632					t.Clone = new(Pipeline_CloneOpts)
5633					if err := t.Clone.UnmarshalCBOR(cr); err != nil {
5634						return xerrors.Errorf("unmarshaling t.Clone pointer: %w", err)
5635					}
5636				}
5637
5638			}
5639			// t.Engine (string) (string)
5640		case "engine":
5641
5642			{
5643				sval, err := cbg.ReadStringWithMax(cr, 1000000)
5644				if err != nil {
5645					return err
5646				}
5647
5648				t.Engine = string(sval)
5649			}
5650
5651		default:
5652			// Field doesn't exist on this type, so ignore it
5653			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5654				return err
5655			}
5656		}
5657	}
5658
5659	return nil
5660}
5661func (t *PublicKey) MarshalCBOR(w io.Writer) error {
5662	if t == nil {
5663		_, err := w.Write(cbg.CborNull)
5664		return err
5665	}
5666
5667	cw := cbg.NewCborWriter(w)
5668
5669	if _, err := cw.Write([]byte{164}); err != nil {
5670		return err
5671	}
5672
5673	// t.Key (string) (string)
5674	if len("key") > 1000000 {
5675		return xerrors.Errorf("Value in field \"key\" was too long")
5676	}
5677
5678	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
5679		return err
5680	}
5681	if _, err := cw.WriteString(string("key")); err != nil {
5682		return err
5683	}
5684
5685	if len(t.Key) > 1000000 {
5686		return xerrors.Errorf("Value in field t.Key was too long")
5687	}
5688
5689	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
5690		return err
5691	}
5692	if _, err := cw.WriteString(string(t.Key)); err != nil {
5693		return err
5694	}
5695
5696	// t.Name (string) (string)
5697	if len("name") > 1000000 {
5698		return xerrors.Errorf("Value in field \"name\" was too long")
5699	}
5700
5701	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
5702		return err
5703	}
5704	if _, err := cw.WriteString(string("name")); err != nil {
5705		return err
5706	}
5707
5708	if len(t.Name) > 1000000 {
5709		return xerrors.Errorf("Value in field t.Name was too long")
5710	}
5711
5712	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
5713		return err
5714	}
5715	if _, err := cw.WriteString(string(t.Name)); err != nil {
5716		return err
5717	}
5718
5719	// t.LexiconTypeID (string) (string)
5720	if len("$type") > 1000000 {
5721		return xerrors.Errorf("Value in field \"$type\" was too long")
5722	}
5723
5724	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
5725		return err
5726	}
5727	if _, err := cw.WriteString(string("$type")); err != nil {
5728		return err
5729	}
5730
5731	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.publicKey"))); err != nil {
5732		return err
5733	}
5734	if _, err := cw.WriteString(string("sh.tangled.publicKey")); err != nil {
5735		return err
5736	}
5737
5738	// t.CreatedAt (string) (string)
5739	if len("createdAt") > 1000000 {
5740		return xerrors.Errorf("Value in field \"createdAt\" was too long")
5741	}
5742
5743	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
5744		return err
5745	}
5746	if _, err := cw.WriteString(string("createdAt")); err != nil {
5747		return err
5748	}
5749
5750	if len(t.CreatedAt) > 1000000 {
5751		return xerrors.Errorf("Value in field t.CreatedAt was too long")
5752	}
5753
5754	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
5755		return err
5756	}
5757	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
5758		return err
5759	}
5760	return nil
5761}
5762
5763func (t *PublicKey) UnmarshalCBOR(r io.Reader) (err error) {
5764	*t = PublicKey{}
5765
5766	cr := cbg.NewCborReader(r)
5767
5768	maj, extra, err := cr.ReadHeader()
5769	if err != nil {
5770		return err
5771	}
5772	defer func() {
5773		if err == io.EOF {
5774			err = io.ErrUnexpectedEOF
5775		}
5776	}()
5777
5778	if maj != cbg.MajMap {
5779		return fmt.Errorf("cbor input should be of type map")
5780	}
5781
5782	if extra > cbg.MaxLength {
5783		return fmt.Errorf("PublicKey: map struct too large (%d)", extra)
5784	}
5785
5786	n := extra
5787
5788	nameBuf := make([]byte, 9)
5789	for i := uint64(0); i < n; i++ {
5790		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
5791		if err != nil {
5792			return err
5793		}
5794
5795		if !ok {
5796			// Field doesn't exist on this type, so ignore it
5797			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
5798				return err
5799			}
5800			continue
5801		}
5802
5803		switch string(nameBuf[:nameLen]) {
5804		// t.Key (string) (string)
5805		case "key":
5806
5807			{
5808				sval, err := cbg.ReadStringWithMax(cr, 1000000)
5809				if err != nil {
5810					return err
5811				}
5812
5813				t.Key = string(sval)
5814			}
5815			// t.Name (string) (string)
5816		case "name":
5817
5818			{
5819				sval, err := cbg.ReadStringWithMax(cr, 1000000)
5820				if err != nil {
5821					return err
5822				}
5823
5824				t.Name = string(sval)
5825			}
5826			// t.LexiconTypeID (string) (string)
5827		case "$type":
5828
5829			{
5830				sval, err := cbg.ReadStringWithMax(cr, 1000000)
5831				if err != nil {
5832					return err
5833				}
5834
5835				t.LexiconTypeID = string(sval)
5836			}
5837			// t.CreatedAt (string) (string)
5838		case "createdAt":
5839
5840			{
5841				sval, err := cbg.ReadStringWithMax(cr, 1000000)
5842				if err != nil {
5843					return err
5844				}
5845
5846				t.CreatedAt = string(sval)
5847			}
5848
5849		default:
5850			// Field doesn't exist on this type, so ignore it
5851			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
5852				return err
5853			}
5854		}
5855	}
5856
5857	return nil
5858}
5859func (t *Repo) MarshalCBOR(w io.Writer) error {
5860	if t == nil {
5861		_, err := w.Write(cbg.CborNull)
5862		return err
5863	}
5864
5865	cw := cbg.NewCborWriter(w)
5866	fieldCount := 10
5867
5868	if t.Description == nil {
5869		fieldCount--
5870	}
5871
5872	if t.Labels == nil {
5873		fieldCount--
5874	}
5875
5876	if t.Source == nil {
5877		fieldCount--
5878	}
5879
5880	if t.Spindle == nil {
5881		fieldCount--
5882	}
5883
5884	if t.Topics == nil {
5885		fieldCount--
5886	}
5887
5888	if t.Website == nil {
5889		fieldCount--
5890	}
5891
5892	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
5893		return err
5894	}
5895
5896	// t.Knot (string) (string)
5897	if len("knot") > 1000000 {
5898		return xerrors.Errorf("Value in field \"knot\" was too long")
5899	}
5900
5901	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil {
5902		return err
5903	}
5904	if _, err := cw.WriteString(string("knot")); err != nil {
5905		return err
5906	}
5907
5908	if len(t.Knot) > 1000000 {
5909		return xerrors.Errorf("Value in field t.Knot was too long")
5910	}
5911
5912	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil {
5913		return err
5914	}
5915	if _, err := cw.WriteString(string(t.Knot)); err != nil {
5916		return err
5917	}
5918
5919	// t.Name (string) (string)
5920	if len("name") > 1000000 {
5921		return xerrors.Errorf("Value in field \"name\" was too long")
5922	}
5923
5924	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
5925		return err
5926	}
5927	if _, err := cw.WriteString(string("name")); err != nil {
5928		return err
5929	}
5930
5931	if len(t.Name) > 1000000 {
5932		return xerrors.Errorf("Value in field t.Name was too long")
5933	}
5934
5935	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
5936		return err
5937	}
5938	if _, err := cw.WriteString(string(t.Name)); err != nil {
5939		return err
5940	}
5941
5942	// t.LexiconTypeID (string) (string)
5943	if len("$type") > 1000000 {
5944		return xerrors.Errorf("Value in field \"$type\" was too long")
5945	}
5946
5947	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
5948		return err
5949	}
5950	if _, err := cw.WriteString(string("$type")); err != nil {
5951		return err
5952	}
5953
5954	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo"))); err != nil {
5955		return err
5956	}
5957	if _, err := cw.WriteString(string("sh.tangled.repo")); err != nil {
5958		return err
5959	}
5960
5961	// t.Labels ([]string) (slice)
5962	if t.Labels != nil {
5963
5964		if len("labels") > 1000000 {
5965			return xerrors.Errorf("Value in field \"labels\" was too long")
5966		}
5967
5968		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("labels"))); err != nil {
5969			return err
5970		}
5971		if _, err := cw.WriteString(string("labels")); err != nil {
5972			return err
5973		}
5974
5975		if len(t.Labels) > 8192 {
5976			return xerrors.Errorf("Slice value in field t.Labels was too long")
5977		}
5978
5979		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Labels))); err != nil {
5980			return err
5981		}
5982		for _, v := range t.Labels {
5983			if len(v) > 1000000 {
5984				return xerrors.Errorf("Value in field v was too long")
5985			}
5986
5987			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
5988				return err
5989			}
5990			if _, err := cw.WriteString(string(v)); err != nil {
5991				return err
5992			}
5993
5994		}
5995	}
5996
5997	// t.Source (string) (string)
5998	if t.Source != nil {
5999
6000		if len("source") > 1000000 {
6001			return xerrors.Errorf("Value in field \"source\" was too long")
6002		}
6003
6004		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil {
6005			return err
6006		}
6007		if _, err := cw.WriteString(string("source")); err != nil {
6008			return err
6009		}
6010
6011		if t.Source == nil {
6012			if _, err := cw.Write(cbg.CborNull); err != nil {
6013				return err
6014			}
6015		} else {
6016			if len(*t.Source) > 1000000 {
6017				return xerrors.Errorf("Value in field t.Source was too long")
6018			}
6019
6020			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Source))); err != nil {
6021				return err
6022			}
6023			if _, err := cw.WriteString(string(*t.Source)); err != nil {
6024				return err
6025			}
6026		}
6027	}
6028
6029	// t.Topics ([]string) (slice)
6030	if t.Topics != nil {
6031
6032		if len("topics") > 1000000 {
6033			return xerrors.Errorf("Value in field \"topics\" was too long")
6034		}
6035
6036		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("topics"))); err != nil {
6037			return err
6038		}
6039		if _, err := cw.WriteString(string("topics")); err != nil {
6040			return err
6041		}
6042
6043		if len(t.Topics) > 8192 {
6044			return xerrors.Errorf("Slice value in field t.Topics was too long")
6045		}
6046
6047		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Topics))); err != nil {
6048			return err
6049		}
6050		for _, v := range t.Topics {
6051			if len(v) > 1000000 {
6052				return xerrors.Errorf("Value in field v was too long")
6053			}
6054
6055			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
6056				return err
6057			}
6058			if _, err := cw.WriteString(string(v)); err != nil {
6059				return err
6060			}
6061
6062		}
6063	}
6064
6065	// t.Spindle (string) (string)
6066	if t.Spindle != nil {
6067
6068		if len("spindle") > 1000000 {
6069			return xerrors.Errorf("Value in field \"spindle\" was too long")
6070		}
6071
6072		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("spindle"))); err != nil {
6073			return err
6074		}
6075		if _, err := cw.WriteString(string("spindle")); err != nil {
6076			return err
6077		}
6078
6079		if t.Spindle == nil {
6080			if _, err := cw.Write(cbg.CborNull); err != nil {
6081				return err
6082			}
6083		} else {
6084			if len(*t.Spindle) > 1000000 {
6085				return xerrors.Errorf("Value in field t.Spindle was too long")
6086			}
6087
6088			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Spindle))); err != nil {
6089				return err
6090			}
6091			if _, err := cw.WriteString(string(*t.Spindle)); err != nil {
6092				return err
6093			}
6094		}
6095	}
6096
6097	// t.Website (string) (string)
6098	if t.Website != nil {
6099
6100		if len("website") > 1000000 {
6101			return xerrors.Errorf("Value in field \"website\" was too long")
6102		}
6103
6104		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("website"))); err != nil {
6105			return err
6106		}
6107		if _, err := cw.WriteString(string("website")); err != nil {
6108			return err
6109		}
6110
6111		if t.Website == nil {
6112			if _, err := cw.Write(cbg.CborNull); err != nil {
6113				return err
6114			}
6115		} else {
6116			if len(*t.Website) > 1000000 {
6117				return xerrors.Errorf("Value in field t.Website was too long")
6118			}
6119
6120			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Website))); err != nil {
6121				return err
6122			}
6123			if _, err := cw.WriteString(string(*t.Website)); err != nil {
6124				return err
6125			}
6126		}
6127	}
6128
6129	// t.CreatedAt (string) (string)
6130	if len("createdAt") > 1000000 {
6131		return xerrors.Errorf("Value in field \"createdAt\" was too long")
6132	}
6133
6134	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
6135		return err
6136	}
6137	if _, err := cw.WriteString(string("createdAt")); err != nil {
6138		return err
6139	}
6140
6141	if len(t.CreatedAt) > 1000000 {
6142		return xerrors.Errorf("Value in field t.CreatedAt was too long")
6143	}
6144
6145	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
6146		return err
6147	}
6148	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
6149		return err
6150	}
6151
6152	// t.Description (string) (string)
6153	if t.Description != nil {
6154
6155		if len("description") > 1000000 {
6156			return xerrors.Errorf("Value in field \"description\" was too long")
6157		}
6158
6159		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
6160			return err
6161		}
6162		if _, err := cw.WriteString(string("description")); err != nil {
6163			return err
6164		}
6165
6166		if t.Description == nil {
6167			if _, err := cw.Write(cbg.CborNull); err != nil {
6168				return err
6169			}
6170		} else {
6171			if len(*t.Description) > 1000000 {
6172				return xerrors.Errorf("Value in field t.Description was too long")
6173			}
6174
6175			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil {
6176				return err
6177			}
6178			if _, err := cw.WriteString(string(*t.Description)); err != nil {
6179				return err
6180			}
6181		}
6182	}
6183	return nil
6184}
6185
6186func (t *Repo) UnmarshalCBOR(r io.Reader) (err error) {
6187	*t = Repo{}
6188
6189	cr := cbg.NewCborReader(r)
6190
6191	maj, extra, err := cr.ReadHeader()
6192	if err != nil {
6193		return err
6194	}
6195	defer func() {
6196		if err == io.EOF {
6197			err = io.ErrUnexpectedEOF
6198		}
6199	}()
6200
6201	if maj != cbg.MajMap {
6202		return fmt.Errorf("cbor input should be of type map")
6203	}
6204
6205	if extra > cbg.MaxLength {
6206		return fmt.Errorf("Repo: map struct too large (%d)", extra)
6207	}
6208
6209	n := extra
6210
6211	nameBuf := make([]byte, 11)
6212	for i := uint64(0); i < n; i++ {
6213		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6214		if err != nil {
6215			return err
6216		}
6217
6218		if !ok {
6219			// Field doesn't exist on this type, so ignore it
6220			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6221				return err
6222			}
6223			continue
6224		}
6225
6226		switch string(nameBuf[:nameLen]) {
6227		// t.Knot (string) (string)
6228		case "knot":
6229
6230			{
6231				sval, err := cbg.ReadStringWithMax(cr, 1000000)
6232				if err != nil {
6233					return err
6234				}
6235
6236				t.Knot = string(sval)
6237			}
6238			// t.Name (string) (string)
6239		case "name":
6240
6241			{
6242				sval, err := cbg.ReadStringWithMax(cr, 1000000)
6243				if err != nil {
6244					return err
6245				}
6246
6247				t.Name = string(sval)
6248			}
6249			// t.LexiconTypeID (string) (string)
6250		case "$type":
6251
6252			{
6253				sval, err := cbg.ReadStringWithMax(cr, 1000000)
6254				if err != nil {
6255					return err
6256				}
6257
6258				t.LexiconTypeID = string(sval)
6259			}
6260			// t.Labels ([]string) (slice)
6261		case "labels":
6262
6263			maj, extra, err = cr.ReadHeader()
6264			if err != nil {
6265				return err
6266			}
6267
6268			if extra > 8192 {
6269				return fmt.Errorf("t.Labels: array too large (%d)", extra)
6270			}
6271
6272			if maj != cbg.MajArray {
6273				return fmt.Errorf("expected cbor array")
6274			}
6275
6276			if extra > 0 {
6277				t.Labels = make([]string, extra)
6278			}
6279
6280			for i := 0; i < int(extra); i++ {
6281				{
6282					var maj byte
6283					var extra uint64
6284					var err error
6285					_ = maj
6286					_ = extra
6287					_ = err
6288
6289					{
6290						sval, err := cbg.ReadStringWithMax(cr, 1000000)
6291						if err != nil {
6292							return err
6293						}
6294
6295						t.Labels[i] = string(sval)
6296					}
6297
6298				}
6299			}
6300			// t.Source (string) (string)
6301		case "source":
6302
6303			{
6304				b, err := cr.ReadByte()
6305				if err != nil {
6306					return err
6307				}
6308				if b != cbg.CborNull[0] {
6309					if err := cr.UnreadByte(); err != nil {
6310						return err
6311					}
6312
6313					sval, err := cbg.ReadStringWithMax(cr, 1000000)
6314					if err != nil {
6315						return err
6316					}
6317
6318					t.Source = (*string)(&sval)
6319				}
6320			}
6321			// t.Topics ([]string) (slice)
6322		case "topics":
6323
6324			maj, extra, err = cr.ReadHeader()
6325			if err != nil {
6326				return err
6327			}
6328
6329			if extra > 8192 {
6330				return fmt.Errorf("t.Topics: array too large (%d)", extra)
6331			}
6332
6333			if maj != cbg.MajArray {
6334				return fmt.Errorf("expected cbor array")
6335			}
6336
6337			if extra > 0 {
6338				t.Topics = make([]string, extra)
6339			}
6340
6341			for i := 0; i < int(extra); i++ {
6342				{
6343					var maj byte
6344					var extra uint64
6345					var err error
6346					_ = maj
6347					_ = extra
6348					_ = err
6349
6350					{
6351						sval, err := cbg.ReadStringWithMax(cr, 1000000)
6352						if err != nil {
6353							return err
6354						}
6355
6356						t.Topics[i] = string(sval)
6357					}
6358
6359				}
6360			}
6361			// t.Spindle (string) (string)
6362		case "spindle":
6363
6364			{
6365				b, err := cr.ReadByte()
6366				if err != nil {
6367					return err
6368				}
6369				if b != cbg.CborNull[0] {
6370					if err := cr.UnreadByte(); err != nil {
6371						return err
6372					}
6373
6374					sval, err := cbg.ReadStringWithMax(cr, 1000000)
6375					if err != nil {
6376						return err
6377					}
6378
6379					t.Spindle = (*string)(&sval)
6380				}
6381			}
6382			// t.Website (string) (string)
6383		case "website":
6384
6385			{
6386				b, err := cr.ReadByte()
6387				if err != nil {
6388					return err
6389				}
6390				if b != cbg.CborNull[0] {
6391					if err := cr.UnreadByte(); err != nil {
6392						return err
6393					}
6394
6395					sval, err := cbg.ReadStringWithMax(cr, 1000000)
6396					if err != nil {
6397						return err
6398					}
6399
6400					t.Website = (*string)(&sval)
6401				}
6402			}
6403			// t.CreatedAt (string) (string)
6404		case "createdAt":
6405
6406			{
6407				sval, err := cbg.ReadStringWithMax(cr, 1000000)
6408				if err != nil {
6409					return err
6410				}
6411
6412				t.CreatedAt = string(sval)
6413			}
6414			// t.Description (string) (string)
6415		case "description":
6416
6417			{
6418				b, err := cr.ReadByte()
6419				if err != nil {
6420					return err
6421				}
6422				if b != cbg.CborNull[0] {
6423					if err := cr.UnreadByte(); err != nil {
6424						return err
6425					}
6426
6427					sval, err := cbg.ReadStringWithMax(cr, 1000000)
6428					if err != nil {
6429						return err
6430					}
6431
6432					t.Description = (*string)(&sval)
6433				}
6434			}
6435
6436		default:
6437			// Field doesn't exist on this type, so ignore it
6438			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6439				return err
6440			}
6441		}
6442	}
6443
6444	return nil
6445}
6446func (t *RepoArtifact) MarshalCBOR(w io.Writer) error {
6447	if t == nil {
6448		_, err := w.Write(cbg.CborNull)
6449		return err
6450	}
6451
6452	cw := cbg.NewCborWriter(w)
6453	fieldCount := 6
6454
6455	if t.Tag == nil {
6456		fieldCount--
6457	}
6458
6459	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
6460		return err
6461	}
6462
6463	// t.Tag (util.LexBytes) (slice)
6464	if t.Tag != nil {
6465
6466		if len("tag") > 1000000 {
6467			return xerrors.Errorf("Value in field \"tag\" was too long")
6468		}
6469
6470		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("tag"))); err != nil {
6471			return err
6472		}
6473		if _, err := cw.WriteString(string("tag")); err != nil {
6474			return err
6475		}
6476
6477		if len(t.Tag) > 2097152 {
6478			return xerrors.Errorf("Byte array in field t.Tag was too long")
6479		}
6480
6481		if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Tag))); err != nil {
6482			return err
6483		}
6484
6485		if _, err := cw.Write(t.Tag); err != nil {
6486			return err
6487		}
6488
6489	}
6490
6491	// t.Name (string) (string)
6492	if len("name") > 1000000 {
6493		return xerrors.Errorf("Value in field \"name\" was too long")
6494	}
6495
6496	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
6497		return err
6498	}
6499	if _, err := cw.WriteString(string("name")); err != nil {
6500		return err
6501	}
6502
6503	if len(t.Name) > 1000000 {
6504		return xerrors.Errorf("Value in field t.Name was too long")
6505	}
6506
6507	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
6508		return err
6509	}
6510	if _, err := cw.WriteString(string(t.Name)); err != nil {
6511		return err
6512	}
6513
6514	// t.Repo (string) (string)
6515	if len("repo") > 1000000 {
6516		return xerrors.Errorf("Value in field \"repo\" was too long")
6517	}
6518
6519	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
6520		return err
6521	}
6522	if _, err := cw.WriteString(string("repo")); err != nil {
6523		return err
6524	}
6525
6526	if len(t.Repo) > 1000000 {
6527		return xerrors.Errorf("Value in field t.Repo was too long")
6528	}
6529
6530	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
6531		return err
6532	}
6533	if _, err := cw.WriteString(string(t.Repo)); err != nil {
6534		return err
6535	}
6536
6537	// t.LexiconTypeID (string) (string)
6538	if len("$type") > 1000000 {
6539		return xerrors.Errorf("Value in field \"$type\" was too long")
6540	}
6541
6542	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6543		return err
6544	}
6545	if _, err := cw.WriteString(string("$type")); err != nil {
6546		return err
6547	}
6548
6549	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.artifact"))); err != nil {
6550		return err
6551	}
6552	if _, err := cw.WriteString(string("sh.tangled.repo.artifact")); err != nil {
6553		return err
6554	}
6555
6556	// t.Artifact (util.LexBlob) (struct)
6557	if len("artifact") > 1000000 {
6558		return xerrors.Errorf("Value in field \"artifact\" was too long")
6559	}
6560
6561	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("artifact"))); err != nil {
6562		return err
6563	}
6564	if _, err := cw.WriteString(string("artifact")); err != nil {
6565		return err
6566	}
6567
6568	if err := t.Artifact.MarshalCBOR(cw); err != nil {
6569		return err
6570	}
6571
6572	// t.CreatedAt (string) (string)
6573	if len("createdAt") > 1000000 {
6574		return xerrors.Errorf("Value in field \"createdAt\" was too long")
6575	}
6576
6577	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
6578		return err
6579	}
6580	if _, err := cw.WriteString(string("createdAt")); err != nil {
6581		return err
6582	}
6583
6584	if len(t.CreatedAt) > 1000000 {
6585		return xerrors.Errorf("Value in field t.CreatedAt was too long")
6586	}
6587
6588	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
6589		return err
6590	}
6591	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
6592		return err
6593	}
6594	return nil
6595}
6596
6597func (t *RepoArtifact) UnmarshalCBOR(r io.Reader) (err error) {
6598	*t = RepoArtifact{}
6599
6600	cr := cbg.NewCborReader(r)
6601
6602	maj, extra, err := cr.ReadHeader()
6603	if err != nil {
6604		return err
6605	}
6606	defer func() {
6607		if err == io.EOF {
6608			err = io.ErrUnexpectedEOF
6609		}
6610	}()
6611
6612	if maj != cbg.MajMap {
6613		return fmt.Errorf("cbor input should be of type map")
6614	}
6615
6616	if extra > cbg.MaxLength {
6617		return fmt.Errorf("RepoArtifact: map struct too large (%d)", extra)
6618	}
6619
6620	n := extra
6621
6622	nameBuf := make([]byte, 9)
6623	for i := uint64(0); i < n; i++ {
6624		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6625		if err != nil {
6626			return err
6627		}
6628
6629		if !ok {
6630			// Field doesn't exist on this type, so ignore it
6631			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6632				return err
6633			}
6634			continue
6635		}
6636
6637		switch string(nameBuf[:nameLen]) {
6638		// t.Tag (util.LexBytes) (slice)
6639		case "tag":
6640
6641			maj, extra, err = cr.ReadHeader()
6642			if err != nil {
6643				return err
6644			}
6645
6646			if extra > 2097152 {
6647				return fmt.Errorf("t.Tag: byte array too large (%d)", extra)
6648			}
6649			if maj != cbg.MajByteString {
6650				return fmt.Errorf("expected byte array")
6651			}
6652
6653			if extra > 0 {
6654				t.Tag = make([]uint8, extra)
6655			}
6656
6657			if _, err := io.ReadFull(cr, t.Tag); err != nil {
6658				return err
6659			}
6660
6661			// t.Name (string) (string)
6662		case "name":
6663
6664			{
6665				sval, err := cbg.ReadStringWithMax(cr, 1000000)
6666				if err != nil {
6667					return err
6668				}
6669
6670				t.Name = string(sval)
6671			}
6672			// t.Repo (string) (string)
6673		case "repo":
6674
6675			{
6676				sval, err := cbg.ReadStringWithMax(cr, 1000000)
6677				if err != nil {
6678					return err
6679				}
6680
6681				t.Repo = string(sval)
6682			}
6683			// t.LexiconTypeID (string) (string)
6684		case "$type":
6685
6686			{
6687				sval, err := cbg.ReadStringWithMax(cr, 1000000)
6688				if err != nil {
6689					return err
6690				}
6691
6692				t.LexiconTypeID = string(sval)
6693			}
6694			// t.Artifact (util.LexBlob) (struct)
6695		case "artifact":
6696
6697			{
6698
6699				b, err := cr.ReadByte()
6700				if err != nil {
6701					return err
6702				}
6703				if b != cbg.CborNull[0] {
6704					if err := cr.UnreadByte(); err != nil {
6705						return err
6706					}
6707					t.Artifact = new(util.LexBlob)
6708					if err := t.Artifact.UnmarshalCBOR(cr); err != nil {
6709						return xerrors.Errorf("unmarshaling t.Artifact pointer: %w", err)
6710					}
6711				}
6712
6713			}
6714			// t.CreatedAt (string) (string)
6715		case "createdAt":
6716
6717			{
6718				sval, err := cbg.ReadStringWithMax(cr, 1000000)
6719				if err != nil {
6720					return err
6721				}
6722
6723				t.CreatedAt = string(sval)
6724			}
6725
6726		default:
6727			// Field doesn't exist on this type, so ignore it
6728			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6729				return err
6730			}
6731		}
6732	}
6733
6734	return nil
6735}
6736func (t *RepoCollaborator) MarshalCBOR(w io.Writer) error {
6737	if t == nil {
6738		_, err := w.Write(cbg.CborNull)
6739		return err
6740	}
6741
6742	cw := cbg.NewCborWriter(w)
6743
6744	if _, err := cw.Write([]byte{164}); err != nil {
6745		return err
6746	}
6747
6748	// t.Repo (string) (string)
6749	if len("repo") > 1000000 {
6750		return xerrors.Errorf("Value in field \"repo\" was too long")
6751	}
6752
6753	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
6754		return err
6755	}
6756	if _, err := cw.WriteString(string("repo")); err != nil {
6757		return err
6758	}
6759
6760	if len(t.Repo) > 1000000 {
6761		return xerrors.Errorf("Value in field t.Repo was too long")
6762	}
6763
6764	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
6765		return err
6766	}
6767	if _, err := cw.WriteString(string(t.Repo)); err != nil {
6768		return err
6769	}
6770
6771	// t.LexiconTypeID (string) (string)
6772	if len("$type") > 1000000 {
6773		return xerrors.Errorf("Value in field \"$type\" was too long")
6774	}
6775
6776	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
6777		return err
6778	}
6779	if _, err := cw.WriteString(string("$type")); err != nil {
6780		return err
6781	}
6782
6783	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.collaborator"))); err != nil {
6784		return err
6785	}
6786	if _, err := cw.WriteString(string("sh.tangled.repo.collaborator")); err != nil {
6787		return err
6788	}
6789
6790	// t.Subject (string) (string)
6791	if len("subject") > 1000000 {
6792		return xerrors.Errorf("Value in field \"subject\" was too long")
6793	}
6794
6795	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
6796		return err
6797	}
6798	if _, err := cw.WriteString(string("subject")); err != nil {
6799		return err
6800	}
6801
6802	if len(t.Subject) > 1000000 {
6803		return xerrors.Errorf("Value in field t.Subject was too long")
6804	}
6805
6806	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
6807		return err
6808	}
6809	if _, err := cw.WriteString(string(t.Subject)); err != nil {
6810		return err
6811	}
6812
6813	// t.CreatedAt (string) (string)
6814	if len("createdAt") > 1000000 {
6815		return xerrors.Errorf("Value in field \"createdAt\" was too long")
6816	}
6817
6818	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
6819		return err
6820	}
6821	if _, err := cw.WriteString(string("createdAt")); err != nil {
6822		return err
6823	}
6824
6825	if len(t.CreatedAt) > 1000000 {
6826		return xerrors.Errorf("Value in field t.CreatedAt was too long")
6827	}
6828
6829	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
6830		return err
6831	}
6832	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
6833		return err
6834	}
6835	return nil
6836}
6837
6838func (t *RepoCollaborator) UnmarshalCBOR(r io.Reader) (err error) {
6839	*t = RepoCollaborator{}
6840
6841	cr := cbg.NewCborReader(r)
6842
6843	maj, extra, err := cr.ReadHeader()
6844	if err != nil {
6845		return err
6846	}
6847	defer func() {
6848		if err == io.EOF {
6849			err = io.ErrUnexpectedEOF
6850		}
6851	}()
6852
6853	if maj != cbg.MajMap {
6854		return fmt.Errorf("cbor input should be of type map")
6855	}
6856
6857	if extra > cbg.MaxLength {
6858		return fmt.Errorf("RepoCollaborator: map struct too large (%d)", extra)
6859	}
6860
6861	n := extra
6862
6863	nameBuf := make([]byte, 9)
6864	for i := uint64(0); i < n; i++ {
6865		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6866		if err != nil {
6867			return err
6868		}
6869
6870		if !ok {
6871			// Field doesn't exist on this type, so ignore it
6872			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6873				return err
6874			}
6875			continue
6876		}
6877
6878		switch string(nameBuf[:nameLen]) {
6879		// t.Repo (string) (string)
6880		case "repo":
6881
6882			{
6883				sval, err := cbg.ReadStringWithMax(cr, 1000000)
6884				if err != nil {
6885					return err
6886				}
6887
6888				t.Repo = string(sval)
6889			}
6890			// t.LexiconTypeID (string) (string)
6891		case "$type":
6892
6893			{
6894				sval, err := cbg.ReadStringWithMax(cr, 1000000)
6895				if err != nil {
6896					return err
6897				}
6898
6899				t.LexiconTypeID = string(sval)
6900			}
6901			// t.Subject (string) (string)
6902		case "subject":
6903
6904			{
6905				sval, err := cbg.ReadStringWithMax(cr, 1000000)
6906				if err != nil {
6907					return err
6908				}
6909
6910				t.Subject = string(sval)
6911			}
6912			// t.CreatedAt (string) (string)
6913		case "createdAt":
6914
6915			{
6916				sval, err := cbg.ReadStringWithMax(cr, 1000000)
6917				if err != nil {
6918					return err
6919				}
6920
6921				t.CreatedAt = string(sval)
6922			}
6923
6924		default:
6925			// Field doesn't exist on this type, so ignore it
6926			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6927				return err
6928			}
6929		}
6930	}
6931
6932	return nil
6933}
6934func (t *RepoIssue) MarshalCBOR(w io.Writer) error {
6935	if t == nil {
6936		_, err := w.Write(cbg.CborNull)
6937		return err
6938	}
6939
6940	cw := cbg.NewCborWriter(w)
6941	fieldCount := 7
6942
6943	if t.Body == nil {
6944		fieldCount--
6945	}
6946
6947	if t.Mentions == nil {
6948		fieldCount--
6949	}
6950
6951	if t.References == nil {
6952		fieldCount--
6953	}
6954
6955	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
6956		return err
6957	}
6958
6959	// t.Body (string) (string)
6960	if t.Body != nil {
6961
6962		if len("body") > 1000000 {
6963			return xerrors.Errorf("Value in field \"body\" was too long")
6964		}
6965
6966		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
6967			return err
6968		}
6969		if _, err := cw.WriteString(string("body")); err != nil {
6970			return err
6971		}
6972
6973		if t.Body == nil {
6974			if _, err := cw.Write(cbg.CborNull); err != nil {
6975				return err
6976			}
6977		} else {
6978			if len(*t.Body) > 1000000 {
6979				return xerrors.Errorf("Value in field t.Body was too long")
6980			}
6981
6982			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {
6983				return err
6984			}
6985			if _, err := cw.WriteString(string(*t.Body)); err != nil {
6986				return err
6987			}
6988		}
6989	}
6990
6991	// t.Repo (string) (string)
6992	if len("repo") > 1000000 {
6993		return xerrors.Errorf("Value in field \"repo\" was too long")
6994	}
6995
6996	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
6997		return err
6998	}
6999	if _, err := cw.WriteString(string("repo")); err != nil {
7000		return err
7001	}
7002
7003	if len(t.Repo) > 1000000 {
7004		return xerrors.Errorf("Value in field t.Repo was too long")
7005	}
7006
7007	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
7008		return err
7009	}
7010	if _, err := cw.WriteString(string(t.Repo)); err != nil {
7011		return err
7012	}
7013
7014	// t.LexiconTypeID (string) (string)
7015	if len("$type") > 1000000 {
7016		return xerrors.Errorf("Value in field \"$type\" was too long")
7017	}
7018
7019	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7020		return err
7021	}
7022	if _, err := cw.WriteString(string("$type")); err != nil {
7023		return err
7024	}
7025
7026	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue"))); err != nil {
7027		return err
7028	}
7029	if _, err := cw.WriteString(string("sh.tangled.repo.issue")); err != nil {
7030		return err
7031	}
7032
7033	// t.Title (string) (string)
7034	if len("title") > 1000000 {
7035		return xerrors.Errorf("Value in field \"title\" was too long")
7036	}
7037
7038	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil {
7039		return err
7040	}
7041	if _, err := cw.WriteString(string("title")); err != nil {
7042		return err
7043	}
7044
7045	if len(t.Title) > 1000000 {
7046		return xerrors.Errorf("Value in field t.Title was too long")
7047	}
7048
7049	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil {
7050		return err
7051	}
7052	if _, err := cw.WriteString(string(t.Title)); err != nil {
7053		return err
7054	}
7055
7056	// t.Mentions ([]string) (slice)
7057	if t.Mentions != nil {
7058
7059		if len("mentions") > 1000000 {
7060			return xerrors.Errorf("Value in field \"mentions\" was too long")
7061		}
7062
7063		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("mentions"))); err != nil {
7064			return err
7065		}
7066		if _, err := cw.WriteString(string("mentions")); err != nil {
7067			return err
7068		}
7069
7070		if len(t.Mentions) > 8192 {
7071			return xerrors.Errorf("Slice value in field t.Mentions was too long")
7072		}
7073
7074		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {
7075			return err
7076		}
7077		for _, v := range t.Mentions {
7078			if len(v) > 1000000 {
7079				return xerrors.Errorf("Value in field v was too long")
7080			}
7081
7082			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
7083				return err
7084			}
7085			if _, err := cw.WriteString(string(v)); err != nil {
7086				return err
7087			}
7088
7089		}
7090	}
7091
7092	// t.CreatedAt (string) (string)
7093	if len("createdAt") > 1000000 {
7094		return xerrors.Errorf("Value in field \"createdAt\" was too long")
7095	}
7096
7097	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
7098		return err
7099	}
7100	if _, err := cw.WriteString(string("createdAt")); err != nil {
7101		return err
7102	}
7103
7104	if len(t.CreatedAt) > 1000000 {
7105		return xerrors.Errorf("Value in field t.CreatedAt was too long")
7106	}
7107
7108	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
7109		return err
7110	}
7111	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7112		return err
7113	}
7114
7115	// t.References ([]string) (slice)
7116	if t.References != nil {
7117
7118		if len("references") > 1000000 {
7119			return xerrors.Errorf("Value in field \"references\" was too long")
7120		}
7121
7122		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("references"))); err != nil {
7123			return err
7124		}
7125		if _, err := cw.WriteString(string("references")); err != nil {
7126			return err
7127		}
7128
7129		if len(t.References) > 8192 {
7130			return xerrors.Errorf("Slice value in field t.References was too long")
7131		}
7132
7133		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {
7134			return err
7135		}
7136		for _, v := range t.References {
7137			if len(v) > 1000000 {
7138				return xerrors.Errorf("Value in field v was too long")
7139			}
7140
7141			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
7142				return err
7143			}
7144			if _, err := cw.WriteString(string(v)); err != nil {
7145				return err
7146			}
7147
7148		}
7149	}
7150	return nil
7151}
7152
7153func (t *RepoIssue) UnmarshalCBOR(r io.Reader) (err error) {
7154	*t = RepoIssue{}
7155
7156	cr := cbg.NewCborReader(r)
7157
7158	maj, extra, err := cr.ReadHeader()
7159	if err != nil {
7160		return err
7161	}
7162	defer func() {
7163		if err == io.EOF {
7164			err = io.ErrUnexpectedEOF
7165		}
7166	}()
7167
7168	if maj != cbg.MajMap {
7169		return fmt.Errorf("cbor input should be of type map")
7170	}
7171
7172	if extra > cbg.MaxLength {
7173		return fmt.Errorf("RepoIssue: map struct too large (%d)", extra)
7174	}
7175
7176	n := extra
7177
7178	nameBuf := make([]byte, 10)
7179	for i := uint64(0); i < n; i++ {
7180		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7181		if err != nil {
7182			return err
7183		}
7184
7185		if !ok {
7186			// Field doesn't exist on this type, so ignore it
7187			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7188				return err
7189			}
7190			continue
7191		}
7192
7193		switch string(nameBuf[:nameLen]) {
7194		// t.Body (string) (string)
7195		case "body":
7196
7197			{
7198				b, err := cr.ReadByte()
7199				if err != nil {
7200					return err
7201				}
7202				if b != cbg.CborNull[0] {
7203					if err := cr.UnreadByte(); err != nil {
7204						return err
7205					}
7206
7207					sval, err := cbg.ReadStringWithMax(cr, 1000000)
7208					if err != nil {
7209						return err
7210					}
7211
7212					t.Body = (*string)(&sval)
7213				}
7214			}
7215			// t.Repo (string) (string)
7216		case "repo":
7217
7218			{
7219				sval, err := cbg.ReadStringWithMax(cr, 1000000)
7220				if err != nil {
7221					return err
7222				}
7223
7224				t.Repo = string(sval)
7225			}
7226			// t.LexiconTypeID (string) (string)
7227		case "$type":
7228
7229			{
7230				sval, err := cbg.ReadStringWithMax(cr, 1000000)
7231				if err != nil {
7232					return err
7233				}
7234
7235				t.LexiconTypeID = string(sval)
7236			}
7237			// t.Title (string) (string)
7238		case "title":
7239
7240			{
7241				sval, err := cbg.ReadStringWithMax(cr, 1000000)
7242				if err != nil {
7243					return err
7244				}
7245
7246				t.Title = string(sval)
7247			}
7248			// t.Mentions ([]string) (slice)
7249		case "mentions":
7250
7251			maj, extra, err = cr.ReadHeader()
7252			if err != nil {
7253				return err
7254			}
7255
7256			if extra > 8192 {
7257				return fmt.Errorf("t.Mentions: array too large (%d)", extra)
7258			}
7259
7260			if maj != cbg.MajArray {
7261				return fmt.Errorf("expected cbor array")
7262			}
7263
7264			if extra > 0 {
7265				t.Mentions = make([]string, extra)
7266			}
7267
7268			for i := 0; i < int(extra); i++ {
7269				{
7270					var maj byte
7271					var extra uint64
7272					var err error
7273					_ = maj
7274					_ = extra
7275					_ = err
7276
7277					{
7278						sval, err := cbg.ReadStringWithMax(cr, 1000000)
7279						if err != nil {
7280							return err
7281						}
7282
7283						t.Mentions[i] = string(sval)
7284					}
7285
7286				}
7287			}
7288			// t.CreatedAt (string) (string)
7289		case "createdAt":
7290
7291			{
7292				sval, err := cbg.ReadStringWithMax(cr, 1000000)
7293				if err != nil {
7294					return err
7295				}
7296
7297				t.CreatedAt = string(sval)
7298			}
7299			// t.References ([]string) (slice)
7300		case "references":
7301
7302			maj, extra, err = cr.ReadHeader()
7303			if err != nil {
7304				return err
7305			}
7306
7307			if extra > 8192 {
7308				return fmt.Errorf("t.References: array too large (%d)", extra)
7309			}
7310
7311			if maj != cbg.MajArray {
7312				return fmt.Errorf("expected cbor array")
7313			}
7314
7315			if extra > 0 {
7316				t.References = make([]string, extra)
7317			}
7318
7319			for i := 0; i < int(extra); i++ {
7320				{
7321					var maj byte
7322					var extra uint64
7323					var err error
7324					_ = maj
7325					_ = extra
7326					_ = err
7327
7328					{
7329						sval, err := cbg.ReadStringWithMax(cr, 1000000)
7330						if err != nil {
7331							return err
7332						}
7333
7334						t.References[i] = string(sval)
7335					}
7336
7337				}
7338			}
7339
7340		default:
7341			// Field doesn't exist on this type, so ignore it
7342			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7343				return err
7344			}
7345		}
7346	}
7347
7348	return nil
7349}
7350func (t *RepoIssueComment) MarshalCBOR(w io.Writer) error {
7351	if t == nil {
7352		_, err := w.Write(cbg.CborNull)
7353		return err
7354	}
7355
7356	cw := cbg.NewCborWriter(w)
7357	fieldCount := 7
7358
7359	if t.Mentions == nil {
7360		fieldCount--
7361	}
7362
7363	if t.References == nil {
7364		fieldCount--
7365	}
7366
7367	if t.ReplyTo == nil {
7368		fieldCount--
7369	}
7370
7371	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
7372		return err
7373	}
7374
7375	// t.Body (string) (string)
7376	if len("body") > 1000000 {
7377		return xerrors.Errorf("Value in field \"body\" was too long")
7378	}
7379
7380	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
7381		return err
7382	}
7383	if _, err := cw.WriteString(string("body")); err != nil {
7384		return err
7385	}
7386
7387	if len(t.Body) > 1000000 {
7388		return xerrors.Errorf("Value in field t.Body was too long")
7389	}
7390
7391	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil {
7392		return err
7393	}
7394	if _, err := cw.WriteString(string(t.Body)); err != nil {
7395		return err
7396	}
7397
7398	// t.LexiconTypeID (string) (string)
7399	if len("$type") > 1000000 {
7400		return xerrors.Errorf("Value in field \"$type\" was too long")
7401	}
7402
7403	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7404		return err
7405	}
7406	if _, err := cw.WriteString(string("$type")); err != nil {
7407		return err
7408	}
7409
7410	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.comment"))); err != nil {
7411		return err
7412	}
7413	if _, err := cw.WriteString(string("sh.tangled.repo.issue.comment")); err != nil {
7414		return err
7415	}
7416
7417	// t.Issue (string) (string)
7418	if len("issue") > 1000000 {
7419		return xerrors.Errorf("Value in field \"issue\" was too long")
7420	}
7421
7422	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil {
7423		return err
7424	}
7425	if _, err := cw.WriteString(string("issue")); err != nil {
7426		return err
7427	}
7428
7429	if len(t.Issue) > 1000000 {
7430		return xerrors.Errorf("Value in field t.Issue was too long")
7431	}
7432
7433	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil {
7434		return err
7435	}
7436	if _, err := cw.WriteString(string(t.Issue)); err != nil {
7437		return err
7438	}
7439
7440	// t.ReplyTo (string) (string)
7441	if t.ReplyTo != nil {
7442
7443		if len("replyTo") > 1000000 {
7444			return xerrors.Errorf("Value in field \"replyTo\" was too long")
7445		}
7446
7447		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("replyTo"))); err != nil {
7448			return err
7449		}
7450		if _, err := cw.WriteString(string("replyTo")); err != nil {
7451			return err
7452		}
7453
7454		if t.ReplyTo == nil {
7455			if _, err := cw.Write(cbg.CborNull); err != nil {
7456				return err
7457			}
7458		} else {
7459			if len(*t.ReplyTo) > 1000000 {
7460				return xerrors.Errorf("Value in field t.ReplyTo was too long")
7461			}
7462
7463			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.ReplyTo))); err != nil {
7464				return err
7465			}
7466			if _, err := cw.WriteString(string(*t.ReplyTo)); err != nil {
7467				return err
7468			}
7469		}
7470	}
7471
7472	// t.Mentions ([]string) (slice)
7473	if t.Mentions != nil {
7474
7475		if len("mentions") > 1000000 {
7476			return xerrors.Errorf("Value in field \"mentions\" was too long")
7477		}
7478
7479		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("mentions"))); err != nil {
7480			return err
7481		}
7482		if _, err := cw.WriteString(string("mentions")); err != nil {
7483			return err
7484		}
7485
7486		if len(t.Mentions) > 8192 {
7487			return xerrors.Errorf("Slice value in field t.Mentions was too long")
7488		}
7489
7490		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {
7491			return err
7492		}
7493		for _, v := range t.Mentions {
7494			if len(v) > 1000000 {
7495				return xerrors.Errorf("Value in field v was too long")
7496			}
7497
7498			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
7499				return err
7500			}
7501			if _, err := cw.WriteString(string(v)); err != nil {
7502				return err
7503			}
7504
7505		}
7506	}
7507
7508	// t.CreatedAt (string) (string)
7509	if len("createdAt") > 1000000 {
7510		return xerrors.Errorf("Value in field \"createdAt\" was too long")
7511	}
7512
7513	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
7514		return err
7515	}
7516	if _, err := cw.WriteString(string("createdAt")); err != nil {
7517		return err
7518	}
7519
7520	if len(t.CreatedAt) > 1000000 {
7521		return xerrors.Errorf("Value in field t.CreatedAt was too long")
7522	}
7523
7524	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
7525		return err
7526	}
7527	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7528		return err
7529	}
7530
7531	// t.References ([]string) (slice)
7532	if t.References != nil {
7533
7534		if len("references") > 1000000 {
7535			return xerrors.Errorf("Value in field \"references\" was too long")
7536		}
7537
7538		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("references"))); err != nil {
7539			return err
7540		}
7541		if _, err := cw.WriteString(string("references")); err != nil {
7542			return err
7543		}
7544
7545		if len(t.References) > 8192 {
7546			return xerrors.Errorf("Slice value in field t.References was too long")
7547		}
7548
7549		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {
7550			return err
7551		}
7552		for _, v := range t.References {
7553			if len(v) > 1000000 {
7554				return xerrors.Errorf("Value in field v was too long")
7555			}
7556
7557			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
7558				return err
7559			}
7560			if _, err := cw.WriteString(string(v)); err != nil {
7561				return err
7562			}
7563
7564		}
7565	}
7566	return nil
7567}
7568
7569func (t *RepoIssueComment) UnmarshalCBOR(r io.Reader) (err error) {
7570	*t = RepoIssueComment{}
7571
7572	cr := cbg.NewCborReader(r)
7573
7574	maj, extra, err := cr.ReadHeader()
7575	if err != nil {
7576		return err
7577	}
7578	defer func() {
7579		if err == io.EOF {
7580			err = io.ErrUnexpectedEOF
7581		}
7582	}()
7583
7584	if maj != cbg.MajMap {
7585		return fmt.Errorf("cbor input should be of type map")
7586	}
7587
7588	if extra > cbg.MaxLength {
7589		return fmt.Errorf("RepoIssueComment: map struct too large (%d)", extra)
7590	}
7591
7592	n := extra
7593
7594	nameBuf := make([]byte, 10)
7595	for i := uint64(0); i < n; i++ {
7596		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7597		if err != nil {
7598			return err
7599		}
7600
7601		if !ok {
7602			// Field doesn't exist on this type, so ignore it
7603			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7604				return err
7605			}
7606			continue
7607		}
7608
7609		switch string(nameBuf[:nameLen]) {
7610		// t.Body (string) (string)
7611		case "body":
7612
7613			{
7614				sval, err := cbg.ReadStringWithMax(cr, 1000000)
7615				if err != nil {
7616					return err
7617				}
7618
7619				t.Body = string(sval)
7620			}
7621			// t.LexiconTypeID (string) (string)
7622		case "$type":
7623
7624			{
7625				sval, err := cbg.ReadStringWithMax(cr, 1000000)
7626				if err != nil {
7627					return err
7628				}
7629
7630				t.LexiconTypeID = string(sval)
7631			}
7632			// t.Issue (string) (string)
7633		case "issue":
7634
7635			{
7636				sval, err := cbg.ReadStringWithMax(cr, 1000000)
7637				if err != nil {
7638					return err
7639				}
7640
7641				t.Issue = string(sval)
7642			}
7643			// t.ReplyTo (string) (string)
7644		case "replyTo":
7645
7646			{
7647				b, err := cr.ReadByte()
7648				if err != nil {
7649					return err
7650				}
7651				if b != cbg.CborNull[0] {
7652					if err := cr.UnreadByte(); err != nil {
7653						return err
7654					}
7655
7656					sval, err := cbg.ReadStringWithMax(cr, 1000000)
7657					if err != nil {
7658						return err
7659					}
7660
7661					t.ReplyTo = (*string)(&sval)
7662				}
7663			}
7664			// t.Mentions ([]string) (slice)
7665		case "mentions":
7666
7667			maj, extra, err = cr.ReadHeader()
7668			if err != nil {
7669				return err
7670			}
7671
7672			if extra > 8192 {
7673				return fmt.Errorf("t.Mentions: array too large (%d)", extra)
7674			}
7675
7676			if maj != cbg.MajArray {
7677				return fmt.Errorf("expected cbor array")
7678			}
7679
7680			if extra > 0 {
7681				t.Mentions = make([]string, extra)
7682			}
7683
7684			for i := 0; i < int(extra); i++ {
7685				{
7686					var maj byte
7687					var extra uint64
7688					var err error
7689					_ = maj
7690					_ = extra
7691					_ = err
7692
7693					{
7694						sval, err := cbg.ReadStringWithMax(cr, 1000000)
7695						if err != nil {
7696							return err
7697						}
7698
7699						t.Mentions[i] = string(sval)
7700					}
7701
7702				}
7703			}
7704			// t.CreatedAt (string) (string)
7705		case "createdAt":
7706
7707			{
7708				sval, err := cbg.ReadStringWithMax(cr, 1000000)
7709				if err != nil {
7710					return err
7711				}
7712
7713				t.CreatedAt = string(sval)
7714			}
7715			// t.References ([]string) (slice)
7716		case "references":
7717
7718			maj, extra, err = cr.ReadHeader()
7719			if err != nil {
7720				return err
7721			}
7722
7723			if extra > 8192 {
7724				return fmt.Errorf("t.References: array too large (%d)", extra)
7725			}
7726
7727			if maj != cbg.MajArray {
7728				return fmt.Errorf("expected cbor array")
7729			}
7730
7731			if extra > 0 {
7732				t.References = make([]string, extra)
7733			}
7734
7735			for i := 0; i < int(extra); i++ {
7736				{
7737					var maj byte
7738					var extra uint64
7739					var err error
7740					_ = maj
7741					_ = extra
7742					_ = err
7743
7744					{
7745						sval, err := cbg.ReadStringWithMax(cr, 1000000)
7746						if err != nil {
7747							return err
7748						}
7749
7750						t.References[i] = string(sval)
7751					}
7752
7753				}
7754			}
7755
7756		default:
7757			// Field doesn't exist on this type, so ignore it
7758			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7759				return err
7760			}
7761		}
7762	}
7763
7764	return nil
7765}
7766func (t *RepoIssueState) MarshalCBOR(w io.Writer) error {
7767	if t == nil {
7768		_, err := w.Write(cbg.CborNull)
7769		return err
7770	}
7771
7772	cw := cbg.NewCborWriter(w)
7773
7774	if _, err := cw.Write([]byte{163}); err != nil {
7775		return err
7776	}
7777
7778	// t.LexiconTypeID (string) (string)
7779	if len("$type") > 1000000 {
7780		return xerrors.Errorf("Value in field \"$type\" was too long")
7781	}
7782
7783	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7784		return err
7785	}
7786	if _, err := cw.WriteString(string("$type")); err != nil {
7787		return err
7788	}
7789
7790	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue.state"))); err != nil {
7791		return err
7792	}
7793	if _, err := cw.WriteString(string("sh.tangled.repo.issue.state")); err != nil {
7794		return err
7795	}
7796
7797	// t.Issue (string) (string)
7798	if len("issue") > 1000000 {
7799		return xerrors.Errorf("Value in field \"issue\" was too long")
7800	}
7801
7802	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issue"))); err != nil {
7803		return err
7804	}
7805	if _, err := cw.WriteString(string("issue")); err != nil {
7806		return err
7807	}
7808
7809	if len(t.Issue) > 1000000 {
7810		return xerrors.Errorf("Value in field t.Issue was too long")
7811	}
7812
7813	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Issue))); err != nil {
7814		return err
7815	}
7816	if _, err := cw.WriteString(string(t.Issue)); err != nil {
7817		return err
7818	}
7819
7820	// t.State (string) (string)
7821	if len("state") > 1000000 {
7822		return xerrors.Errorf("Value in field \"state\" was too long")
7823	}
7824
7825	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("state"))); err != nil {
7826		return err
7827	}
7828	if _, err := cw.WriteString(string("state")); err != nil {
7829		return err
7830	}
7831
7832	if len(t.State) > 1000000 {
7833		return xerrors.Errorf("Value in field t.State was too long")
7834	}
7835
7836	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.State))); err != nil {
7837		return err
7838	}
7839	if _, err := cw.WriteString(string(t.State)); err != nil {
7840		return err
7841	}
7842	return nil
7843}
7844
7845func (t *RepoIssueState) UnmarshalCBOR(r io.Reader) (err error) {
7846	*t = RepoIssueState{}
7847
7848	cr := cbg.NewCborReader(r)
7849
7850	maj, extra, err := cr.ReadHeader()
7851	if err != nil {
7852		return err
7853	}
7854	defer func() {
7855		if err == io.EOF {
7856			err = io.ErrUnexpectedEOF
7857		}
7858	}()
7859
7860	if maj != cbg.MajMap {
7861		return fmt.Errorf("cbor input should be of type map")
7862	}
7863
7864	if extra > cbg.MaxLength {
7865		return fmt.Errorf("RepoIssueState: map struct too large (%d)", extra)
7866	}
7867
7868	n := extra
7869
7870	nameBuf := make([]byte, 5)
7871	for i := uint64(0); i < n; i++ {
7872		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
7873		if err != nil {
7874			return err
7875		}
7876
7877		if !ok {
7878			// Field doesn't exist on this type, so ignore it
7879			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
7880				return err
7881			}
7882			continue
7883		}
7884
7885		switch string(nameBuf[:nameLen]) {
7886		// t.LexiconTypeID (string) (string)
7887		case "$type":
7888
7889			{
7890				sval, err := cbg.ReadStringWithMax(cr, 1000000)
7891				if err != nil {
7892					return err
7893				}
7894
7895				t.LexiconTypeID = string(sval)
7896			}
7897			// t.Issue (string) (string)
7898		case "issue":
7899
7900			{
7901				sval, err := cbg.ReadStringWithMax(cr, 1000000)
7902				if err != nil {
7903					return err
7904				}
7905
7906				t.Issue = string(sval)
7907			}
7908			// t.State (string) (string)
7909		case "state":
7910
7911			{
7912				sval, err := cbg.ReadStringWithMax(cr, 1000000)
7913				if err != nil {
7914					return err
7915				}
7916
7917				t.State = string(sval)
7918			}
7919
7920		default:
7921			// Field doesn't exist on this type, so ignore it
7922			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
7923				return err
7924			}
7925		}
7926	}
7927
7928	return nil
7929}
7930func (t *RepoPull) MarshalCBOR(w io.Writer) error {
7931	if t == nil {
7932		_, err := w.Write(cbg.CborNull)
7933		return err
7934	}
7935
7936	cw := cbg.NewCborWriter(w)
7937	fieldCount := 9
7938
7939	if t.Body == nil {
7940		fieldCount--
7941	}
7942
7943	if t.Mentions == nil {
7944		fieldCount--
7945	}
7946
7947	if t.References == nil {
7948		fieldCount--
7949	}
7950
7951	if t.Source == nil {
7952		fieldCount--
7953	}
7954
7955	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
7956		return err
7957	}
7958
7959	// t.Body (string) (string)
7960	if t.Body != nil {
7961
7962		if len("body") > 1000000 {
7963			return xerrors.Errorf("Value in field \"body\" was too long")
7964		}
7965
7966		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
7967			return err
7968		}
7969		if _, err := cw.WriteString(string("body")); err != nil {
7970			return err
7971		}
7972
7973		if t.Body == nil {
7974			if _, err := cw.Write(cbg.CborNull); err != nil {
7975				return err
7976			}
7977		} else {
7978			if len(*t.Body) > 1000000 {
7979				return xerrors.Errorf("Value in field t.Body was too long")
7980			}
7981
7982			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {
7983				return err
7984			}
7985			if _, err := cw.WriteString(string(*t.Body)); err != nil {
7986				return err
7987			}
7988		}
7989	}
7990
7991	// t.LexiconTypeID (string) (string)
7992	if len("$type") > 1000000 {
7993		return xerrors.Errorf("Value in field \"$type\" was too long")
7994	}
7995
7996	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
7997		return err
7998	}
7999	if _, err := cw.WriteString(string("$type")); err != nil {
8000		return err
8001	}
8002
8003	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull"))); err != nil {
8004		return err
8005	}
8006	if _, err := cw.WriteString(string("sh.tangled.repo.pull")); err != nil {
8007		return err
8008	}
8009
8010	// t.Patch (string) (string)
8011	if len("patch") > 1000000 {
8012		return xerrors.Errorf("Value in field \"patch\" was too long")
8013	}
8014
8015	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("patch"))); err != nil {
8016		return err
8017	}
8018	if _, err := cw.WriteString(string("patch")); err != nil {
8019		return err
8020	}
8021
8022	if len(t.Patch) > 1000000 {
8023		return xerrors.Errorf("Value in field t.Patch was too long")
8024	}
8025
8026	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Patch))); err != nil {
8027		return err
8028	}
8029	if _, err := cw.WriteString(string(t.Patch)); err != nil {
8030		return err
8031	}
8032
8033	// t.Title (string) (string)
8034	if len("title") > 1000000 {
8035		return xerrors.Errorf("Value in field \"title\" was too long")
8036	}
8037
8038	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil {
8039		return err
8040	}
8041	if _, err := cw.WriteString(string("title")); err != nil {
8042		return err
8043	}
8044
8045	if len(t.Title) > 1000000 {
8046		return xerrors.Errorf("Value in field t.Title was too long")
8047	}
8048
8049	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil {
8050		return err
8051	}
8052	if _, err := cw.WriteString(string(t.Title)); err != nil {
8053		return err
8054	}
8055
8056	// t.Source (tangled.RepoPull_Source) (struct)
8057	if t.Source != nil {
8058
8059		if len("source") > 1000000 {
8060			return xerrors.Errorf("Value in field \"source\" was too long")
8061		}
8062
8063		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil {
8064			return err
8065		}
8066		if _, err := cw.WriteString(string("source")); err != nil {
8067			return err
8068		}
8069
8070		if err := t.Source.MarshalCBOR(cw); err != nil {
8071			return err
8072		}
8073	}
8074
8075	// t.Target (tangled.RepoPull_Target) (struct)
8076	if len("target") > 1000000 {
8077		return xerrors.Errorf("Value in field \"target\" was too long")
8078	}
8079
8080	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("target"))); err != nil {
8081		return err
8082	}
8083	if _, err := cw.WriteString(string("target")); err != nil {
8084		return err
8085	}
8086
8087	if err := t.Target.MarshalCBOR(cw); err != nil {
8088		return err
8089	}
8090
8091	// t.Mentions ([]string) (slice)
8092	if t.Mentions != nil {
8093
8094		if len("mentions") > 1000000 {
8095			return xerrors.Errorf("Value in field \"mentions\" was too long")
8096		}
8097
8098		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("mentions"))); err != nil {
8099			return err
8100		}
8101		if _, err := cw.WriteString(string("mentions")); err != nil {
8102			return err
8103		}
8104
8105		if len(t.Mentions) > 8192 {
8106			return xerrors.Errorf("Slice value in field t.Mentions was too long")
8107		}
8108
8109		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {
8110			return err
8111		}
8112		for _, v := range t.Mentions {
8113			if len(v) > 1000000 {
8114				return xerrors.Errorf("Value in field v was too long")
8115			}
8116
8117			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
8118				return err
8119			}
8120			if _, err := cw.WriteString(string(v)); err != nil {
8121				return err
8122			}
8123
8124		}
8125	}
8126
8127	// t.CreatedAt (string) (string)
8128	if len("createdAt") > 1000000 {
8129		return xerrors.Errorf("Value in field \"createdAt\" was too long")
8130	}
8131
8132	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
8133		return err
8134	}
8135	if _, err := cw.WriteString(string("createdAt")); err != nil {
8136		return err
8137	}
8138
8139	if len(t.CreatedAt) > 1000000 {
8140		return xerrors.Errorf("Value in field t.CreatedAt was too long")
8141	}
8142
8143	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
8144		return err
8145	}
8146	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
8147		return err
8148	}
8149
8150	// t.References ([]string) (slice)
8151	if t.References != nil {
8152
8153		if len("references") > 1000000 {
8154			return xerrors.Errorf("Value in field \"references\" was too long")
8155		}
8156
8157		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("references"))); err != nil {
8158			return err
8159		}
8160		if _, err := cw.WriteString(string("references")); err != nil {
8161			return err
8162		}
8163
8164		if len(t.References) > 8192 {
8165			return xerrors.Errorf("Slice value in field t.References was too long")
8166		}
8167
8168		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {
8169			return err
8170		}
8171		for _, v := range t.References {
8172			if len(v) > 1000000 {
8173				return xerrors.Errorf("Value in field v was too long")
8174			}
8175
8176			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
8177				return err
8178			}
8179			if _, err := cw.WriteString(string(v)); err != nil {
8180				return err
8181			}
8182
8183		}
8184	}
8185	return nil
8186}
8187
8188func (t *RepoPull) UnmarshalCBOR(r io.Reader) (err error) {
8189	*t = RepoPull{}
8190
8191	cr := cbg.NewCborReader(r)
8192
8193	maj, extra, err := cr.ReadHeader()
8194	if err != nil {
8195		return err
8196	}
8197	defer func() {
8198		if err == io.EOF {
8199			err = io.ErrUnexpectedEOF
8200		}
8201	}()
8202
8203	if maj != cbg.MajMap {
8204		return fmt.Errorf("cbor input should be of type map")
8205	}
8206
8207	if extra > cbg.MaxLength {
8208		return fmt.Errorf("RepoPull: map struct too large (%d)", extra)
8209	}
8210
8211	n := extra
8212
8213	nameBuf := make([]byte, 10)
8214	for i := uint64(0); i < n; i++ {
8215		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8216		if err != nil {
8217			return err
8218		}
8219
8220		if !ok {
8221			// Field doesn't exist on this type, so ignore it
8222			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8223				return err
8224			}
8225			continue
8226		}
8227
8228		switch string(nameBuf[:nameLen]) {
8229		// t.Body (string) (string)
8230		case "body":
8231
8232			{
8233				b, err := cr.ReadByte()
8234				if err != nil {
8235					return err
8236				}
8237				if b != cbg.CborNull[0] {
8238					if err := cr.UnreadByte(); err != nil {
8239						return err
8240					}
8241
8242					sval, err := cbg.ReadStringWithMax(cr, 1000000)
8243					if err != nil {
8244						return err
8245					}
8246
8247					t.Body = (*string)(&sval)
8248				}
8249			}
8250			// t.LexiconTypeID (string) (string)
8251		case "$type":
8252
8253			{
8254				sval, err := cbg.ReadStringWithMax(cr, 1000000)
8255				if err != nil {
8256					return err
8257				}
8258
8259				t.LexiconTypeID = string(sval)
8260			}
8261			// t.Patch (string) (string)
8262		case "patch":
8263
8264			{
8265				sval, err := cbg.ReadStringWithMax(cr, 1000000)
8266				if err != nil {
8267					return err
8268				}
8269
8270				t.Patch = string(sval)
8271			}
8272			// t.Title (string) (string)
8273		case "title":
8274
8275			{
8276				sval, err := cbg.ReadStringWithMax(cr, 1000000)
8277				if err != nil {
8278					return err
8279				}
8280
8281				t.Title = string(sval)
8282			}
8283			// t.Source (tangled.RepoPull_Source) (struct)
8284		case "source":
8285
8286			{
8287
8288				b, err := cr.ReadByte()
8289				if err != nil {
8290					return err
8291				}
8292				if b != cbg.CborNull[0] {
8293					if err := cr.UnreadByte(); err != nil {
8294						return err
8295					}
8296					t.Source = new(RepoPull_Source)
8297					if err := t.Source.UnmarshalCBOR(cr); err != nil {
8298						return xerrors.Errorf("unmarshaling t.Source pointer: %w", err)
8299					}
8300				}
8301
8302			}
8303			// t.Target (tangled.RepoPull_Target) (struct)
8304		case "target":
8305
8306			{
8307
8308				b, err := cr.ReadByte()
8309				if err != nil {
8310					return err
8311				}
8312				if b != cbg.CborNull[0] {
8313					if err := cr.UnreadByte(); err != nil {
8314						return err
8315					}
8316					t.Target = new(RepoPull_Target)
8317					if err := t.Target.UnmarshalCBOR(cr); err != nil {
8318						return xerrors.Errorf("unmarshaling t.Target pointer: %w", err)
8319					}
8320				}
8321
8322			}
8323			// t.Mentions ([]string) (slice)
8324		case "mentions":
8325
8326			maj, extra, err = cr.ReadHeader()
8327			if err != nil {
8328				return err
8329			}
8330
8331			if extra > 8192 {
8332				return fmt.Errorf("t.Mentions: array too large (%d)", extra)
8333			}
8334
8335			if maj != cbg.MajArray {
8336				return fmt.Errorf("expected cbor array")
8337			}
8338
8339			if extra > 0 {
8340				t.Mentions = make([]string, extra)
8341			}
8342
8343			for i := 0; i < int(extra); i++ {
8344				{
8345					var maj byte
8346					var extra uint64
8347					var err error
8348					_ = maj
8349					_ = extra
8350					_ = err
8351
8352					{
8353						sval, err := cbg.ReadStringWithMax(cr, 1000000)
8354						if err != nil {
8355							return err
8356						}
8357
8358						t.Mentions[i] = string(sval)
8359					}
8360
8361				}
8362			}
8363			// t.CreatedAt (string) (string)
8364		case "createdAt":
8365
8366			{
8367				sval, err := cbg.ReadStringWithMax(cr, 1000000)
8368				if err != nil {
8369					return err
8370				}
8371
8372				t.CreatedAt = string(sval)
8373			}
8374			// t.References ([]string) (slice)
8375		case "references":
8376
8377			maj, extra, err = cr.ReadHeader()
8378			if err != nil {
8379				return err
8380			}
8381
8382			if extra > 8192 {
8383				return fmt.Errorf("t.References: array too large (%d)", extra)
8384			}
8385
8386			if maj != cbg.MajArray {
8387				return fmt.Errorf("expected cbor array")
8388			}
8389
8390			if extra > 0 {
8391				t.References = make([]string, extra)
8392			}
8393
8394			for i := 0; i < int(extra); i++ {
8395				{
8396					var maj byte
8397					var extra uint64
8398					var err error
8399					_ = maj
8400					_ = extra
8401					_ = err
8402
8403					{
8404						sval, err := cbg.ReadStringWithMax(cr, 1000000)
8405						if err != nil {
8406							return err
8407						}
8408
8409						t.References[i] = string(sval)
8410					}
8411
8412				}
8413			}
8414
8415		default:
8416			// Field doesn't exist on this type, so ignore it
8417			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8418				return err
8419			}
8420		}
8421	}
8422
8423	return nil
8424}
8425func (t *RepoPullComment) MarshalCBOR(w io.Writer) error {
8426	if t == nil {
8427		_, err := w.Write(cbg.CborNull)
8428		return err
8429	}
8430
8431	cw := cbg.NewCborWriter(w)
8432	fieldCount := 6
8433
8434	if t.Mentions == nil {
8435		fieldCount--
8436	}
8437
8438	if t.References == nil {
8439		fieldCount--
8440	}
8441
8442	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
8443		return err
8444	}
8445
8446	// t.Body (string) (string)
8447	if len("body") > 1000000 {
8448		return xerrors.Errorf("Value in field \"body\" was too long")
8449	}
8450
8451	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
8452		return err
8453	}
8454	if _, err := cw.WriteString(string("body")); err != nil {
8455		return err
8456	}
8457
8458	if len(t.Body) > 1000000 {
8459		return xerrors.Errorf("Value in field t.Body was too long")
8460	}
8461
8462	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil {
8463		return err
8464	}
8465	if _, err := cw.WriteString(string(t.Body)); err != nil {
8466		return err
8467	}
8468
8469	// t.Pull (string) (string)
8470	if len("pull") > 1000000 {
8471		return xerrors.Errorf("Value in field \"pull\" was too long")
8472	}
8473
8474	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil {
8475		return err
8476	}
8477	if _, err := cw.WriteString(string("pull")); err != nil {
8478		return err
8479	}
8480
8481	if len(t.Pull) > 1000000 {
8482		return xerrors.Errorf("Value in field t.Pull was too long")
8483	}
8484
8485	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil {
8486		return err
8487	}
8488	if _, err := cw.WriteString(string(t.Pull)); err != nil {
8489		return err
8490	}
8491
8492	// t.LexiconTypeID (string) (string)
8493	if len("$type") > 1000000 {
8494		return xerrors.Errorf("Value in field \"$type\" was too long")
8495	}
8496
8497	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
8498		return err
8499	}
8500	if _, err := cw.WriteString(string("$type")); err != nil {
8501		return err
8502	}
8503
8504	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.comment"))); err != nil {
8505		return err
8506	}
8507	if _, err := cw.WriteString(string("sh.tangled.repo.pull.comment")); err != nil {
8508		return err
8509	}
8510
8511	// t.Mentions ([]string) (slice)
8512	if t.Mentions != nil {
8513
8514		if len("mentions") > 1000000 {
8515			return xerrors.Errorf("Value in field \"mentions\" was too long")
8516		}
8517
8518		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("mentions"))); err != nil {
8519			return err
8520		}
8521		if _, err := cw.WriteString(string("mentions")); err != nil {
8522			return err
8523		}
8524
8525		if len(t.Mentions) > 8192 {
8526			return xerrors.Errorf("Slice value in field t.Mentions was too long")
8527		}
8528
8529		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {
8530			return err
8531		}
8532		for _, v := range t.Mentions {
8533			if len(v) > 1000000 {
8534				return xerrors.Errorf("Value in field v was too long")
8535			}
8536
8537			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
8538				return err
8539			}
8540			if _, err := cw.WriteString(string(v)); err != nil {
8541				return err
8542			}
8543
8544		}
8545	}
8546
8547	// t.CreatedAt (string) (string)
8548	if len("createdAt") > 1000000 {
8549		return xerrors.Errorf("Value in field \"createdAt\" was too long")
8550	}
8551
8552	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
8553		return err
8554	}
8555	if _, err := cw.WriteString(string("createdAt")); err != nil {
8556		return err
8557	}
8558
8559	if len(t.CreatedAt) > 1000000 {
8560		return xerrors.Errorf("Value in field t.CreatedAt was too long")
8561	}
8562
8563	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
8564		return err
8565	}
8566	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
8567		return err
8568	}
8569
8570	// t.References ([]string) (slice)
8571	if t.References != nil {
8572
8573		if len("references") > 1000000 {
8574			return xerrors.Errorf("Value in field \"references\" was too long")
8575		}
8576
8577		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("references"))); err != nil {
8578			return err
8579		}
8580		if _, err := cw.WriteString(string("references")); err != nil {
8581			return err
8582		}
8583
8584		if len(t.References) > 8192 {
8585			return xerrors.Errorf("Slice value in field t.References was too long")
8586		}
8587
8588		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {
8589			return err
8590		}
8591		for _, v := range t.References {
8592			if len(v) > 1000000 {
8593				return xerrors.Errorf("Value in field v was too long")
8594			}
8595
8596			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
8597				return err
8598			}
8599			if _, err := cw.WriteString(string(v)); err != nil {
8600				return err
8601			}
8602
8603		}
8604	}
8605	return nil
8606}
8607
8608func (t *RepoPullComment) UnmarshalCBOR(r io.Reader) (err error) {
8609	*t = RepoPullComment{}
8610
8611	cr := cbg.NewCborReader(r)
8612
8613	maj, extra, err := cr.ReadHeader()
8614	if err != nil {
8615		return err
8616	}
8617	defer func() {
8618		if err == io.EOF {
8619			err = io.ErrUnexpectedEOF
8620		}
8621	}()
8622
8623	if maj != cbg.MajMap {
8624		return fmt.Errorf("cbor input should be of type map")
8625	}
8626
8627	if extra > cbg.MaxLength {
8628		return fmt.Errorf("RepoPullComment: map struct too large (%d)", extra)
8629	}
8630
8631	n := extra
8632
8633	nameBuf := make([]byte, 10)
8634	for i := uint64(0); i < n; i++ {
8635		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8636		if err != nil {
8637			return err
8638		}
8639
8640		if !ok {
8641			// Field doesn't exist on this type, so ignore it
8642			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8643				return err
8644			}
8645			continue
8646		}
8647
8648		switch string(nameBuf[:nameLen]) {
8649		// t.Body (string) (string)
8650		case "body":
8651
8652			{
8653				sval, err := cbg.ReadStringWithMax(cr, 1000000)
8654				if err != nil {
8655					return err
8656				}
8657
8658				t.Body = string(sval)
8659			}
8660			// t.Pull (string) (string)
8661		case "pull":
8662
8663			{
8664				sval, err := cbg.ReadStringWithMax(cr, 1000000)
8665				if err != nil {
8666					return err
8667				}
8668
8669				t.Pull = string(sval)
8670			}
8671			// t.LexiconTypeID (string) (string)
8672		case "$type":
8673
8674			{
8675				sval, err := cbg.ReadStringWithMax(cr, 1000000)
8676				if err != nil {
8677					return err
8678				}
8679
8680				t.LexiconTypeID = string(sval)
8681			}
8682			// t.Mentions ([]string) (slice)
8683		case "mentions":
8684
8685			maj, extra, err = cr.ReadHeader()
8686			if err != nil {
8687				return err
8688			}
8689
8690			if extra > 8192 {
8691				return fmt.Errorf("t.Mentions: array too large (%d)", extra)
8692			}
8693
8694			if maj != cbg.MajArray {
8695				return fmt.Errorf("expected cbor array")
8696			}
8697
8698			if extra > 0 {
8699				t.Mentions = make([]string, extra)
8700			}
8701
8702			for i := 0; i < int(extra); i++ {
8703				{
8704					var maj byte
8705					var extra uint64
8706					var err error
8707					_ = maj
8708					_ = extra
8709					_ = err
8710
8711					{
8712						sval, err := cbg.ReadStringWithMax(cr, 1000000)
8713						if err != nil {
8714							return err
8715						}
8716
8717						t.Mentions[i] = string(sval)
8718					}
8719
8720				}
8721			}
8722			// t.CreatedAt (string) (string)
8723		case "createdAt":
8724
8725			{
8726				sval, err := cbg.ReadStringWithMax(cr, 1000000)
8727				if err != nil {
8728					return err
8729				}
8730
8731				t.CreatedAt = string(sval)
8732			}
8733			// t.References ([]string) (slice)
8734		case "references":
8735
8736			maj, extra, err = cr.ReadHeader()
8737			if err != nil {
8738				return err
8739			}
8740
8741			if extra > 8192 {
8742				return fmt.Errorf("t.References: array too large (%d)", extra)
8743			}
8744
8745			if maj != cbg.MajArray {
8746				return fmt.Errorf("expected cbor array")
8747			}
8748
8749			if extra > 0 {
8750				t.References = make([]string, extra)
8751			}
8752
8753			for i := 0; i < int(extra); i++ {
8754				{
8755					var maj byte
8756					var extra uint64
8757					var err error
8758					_ = maj
8759					_ = extra
8760					_ = err
8761
8762					{
8763						sval, err := cbg.ReadStringWithMax(cr, 1000000)
8764						if err != nil {
8765							return err
8766						}
8767
8768						t.References[i] = string(sval)
8769					}
8770
8771				}
8772			}
8773
8774		default:
8775			// Field doesn't exist on this type, so ignore it
8776			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8777				return err
8778			}
8779		}
8780	}
8781
8782	return nil
8783}
8784func (t *RepoPull_Source) MarshalCBOR(w io.Writer) error {
8785	if t == nil {
8786		_, err := w.Write(cbg.CborNull)
8787		return err
8788	}
8789
8790	cw := cbg.NewCborWriter(w)
8791	fieldCount := 3
8792
8793	if t.Repo == nil {
8794		fieldCount--
8795	}
8796
8797	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
8798		return err
8799	}
8800
8801	// t.Sha (string) (string)
8802	if len("sha") > 1000000 {
8803		return xerrors.Errorf("Value in field \"sha\" was too long")
8804	}
8805
8806	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sha"))); err != nil {
8807		return err
8808	}
8809	if _, err := cw.WriteString(string("sha")); err != nil {
8810		return err
8811	}
8812
8813	if len(t.Sha) > 1000000 {
8814		return xerrors.Errorf("Value in field t.Sha was too long")
8815	}
8816
8817	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Sha))); err != nil {
8818		return err
8819	}
8820	if _, err := cw.WriteString(string(t.Sha)); err != nil {
8821		return err
8822	}
8823
8824	// t.Repo (string) (string)
8825	if t.Repo != nil {
8826
8827		if len("repo") > 1000000 {
8828			return xerrors.Errorf("Value in field \"repo\" was too long")
8829		}
8830
8831		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
8832			return err
8833		}
8834		if _, err := cw.WriteString(string("repo")); err != nil {
8835			return err
8836		}
8837
8838		if t.Repo == nil {
8839			if _, err := cw.Write(cbg.CborNull); err != nil {
8840				return err
8841			}
8842		} else {
8843			if len(*t.Repo) > 1000000 {
8844				return xerrors.Errorf("Value in field t.Repo was too long")
8845			}
8846
8847			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
8848				return err
8849			}
8850			if _, err := cw.WriteString(string(*t.Repo)); err != nil {
8851				return err
8852			}
8853		}
8854	}
8855
8856	// t.Branch (string) (string)
8857	if len("branch") > 1000000 {
8858		return xerrors.Errorf("Value in field \"branch\" was too long")
8859	}
8860
8861	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("branch"))); err != nil {
8862		return err
8863	}
8864	if _, err := cw.WriteString(string("branch")); err != nil {
8865		return err
8866	}
8867
8868	if len(t.Branch) > 1000000 {
8869		return xerrors.Errorf("Value in field t.Branch was too long")
8870	}
8871
8872	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Branch))); err != nil {
8873		return err
8874	}
8875	if _, err := cw.WriteString(string(t.Branch)); err != nil {
8876		return err
8877	}
8878	return nil
8879}
8880
8881func (t *RepoPull_Source) UnmarshalCBOR(r io.Reader) (err error) {
8882	*t = RepoPull_Source{}
8883
8884	cr := cbg.NewCborReader(r)
8885
8886	maj, extra, err := cr.ReadHeader()
8887	if err != nil {
8888		return err
8889	}
8890	defer func() {
8891		if err == io.EOF {
8892			err = io.ErrUnexpectedEOF
8893		}
8894	}()
8895
8896	if maj != cbg.MajMap {
8897		return fmt.Errorf("cbor input should be of type map")
8898	}
8899
8900	if extra > cbg.MaxLength {
8901		return fmt.Errorf("RepoPull_Source: map struct too large (%d)", extra)
8902	}
8903
8904	n := extra
8905
8906	nameBuf := make([]byte, 6)
8907	for i := uint64(0); i < n; i++ {
8908		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
8909		if err != nil {
8910			return err
8911		}
8912
8913		if !ok {
8914			// Field doesn't exist on this type, so ignore it
8915			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
8916				return err
8917			}
8918			continue
8919		}
8920
8921		switch string(nameBuf[:nameLen]) {
8922		// t.Sha (string) (string)
8923		case "sha":
8924
8925			{
8926				sval, err := cbg.ReadStringWithMax(cr, 1000000)
8927				if err != nil {
8928					return err
8929				}
8930
8931				t.Sha = string(sval)
8932			}
8933			// t.Repo (string) (string)
8934		case "repo":
8935
8936			{
8937				b, err := cr.ReadByte()
8938				if err != nil {
8939					return err
8940				}
8941				if b != cbg.CborNull[0] {
8942					if err := cr.UnreadByte(); err != nil {
8943						return err
8944					}
8945
8946					sval, err := cbg.ReadStringWithMax(cr, 1000000)
8947					if err != nil {
8948						return err
8949					}
8950
8951					t.Repo = (*string)(&sval)
8952				}
8953			}
8954			// t.Branch (string) (string)
8955		case "branch":
8956
8957			{
8958				sval, err := cbg.ReadStringWithMax(cr, 1000000)
8959				if err != nil {
8960					return err
8961				}
8962
8963				t.Branch = string(sval)
8964			}
8965
8966		default:
8967			// Field doesn't exist on this type, so ignore it
8968			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
8969				return err
8970			}
8971		}
8972	}
8973
8974	return nil
8975}
8976func (t *RepoPullStatus) MarshalCBOR(w io.Writer) error {
8977	if t == nil {
8978		_, err := w.Write(cbg.CborNull)
8979		return err
8980	}
8981
8982	cw := cbg.NewCborWriter(w)
8983
8984	if _, err := cw.Write([]byte{163}); err != nil {
8985		return err
8986	}
8987
8988	// t.Pull (string) (string)
8989	if len("pull") > 1000000 {
8990		return xerrors.Errorf("Value in field \"pull\" was too long")
8991	}
8992
8993	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil {
8994		return err
8995	}
8996	if _, err := cw.WriteString(string("pull")); err != nil {
8997		return err
8998	}
8999
9000	if len(t.Pull) > 1000000 {
9001		return xerrors.Errorf("Value in field t.Pull was too long")
9002	}
9003
9004	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil {
9005		return err
9006	}
9007	if _, err := cw.WriteString(string(t.Pull)); err != nil {
9008		return err
9009	}
9010
9011	// t.LexiconTypeID (string) (string)
9012	if len("$type") > 1000000 {
9013		return xerrors.Errorf("Value in field \"$type\" was too long")
9014	}
9015
9016	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
9017		return err
9018	}
9019	if _, err := cw.WriteString(string("$type")); err != nil {
9020		return err
9021	}
9022
9023	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.status"))); err != nil {
9024		return err
9025	}
9026	if _, err := cw.WriteString(string("sh.tangled.repo.pull.status")); err != nil {
9027		return err
9028	}
9029
9030	// t.Status (string) (string)
9031	if len("status") > 1000000 {
9032		return xerrors.Errorf("Value in field \"status\" was too long")
9033	}
9034
9035	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {
9036		return err
9037	}
9038	if _, err := cw.WriteString(string("status")); err != nil {
9039		return err
9040	}
9041
9042	if len(t.Status) > 1000000 {
9043		return xerrors.Errorf("Value in field t.Status was too long")
9044	}
9045
9046	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil {
9047		return err
9048	}
9049	if _, err := cw.WriteString(string(t.Status)); err != nil {
9050		return err
9051	}
9052	return nil
9053}
9054
9055func (t *RepoPullStatus) UnmarshalCBOR(r io.Reader) (err error) {
9056	*t = RepoPullStatus{}
9057
9058	cr := cbg.NewCborReader(r)
9059
9060	maj, extra, err := cr.ReadHeader()
9061	if err != nil {
9062		return err
9063	}
9064	defer func() {
9065		if err == io.EOF {
9066			err = io.ErrUnexpectedEOF
9067		}
9068	}()
9069
9070	if maj != cbg.MajMap {
9071		return fmt.Errorf("cbor input should be of type map")
9072	}
9073
9074	if extra > cbg.MaxLength {
9075		return fmt.Errorf("RepoPullStatus: map struct too large (%d)", extra)
9076	}
9077
9078	n := extra
9079
9080	nameBuf := make([]byte, 6)
9081	for i := uint64(0); i < n; i++ {
9082		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
9083		if err != nil {
9084			return err
9085		}
9086
9087		if !ok {
9088			// Field doesn't exist on this type, so ignore it
9089			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
9090				return err
9091			}
9092			continue
9093		}
9094
9095		switch string(nameBuf[:nameLen]) {
9096		// t.Pull (string) (string)
9097		case "pull":
9098
9099			{
9100				sval, err := cbg.ReadStringWithMax(cr, 1000000)
9101				if err != nil {
9102					return err
9103				}
9104
9105				t.Pull = string(sval)
9106			}
9107			// t.LexiconTypeID (string) (string)
9108		case "$type":
9109
9110			{
9111				sval, err := cbg.ReadStringWithMax(cr, 1000000)
9112				if err != nil {
9113					return err
9114				}
9115
9116				t.LexiconTypeID = string(sval)
9117			}
9118			// t.Status (string) (string)
9119		case "status":
9120
9121			{
9122				sval, err := cbg.ReadStringWithMax(cr, 1000000)
9123				if err != nil {
9124					return err
9125				}
9126
9127				t.Status = string(sval)
9128			}
9129
9130		default:
9131			// Field doesn't exist on this type, so ignore it
9132			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
9133				return err
9134			}
9135		}
9136	}
9137
9138	return nil
9139}
9140func (t *RepoPull_Target) MarshalCBOR(w io.Writer) error {
9141	if t == nil {
9142		_, err := w.Write(cbg.CborNull)
9143		return err
9144	}
9145
9146	cw := cbg.NewCborWriter(w)
9147
9148	if _, err := cw.Write([]byte{162}); err != nil {
9149		return err
9150	}
9151
9152	// t.Repo (string) (string)
9153	if len("repo") > 1000000 {
9154		return xerrors.Errorf("Value in field \"repo\" was too long")
9155	}
9156
9157	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
9158		return err
9159	}
9160	if _, err := cw.WriteString(string("repo")); err != nil {
9161		return err
9162	}
9163
9164	if len(t.Repo) > 1000000 {
9165		return xerrors.Errorf("Value in field t.Repo was too long")
9166	}
9167
9168	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
9169		return err
9170	}
9171	if _, err := cw.WriteString(string(t.Repo)); err != nil {
9172		return err
9173	}
9174
9175	// t.Branch (string) (string)
9176	if len("branch") > 1000000 {
9177		return xerrors.Errorf("Value in field \"branch\" was too long")
9178	}
9179
9180	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("branch"))); err != nil {
9181		return err
9182	}
9183	if _, err := cw.WriteString(string("branch")); err != nil {
9184		return err
9185	}
9186
9187	if len(t.Branch) > 1000000 {
9188		return xerrors.Errorf("Value in field t.Branch was too long")
9189	}
9190
9191	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Branch))); err != nil {
9192		return err
9193	}
9194	if _, err := cw.WriteString(string(t.Branch)); err != nil {
9195		return err
9196	}
9197	return nil
9198}
9199
9200func (t *RepoPull_Target) UnmarshalCBOR(r io.Reader) (err error) {
9201	*t = RepoPull_Target{}
9202
9203	cr := cbg.NewCborReader(r)
9204
9205	maj, extra, err := cr.ReadHeader()
9206	if err != nil {
9207		return err
9208	}
9209	defer func() {
9210		if err == io.EOF {
9211			err = io.ErrUnexpectedEOF
9212		}
9213	}()
9214
9215	if maj != cbg.MajMap {
9216		return fmt.Errorf("cbor input should be of type map")
9217	}
9218
9219	if extra > cbg.MaxLength {
9220		return fmt.Errorf("RepoPull_Target: map struct too large (%d)", extra)
9221	}
9222
9223	n := extra
9224
9225	nameBuf := make([]byte, 6)
9226	for i := uint64(0); i < n; i++ {
9227		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
9228		if err != nil {
9229			return err
9230		}
9231
9232		if !ok {
9233			// Field doesn't exist on this type, so ignore it
9234			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
9235				return err
9236			}
9237			continue
9238		}
9239
9240		switch string(nameBuf[:nameLen]) {
9241		// t.Repo (string) (string)
9242		case "repo":
9243
9244			{
9245				sval, err := cbg.ReadStringWithMax(cr, 1000000)
9246				if err != nil {
9247					return err
9248				}
9249
9250				t.Repo = string(sval)
9251			}
9252			// t.Branch (string) (string)
9253		case "branch":
9254
9255			{
9256				sval, err := cbg.ReadStringWithMax(cr, 1000000)
9257				if err != nil {
9258					return err
9259				}
9260
9261				t.Branch = string(sval)
9262			}
9263
9264		default:
9265			// Field doesn't exist on this type, so ignore it
9266			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
9267				return err
9268			}
9269		}
9270	}
9271
9272	return nil
9273}
9274func (t *Spindle) MarshalCBOR(w io.Writer) error {
9275	if t == nil {
9276		_, err := w.Write(cbg.CborNull)
9277		return err
9278	}
9279
9280	cw := cbg.NewCborWriter(w)
9281
9282	if _, err := cw.Write([]byte{162}); err != nil {
9283		return err
9284	}
9285
9286	// t.LexiconTypeID (string) (string)
9287	if len("$type") > 1000000 {
9288		return xerrors.Errorf("Value in field \"$type\" was too long")
9289	}
9290
9291	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
9292		return err
9293	}
9294	if _, err := cw.WriteString(string("$type")); err != nil {
9295		return err
9296	}
9297
9298	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.spindle"))); err != nil {
9299		return err
9300	}
9301	if _, err := cw.WriteString(string("sh.tangled.spindle")); err != nil {
9302		return err
9303	}
9304
9305	// t.CreatedAt (string) (string)
9306	if len("createdAt") > 1000000 {
9307		return xerrors.Errorf("Value in field \"createdAt\" was too long")
9308	}
9309
9310	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
9311		return err
9312	}
9313	if _, err := cw.WriteString(string("createdAt")); err != nil {
9314		return err
9315	}
9316
9317	if len(t.CreatedAt) > 1000000 {
9318		return xerrors.Errorf("Value in field t.CreatedAt was too long")
9319	}
9320
9321	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
9322		return err
9323	}
9324	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
9325		return err
9326	}
9327	return nil
9328}
9329
9330func (t *Spindle) UnmarshalCBOR(r io.Reader) (err error) {
9331	*t = Spindle{}
9332
9333	cr := cbg.NewCborReader(r)
9334
9335	maj, extra, err := cr.ReadHeader()
9336	if err != nil {
9337		return err
9338	}
9339	defer func() {
9340		if err == io.EOF {
9341			err = io.ErrUnexpectedEOF
9342		}
9343	}()
9344
9345	if maj != cbg.MajMap {
9346		return fmt.Errorf("cbor input should be of type map")
9347	}
9348
9349	if extra > cbg.MaxLength {
9350		return fmt.Errorf("Spindle: map struct too large (%d)", extra)
9351	}
9352
9353	n := extra
9354
9355	nameBuf := make([]byte, 9)
9356	for i := uint64(0); i < n; i++ {
9357		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
9358		if err != nil {
9359			return err
9360		}
9361
9362		if !ok {
9363			// Field doesn't exist on this type, so ignore it
9364			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
9365				return err
9366			}
9367			continue
9368		}
9369
9370		switch string(nameBuf[:nameLen]) {
9371		// t.LexiconTypeID (string) (string)
9372		case "$type":
9373
9374			{
9375				sval, err := cbg.ReadStringWithMax(cr, 1000000)
9376				if err != nil {
9377					return err
9378				}
9379
9380				t.LexiconTypeID = string(sval)
9381			}
9382			// t.CreatedAt (string) (string)
9383		case "createdAt":
9384
9385			{
9386				sval, err := cbg.ReadStringWithMax(cr, 1000000)
9387				if err != nil {
9388					return err
9389				}
9390
9391				t.CreatedAt = string(sval)
9392			}
9393
9394		default:
9395			// Field doesn't exist on this type, so ignore it
9396			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
9397				return err
9398			}
9399		}
9400	}
9401
9402	return nil
9403}
9404func (t *SpindleMember) MarshalCBOR(w io.Writer) error {
9405	if t == nil {
9406		_, err := w.Write(cbg.CborNull)
9407		return err
9408	}
9409
9410	cw := cbg.NewCborWriter(w)
9411
9412	if _, err := cw.Write([]byte{164}); err != nil {
9413		return err
9414	}
9415
9416	// t.LexiconTypeID (string) (string)
9417	if len("$type") > 1000000 {
9418		return xerrors.Errorf("Value in field \"$type\" was too long")
9419	}
9420
9421	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
9422		return err
9423	}
9424	if _, err := cw.WriteString(string("$type")); err != nil {
9425		return err
9426	}
9427
9428	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.spindle.member"))); err != nil {
9429		return err
9430	}
9431	if _, err := cw.WriteString(string("sh.tangled.spindle.member")); err != nil {
9432		return err
9433	}
9434
9435	// t.Subject (string) (string)
9436	if len("subject") > 1000000 {
9437		return xerrors.Errorf("Value in field \"subject\" was too long")
9438	}
9439
9440	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
9441		return err
9442	}
9443	if _, err := cw.WriteString(string("subject")); err != nil {
9444		return err
9445	}
9446
9447	if len(t.Subject) > 1000000 {
9448		return xerrors.Errorf("Value in field t.Subject was too long")
9449	}
9450
9451	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
9452		return err
9453	}
9454	if _, err := cw.WriteString(string(t.Subject)); err != nil {
9455		return err
9456	}
9457
9458	// t.Instance (string) (string)
9459	if len("instance") > 1000000 {
9460		return xerrors.Errorf("Value in field \"instance\" was too long")
9461	}
9462
9463	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("instance"))); err != nil {
9464		return err
9465	}
9466	if _, err := cw.WriteString(string("instance")); err != nil {
9467		return err
9468	}
9469
9470	if len(t.Instance) > 1000000 {
9471		return xerrors.Errorf("Value in field t.Instance was too long")
9472	}
9473
9474	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Instance))); err != nil {
9475		return err
9476	}
9477	if _, err := cw.WriteString(string(t.Instance)); err != nil {
9478		return err
9479	}
9480
9481	// t.CreatedAt (string) (string)
9482	if len("createdAt") > 1000000 {
9483		return xerrors.Errorf("Value in field \"createdAt\" was too long")
9484	}
9485
9486	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
9487		return err
9488	}
9489	if _, err := cw.WriteString(string("createdAt")); err != nil {
9490		return err
9491	}
9492
9493	if len(t.CreatedAt) > 1000000 {
9494		return xerrors.Errorf("Value in field t.CreatedAt was too long")
9495	}
9496
9497	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
9498		return err
9499	}
9500	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
9501		return err
9502	}
9503	return nil
9504}
9505
9506func (t *SpindleMember) UnmarshalCBOR(r io.Reader) (err error) {
9507	*t = SpindleMember{}
9508
9509	cr := cbg.NewCborReader(r)
9510
9511	maj, extra, err := cr.ReadHeader()
9512	if err != nil {
9513		return err
9514	}
9515	defer func() {
9516		if err == io.EOF {
9517			err = io.ErrUnexpectedEOF
9518		}
9519	}()
9520
9521	if maj != cbg.MajMap {
9522		return fmt.Errorf("cbor input should be of type map")
9523	}
9524
9525	if extra > cbg.MaxLength {
9526		return fmt.Errorf("SpindleMember: map struct too large (%d)", extra)
9527	}
9528
9529	n := extra
9530
9531	nameBuf := make([]byte, 9)
9532	for i := uint64(0); i < n; i++ {
9533		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
9534		if err != nil {
9535			return err
9536		}
9537
9538		if !ok {
9539			// Field doesn't exist on this type, so ignore it
9540			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
9541				return err
9542			}
9543			continue
9544		}
9545
9546		switch string(nameBuf[:nameLen]) {
9547		// t.LexiconTypeID (string) (string)
9548		case "$type":
9549
9550			{
9551				sval, err := cbg.ReadStringWithMax(cr, 1000000)
9552				if err != nil {
9553					return err
9554				}
9555
9556				t.LexiconTypeID = string(sval)
9557			}
9558			// t.Subject (string) (string)
9559		case "subject":
9560
9561			{
9562				sval, err := cbg.ReadStringWithMax(cr, 1000000)
9563				if err != nil {
9564					return err
9565				}
9566
9567				t.Subject = string(sval)
9568			}
9569			// t.Instance (string) (string)
9570		case "instance":
9571
9572			{
9573				sval, err := cbg.ReadStringWithMax(cr, 1000000)
9574				if err != nil {
9575					return err
9576				}
9577
9578				t.Instance = string(sval)
9579			}
9580			// t.CreatedAt (string) (string)
9581		case "createdAt":
9582
9583			{
9584				sval, err := cbg.ReadStringWithMax(cr, 1000000)
9585				if err != nil {
9586					return err
9587				}
9588
9589				t.CreatedAt = string(sval)
9590			}
9591
9592		default:
9593			// Field doesn't exist on this type, so ignore it
9594			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
9595				return err
9596			}
9597		}
9598	}
9599
9600	return nil
9601}
9602func (t *String) MarshalCBOR(w io.Writer) error {
9603	if t == nil {
9604		_, err := w.Write(cbg.CborNull)
9605		return err
9606	}
9607
9608	cw := cbg.NewCborWriter(w)
9609
9610	if _, err := cw.Write([]byte{165}); err != nil {
9611		return err
9612	}
9613
9614	// t.LexiconTypeID (string) (string)
9615	if len("$type") > 1000000 {
9616		return xerrors.Errorf("Value in field \"$type\" was too long")
9617	}
9618
9619	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
9620		return err
9621	}
9622	if _, err := cw.WriteString(string("$type")); err != nil {
9623		return err
9624	}
9625
9626	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.string"))); err != nil {
9627		return err
9628	}
9629	if _, err := cw.WriteString(string("sh.tangled.string")); err != nil {
9630		return err
9631	}
9632
9633	// t.Contents (string) (string)
9634	if len("contents") > 1000000 {
9635		return xerrors.Errorf("Value in field \"contents\" was too long")
9636	}
9637
9638	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("contents"))); err != nil {
9639		return err
9640	}
9641	if _, err := cw.WriteString(string("contents")); err != nil {
9642		return err
9643	}
9644
9645	if len(t.Contents) > 1000000 {
9646		return xerrors.Errorf("Value in field t.Contents was too long")
9647	}
9648
9649	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Contents))); err != nil {
9650		return err
9651	}
9652	if _, err := cw.WriteString(string(t.Contents)); err != nil {
9653		return err
9654	}
9655
9656	// t.Filename (string) (string)
9657	if len("filename") > 1000000 {
9658		return xerrors.Errorf("Value in field \"filename\" was too long")
9659	}
9660
9661	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("filename"))); err != nil {
9662		return err
9663	}
9664	if _, err := cw.WriteString(string("filename")); err != nil {
9665		return err
9666	}
9667
9668	if len(t.Filename) > 1000000 {
9669		return xerrors.Errorf("Value in field t.Filename was too long")
9670	}
9671
9672	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Filename))); err != nil {
9673		return err
9674	}
9675	if _, err := cw.WriteString(string(t.Filename)); err != nil {
9676		return err
9677	}
9678
9679	// t.CreatedAt (string) (string)
9680	if len("createdAt") > 1000000 {
9681		return xerrors.Errorf("Value in field \"createdAt\" was too long")
9682	}
9683
9684	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
9685		return err
9686	}
9687	if _, err := cw.WriteString(string("createdAt")); err != nil {
9688		return err
9689	}
9690
9691	if len(t.CreatedAt) > 1000000 {
9692		return xerrors.Errorf("Value in field t.CreatedAt was too long")
9693	}
9694
9695	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
9696		return err
9697	}
9698	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
9699		return err
9700	}
9701
9702	// t.Description (string) (string)
9703	if len("description") > 1000000 {
9704		return xerrors.Errorf("Value in field \"description\" was too long")
9705	}
9706
9707	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
9708		return err
9709	}
9710	if _, err := cw.WriteString(string("description")); err != nil {
9711		return err
9712	}
9713
9714	if len(t.Description) > 1000000 {
9715		return xerrors.Errorf("Value in field t.Description was too long")
9716	}
9717
9718	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Description))); err != nil {
9719		return err
9720	}
9721	if _, err := cw.WriteString(string(t.Description)); err != nil {
9722		return err
9723	}
9724	return nil
9725}
9726
9727func (t *String) UnmarshalCBOR(r io.Reader) (err error) {
9728	*t = String{}
9729
9730	cr := cbg.NewCborReader(r)
9731
9732	maj, extra, err := cr.ReadHeader()
9733	if err != nil {
9734		return err
9735	}
9736	defer func() {
9737		if err == io.EOF {
9738			err = io.ErrUnexpectedEOF
9739		}
9740	}()
9741
9742	if maj != cbg.MajMap {
9743		return fmt.Errorf("cbor input should be of type map")
9744	}
9745
9746	if extra > cbg.MaxLength {
9747		return fmt.Errorf("String: map struct too large (%d)", extra)
9748	}
9749
9750	n := extra
9751
9752	nameBuf := make([]byte, 11)
9753	for i := uint64(0); i < n; i++ {
9754		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
9755		if err != nil {
9756			return err
9757		}
9758
9759		if !ok {
9760			// Field doesn't exist on this type, so ignore it
9761			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
9762				return err
9763			}
9764			continue
9765		}
9766
9767		switch string(nameBuf[:nameLen]) {
9768		// t.LexiconTypeID (string) (string)
9769		case "$type":
9770
9771			{
9772				sval, err := cbg.ReadStringWithMax(cr, 1000000)
9773				if err != nil {
9774					return err
9775				}
9776
9777				t.LexiconTypeID = string(sval)
9778			}
9779			// t.Contents (string) (string)
9780		case "contents":
9781
9782			{
9783				sval, err := cbg.ReadStringWithMax(cr, 1000000)
9784				if err != nil {
9785					return err
9786				}
9787
9788				t.Contents = string(sval)
9789			}
9790			// t.Filename (string) (string)
9791		case "filename":
9792
9793			{
9794				sval, err := cbg.ReadStringWithMax(cr, 1000000)
9795				if err != nil {
9796					return err
9797				}
9798
9799				t.Filename = string(sval)
9800			}
9801			// t.CreatedAt (string) (string)
9802		case "createdAt":
9803
9804			{
9805				sval, err := cbg.ReadStringWithMax(cr, 1000000)
9806				if err != nil {
9807					return err
9808				}
9809
9810				t.CreatedAt = string(sval)
9811			}
9812			// t.Description (string) (string)
9813		case "description":
9814
9815			{
9816				sval, err := cbg.ReadStringWithMax(cr, 1000000)
9817				if err != nil {
9818					return err
9819				}
9820
9821				t.Description = string(sval)
9822			}
9823
9824		default:
9825			// Field doesn't exist on this type, so ignore it
9826			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
9827				return err
9828			}
9829		}
9830	}
9831
9832	return nil
9833}
Configure Feed

Configure Feed
