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