lexgen+cborgen for atproto branches reply-qp-moderation at 2d661f71e411e9e8de1ad1a15b5cceef08bcce8b divy/video at 92d6c6b1da73c6e7a243ae0f059a220e781fbd36

api/bsky/cbor_gen.go

···
 	}
 
 	cw := cbg.NewCborWriter(w)
-	fieldCount := 4
+	fieldCount := 5
 
 	if t.Allow == nil {
+		fieldCount--
+	}
+
+	if t.HiddenReplies == nil {
 		fieldCount--
 	}
 
···
 	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
 		return err
 	}
+
+	// t.HiddenReplies ([]string) (slice)
+	if t.HiddenReplies != nil {
+
+		if len("hiddenReplies") > 1000000 {
+			return xerrors.Errorf("Value in field \"hiddenReplies\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("hiddenReplies"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("hiddenReplies")); err != nil {
+			return err
+		}
+
+		if len(t.HiddenReplies) > 8192 {
+			return xerrors.Errorf("Slice value in field t.HiddenReplies was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.HiddenReplies))); err != nil {
+			return err
+		}
+		for _, v := range t.HiddenReplies {
+			if len(v) > 1000000 {
+				return xerrors.Errorf("Value in field v was too long")
+			}
+
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(v)); err != nil {
+				return err
+			}
+
+		}
+	}
 	return nil
 }
 
···
 				}
 
 				t.CreatedAt = string(sval)
+			}
+			// t.HiddenReplies ([]string) (slice)
+		case "hiddenReplies":
+
+			maj, extra, err = cr.ReadHeader()
+			if err != nil {
+				return err
+			}
+
+			if extra > 8192 {
+				return fmt.Errorf("t.HiddenReplies: array too large (%d)", extra)
+			}
+
+			if maj != cbg.MajArray {
+				return fmt.Errorf("expected cbor array")
+			}
+
+			if extra > 0 {
+				t.HiddenReplies = make([]string, extra)
+			}
+
+			for i := 0; i < int(extra); i++ {
+				{
+					var maj byte
+					var extra uint64
+					var err error
+					_ = maj
+					_ = extra
+					_ = err
+
+					{
+						sval, err := cbg.ReadStringWithMax(cr, 1000000)
+						if err != nil {
+							return err
+						}
+
+						t.HiddenReplies[i] = string(sval)
+					}
+
+				}
 			}
 
 		default:
···
 
 	return nil
 }
+func (t *FeedPostgate) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+
+	cw := cbg.NewCborWriter(w)
+	fieldCount := 5
+
+	if t.DetachedEmbeddingUris == nil {
+		fieldCount--
+	}
+
+	if t.EmbeddingRules == nil {
+		fieldCount--
+	}
+
+	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
+		return err
+	}
+
+	// t.Post (string) (string)
+	if len("post") > 1000000 {
+		return xerrors.Errorf("Value in field \"post\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("post"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("post")); err != nil {
+		return err
+	}
+
+	if len(t.Post) > 1000000 {
+		return xerrors.Errorf("Value in field t.Post was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Post))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string(t.Post)); err != nil {
+		return err
+	}
+
+	// t.LexiconTypeID (string) (string)
+	if len("$type") > 1000000 {
+		return xerrors.Errorf("Value in field \"$type\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("$type")); err != nil {
+		return err
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("app.bsky.feed.postgate"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("app.bsky.feed.postgate")); err != nil {
+		return err
+	}
+
+	// t.CreatedAt (string) (string)
+	if len("createdAt") > 1000000 {
+		return xerrors.Errorf("Value in field \"createdAt\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("createdAt")); err != nil {
+		return err
+	}
+
+	if len(t.CreatedAt) > 1000000 {
+		return xerrors.Errorf("Value in field t.CreatedAt was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
+		return err
+	}
+
+	// t.EmbeddingRules ([]*bsky.FeedPostgate_EmbeddingRules_Elem) (slice)
+	if t.EmbeddingRules != nil {
+
+		if len("embeddingRules") > 1000000 {
+			return xerrors.Errorf("Value in field \"embeddingRules\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("embeddingRules"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("embeddingRules")); err != nil {
+			return err
+		}
+
+		if len(t.EmbeddingRules) > 8192 {
+			return xerrors.Errorf("Slice value in field t.EmbeddingRules was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.EmbeddingRules))); err != nil {
+			return err
+		}
+		for _, v := range t.EmbeddingRules {
+			if err := v.MarshalCBOR(cw); err != nil {
+				return err
+			}
+
+		}
+	}
+
+	// t.DetachedEmbeddingUris ([]string) (slice)
+	if t.DetachedEmbeddingUris != nil {
+
+		if len("detachedEmbeddingUris") > 1000000 {
+			return xerrors.Errorf("Value in field \"detachedEmbeddingUris\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("detachedEmbeddingUris"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("detachedEmbeddingUris")); err != nil {
+			return err
+		}
+
+		if len(t.DetachedEmbeddingUris) > 8192 {
+			return xerrors.Errorf("Slice value in field t.DetachedEmbeddingUris was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.DetachedEmbeddingUris))); err != nil {
+			return err
+		}
+		for _, v := range t.DetachedEmbeddingUris {
+			if len(v) > 1000000 {
+				return xerrors.Errorf("Value in field v was too long")
+			}
+
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(v)); err != nil {
+				return err
+			}
+
+		}
+	}
+	return nil
+}
+
+func (t *FeedPostgate) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = FeedPostgate{}
+
+	cr := cbg.NewCborReader(r)
+
+	maj, extra, err := cr.ReadHeader()
+	if err != nil {
+		return err
+	}
+	defer func() {
+		if err == io.EOF {
+			err = io.ErrUnexpectedEOF
+		}
+	}()
+
+	if maj != cbg.MajMap {
+		return fmt.Errorf("cbor input should be of type map")
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("FeedPostgate: map struct too large (%d)", extra)
+	}
+
+	var name string
+	n := extra
+
+	for i := uint64(0); i < n; i++ {
+
+		{
+			sval, err := cbg.ReadStringWithMax(cr, 1000000)
+			if err != nil {
+				return err
+			}
+
+			name = string(sval)
+		}
+
+		switch name {
+		// t.Post (string) (string)
+		case "post":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.Post = string(sval)
+			}
+			// t.LexiconTypeID (string) (string)
+		case "$type":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.LexiconTypeID = string(sval)
+			}
+			// t.CreatedAt (string) (string)
+		case "createdAt":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.CreatedAt = string(sval)
+			}
+			// t.EmbeddingRules ([]*bsky.FeedPostgate_EmbeddingRules_Elem) (slice)
+		case "embeddingRules":
+
+			maj, extra, err = cr.ReadHeader()
+			if err != nil {
+				return err
+			}
+
+			if extra > 8192 {
+				return fmt.Errorf("t.EmbeddingRules: array too large (%d)", extra)
+			}
+
+			if maj != cbg.MajArray {
+				return fmt.Errorf("expected cbor array")
+			}
+
+			if extra > 0 {
+				t.EmbeddingRules = make([]*FeedPostgate_EmbeddingRules_Elem, extra)
+			}
+
+			for i := 0; i < int(extra); i++ {
+				{
+					var maj byte
+					var extra uint64
+					var err error
+					_ = maj
+					_ = extra
+					_ = err
+
+					{
+
+						b, err := cr.ReadByte()
+						if err != nil {
+							return err
+						}
+						if b != cbg.CborNull[0] {
+							if err := cr.UnreadByte(); err != nil {
+								return err
+							}
+							t.EmbeddingRules[i] = new(FeedPostgate_EmbeddingRules_Elem)
+							if err := t.EmbeddingRules[i].UnmarshalCBOR(cr); err != nil {
+								return xerrors.Errorf("unmarshaling t.EmbeddingRules[i] pointer: %w", err)
+							}
+						}
+
+					}
+
+				}
+			}
+			// t.DetachedEmbeddingUris ([]string) (slice)
+		case "detachedEmbeddingUris":
+
+			maj, extra, err = cr.ReadHeader()
+			if err != nil {
+				return err
+			}
+
+			if extra > 8192 {
+				return fmt.Errorf("t.DetachedEmbeddingUris: array too large (%d)", extra)
+			}
+
+			if maj != cbg.MajArray {
+				return fmt.Errorf("expected cbor array")
+			}
+
+			if extra > 0 {
+				t.DetachedEmbeddingUris = make([]string, extra)
+			}
+
+			for i := 0; i < int(extra); i++ {
+				{
+					var maj byte
+					var extra uint64
+					var err error
+					_ = maj
+					_ = extra
+					_ = err
+
+					{
+						sval, err := cbg.ReadStringWithMax(cr, 1000000)
+						if err != nil {
+							return err
+						}
+
+						t.DetachedEmbeddingUris[i] = string(sval)
+					}
+
+				}
+			}
+
+		default:
+			// Field doesn't exist on this type, so ignore it
+			cbg.ScanForLinks(r, func(cid.Cid) {})
+		}
+	}
+
+	return nil
+}
+func (t *FeedPostgate_DisableRule) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+
+	cw := cbg.NewCborWriter(w)
+
+	if _, err := cw.Write([]byte{161}); err != nil {
+		return err
+	}
+
+	// t.LexiconTypeID (string) (string)
+	if len("$type") > 1000000 {
+		return xerrors.Errorf("Value in field \"$type\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("$type")); err != nil {
+		return err
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("app.bsky.feed.postgate#disableRule"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("app.bsky.feed.postgate#disableRule")); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (t *FeedPostgate_DisableRule) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = FeedPostgate_DisableRule{}
+
+	cr := cbg.NewCborReader(r)
+
+	maj, extra, err := cr.ReadHeader()
+	if err != nil {
+		return err
+	}
+	defer func() {
+		if err == io.EOF {
+			err = io.ErrUnexpectedEOF
+		}
+	}()
+
+	if maj != cbg.MajMap {
+		return fmt.Errorf("cbor input should be of type map")
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("FeedPostgate_DisableRule: map struct too large (%d)", extra)
+	}
+
+	var name string
+	n := extra
+
+	for i := uint64(0); i < n; i++ {
+
+		{
+			sval, err := cbg.ReadStringWithMax(cr, 1000000)
+			if err != nil {
+				return err
+			}
+
+			name = string(sval)
+		}
+
+		switch name {
+		// t.LexiconTypeID (string) (string)
+		case "$type":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.LexiconTypeID = string(sval)
+			}
+
+		default:
+			// Field doesn't exist on this type, so ignore it
+			cbg.ScanForLinks(r, func(cid.Cid) {})
+		}
+	}
+
+	return nil
+}

api/bsky/embedrecord.go

···
 	Uri           string                  `json:"uri" cborgen:"uri"`
 }
 
+// EmbedRecord_ViewDetached is a "viewDetached" in the app.bsky.embed.record schema.
+//
+// RECORDTYPE: EmbedRecord_ViewDetached
+type EmbedRecord_ViewDetached struct {
+	LexiconTypeID string `json:"$type,const=app.bsky.embed.record#viewDetached" cborgen:"$type,const=app.bsky.embed.record#viewDetached"`
+	Detached      bool   `json:"detached" cborgen:"detached"`
+	Uri           string `json:"uri" cborgen:"uri"`
+}
+
 // EmbedRecord_ViewNotFound is a "viewNotFound" in the app.bsky.embed.record schema.
 //
 // RECORDTYPE: EmbedRecord_ViewNotFound
···
 	EmbedRecord_ViewRecord         *EmbedRecord_ViewRecord
 	EmbedRecord_ViewNotFound       *EmbedRecord_ViewNotFound
 	EmbedRecord_ViewBlocked        *EmbedRecord_ViewBlocked
+	EmbedRecord_ViewDetached       *EmbedRecord_ViewDetached
 	FeedDefs_GeneratorView         *FeedDefs_GeneratorView
 	GraphDefs_ListView             *GraphDefs_ListView
 	LabelerDefs_LabelerView        *LabelerDefs_LabelerView
···
 	if t.EmbedRecord_ViewBlocked != nil {
 		t.EmbedRecord_ViewBlocked.LexiconTypeID = "app.bsky.embed.record#viewBlocked"
 		return json.Marshal(t.EmbedRecord_ViewBlocked)
+	}
+	if t.EmbedRecord_ViewDetached != nil {
+		t.EmbedRecord_ViewDetached.LexiconTypeID = "app.bsky.embed.record#viewDetached"
+		return json.Marshal(t.EmbedRecord_ViewDetached)
 	}
 	if t.FeedDefs_GeneratorView != nil {
 		t.FeedDefs_GeneratorView.LexiconTypeID = "app.bsky.feed.defs#generatorView"
···
 	case "app.bsky.embed.record#viewBlocked":
 		t.EmbedRecord_ViewBlocked = new(EmbedRecord_ViewBlocked)
 		return json.Unmarshal(b, t.EmbedRecord_ViewBlocked)
+	case "app.bsky.embed.record#viewDetached":
+		t.EmbedRecord_ViewDetached = new(EmbedRecord_ViewDetached)
+		return json.Unmarshal(b, t.EmbedRecord_ViewDetached)
 	case "app.bsky.feed.defs#generatorView":
 		t.FeedDefs_GeneratorView = new(FeedDefs_GeneratorView)
 		return json.Unmarshal(b, t.FeedDefs_GeneratorView)

api/bsky/feeddefs.go

···
 //
 // Metadata about the requesting account's relationship with the subject content. Only has meaningful content for authed requests.
 type FeedDefs_ViewerState struct {
-	Like          *string `json:"like,omitempty" cborgen:"like,omitempty"`
-	ReplyDisabled *bool   `json:"replyDisabled,omitempty" cborgen:"replyDisabled,omitempty"`
-	Repost        *string `json:"repost,omitempty" cborgen:"repost,omitempty"`
-	ThreadMuted   *bool   `json:"threadMuted,omitempty" cborgen:"threadMuted,omitempty"`
+	EmbeddingDisabled *bool   `json:"embeddingDisabled,omitempty" cborgen:"embeddingDisabled,omitempty"`
+	Like              *string `json:"like,omitempty" cborgen:"like,omitempty"`
+	ReplyDisabled     *bool   `json:"replyDisabled,omitempty" cborgen:"replyDisabled,omitempty"`
+	Repost            *string `json:"repost,omitempty" cborgen:"repost,omitempty"`
+	ThreadMuted       *bool   `json:"threadMuted,omitempty" cborgen:"threadMuted,omitempty"`
 }

api/bsky/feedpostgate.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+package bsky
+
+// schema: app.bsky.feed.postgate
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+
+	"github.com/bluesky-social/indigo/lex/util"
+	cbg "github.com/whyrusleeping/cbor-gen"
+)
+
+func init() {
+	util.RegisterType("app.bsky.feed.postgate", &FeedPostgate{})
+} //
+// RECORDTYPE: FeedPostgate
+type FeedPostgate struct {
+	LexiconTypeID string `json:"$type,const=app.bsky.feed.postgate" cborgen:"$type,const=app.bsky.feed.postgate"`
+	CreatedAt     string `json:"createdAt" cborgen:"createdAt"`
+	// detachedEmbeddingUris: List of AT-URIs embedding this post that the author has detached from.
+	DetachedEmbeddingUris []string                            `json:"detachedEmbeddingUris,omitempty" cborgen:"detachedEmbeddingUris,omitempty"`
+	EmbeddingRules        []*FeedPostgate_EmbeddingRules_Elem `json:"embeddingRules,omitempty" cborgen:"embeddingRules,omitempty"`
+	// post: Reference (AT-URI) to the post record.
+	Post string `json:"post" cborgen:"post"`
+}
+
+// FeedPostgate_DisableRule is a "disableRule" in the app.bsky.feed.postgate schema.
+//
+// Disables embedding of this post.
+//
+// RECORDTYPE: FeedPostgate_DisableRule
+type FeedPostgate_DisableRule struct {
+	LexiconTypeID string `json:"$type,const=app.bsky.feed.postgate#disableRule" cborgen:"$type,const=app.bsky.feed.postgate#disableRule"`
+}
+
+type FeedPostgate_EmbeddingRules_Elem struct {
+	FeedPostgate_DisableRule *FeedPostgate_DisableRule
+}
+
+func (t *FeedPostgate_EmbeddingRules_Elem) MarshalJSON() ([]byte, error) {
+	if t.FeedPostgate_DisableRule != nil {
+		t.FeedPostgate_DisableRule.LexiconTypeID = "app.bsky.feed.postgate#disableRule"
+		return json.Marshal(t.FeedPostgate_DisableRule)
+	}
+	return nil, fmt.Errorf("cannot marshal empty enum")
+}
+func (t *FeedPostgate_EmbeddingRules_Elem) UnmarshalJSON(b []byte) error {
+	typ, err := util.TypeExtract(b)
+	if err != nil {
+		return err
+	}
+
+	switch typ {
+	case "app.bsky.feed.postgate#disableRule":
+		t.FeedPostgate_DisableRule = new(FeedPostgate_DisableRule)
+		return json.Unmarshal(b, t.FeedPostgate_DisableRule)
+
+	default:
+		return nil
+	}
+}
+
+func (t *FeedPostgate_EmbeddingRules_Elem) MarshalCBOR(w io.Writer) error {
+
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if t.FeedPostgate_DisableRule != nil {
+		return t.FeedPostgate_DisableRule.MarshalCBOR(w)
+	}
+	return fmt.Errorf("cannot cbor marshal empty enum")
+}
+func (t *FeedPostgate_EmbeddingRules_Elem) UnmarshalCBOR(r io.Reader) error {
+	typ, b, err := util.CborTypeExtractReader(r)
+	if err != nil {
+		return err
+	}
+
+	switch typ {
+	case "app.bsky.feed.postgate#disableRule":
+		t.FeedPostgate_DisableRule = new(FeedPostgate_DisableRule)
+		return t.FeedPostgate_DisableRule.UnmarshalCBOR(bytes.NewReader(b))
+
+	default:
+		return nil
+	}
+}

api/bsky/feedthreadgate.go

···
 	LexiconTypeID string                       `json:"$type,const=app.bsky.feed.threadgate" cborgen:"$type,const=app.bsky.feed.threadgate"`
 	Allow         []*FeedThreadgate_Allow_Elem `json:"allow,omitempty" cborgen:"allow,omitempty"`
 	CreatedAt     string                       `json:"createdAt" cborgen:"createdAt"`
+	// hiddenReplies: List of hidden reply URIs.
+	HiddenReplies []string `json:"hiddenReplies,omitempty" cborgen:"hiddenReplies,omitempty"`
 	// post: Reference (AT-URI) to the post record.
 	Post string `json:"post" cborgen:"post"`
 }

gen/main.go

···
 		bsky.LabelerService{},
 		bsky.LabelerDefs_LabelerPolicies{},
 		bsky.EmbedVideo{}, bsky.EmbedVideo_Caption{},
+		bsky.FeedPostgate{},
+		bsky.FeedPostgate_DisableRule{},
 		/*bsky.EmbedImages_View{},
 		bsky.EmbedRecord_View{}, bsky.EmbedRecordWithMedia_View{},
 		bsky.EmbedExternal_View{}, bsky.EmbedImages_ViewImage{},