lexgen and cborgen with latest lexicons (#932)

api/atproto/cbor_gen.go

···
 var _ = math.E
 var _ = sort.Sort
 
+func (t *LexiconSchema) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+
+	cw := cbg.NewCborWriter(w)
+
+	if _, err := cw.Write([]byte{162}); 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("com.atproto.lexicon.schema"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("com.atproto.lexicon.schema")); err != nil {
+		return err
+	}
+
+	// t.Lexicon (int64) (int64)
+	if len("lexicon") > 1000000 {
+		return xerrors.Errorf("Value in field \"lexicon\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("lexicon"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("lexicon")); err != nil {
+		return err
+	}
+
+	if t.Lexicon >= 0 {
+		if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Lexicon)); err != nil {
+			return err
+		}
+	} else {
+		if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Lexicon-1)); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (t *LexiconSchema) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = LexiconSchema{}
+
+	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("LexiconSchema: map struct too large (%d)", extra)
+	}
+
+	n := extra
+
+	nameBuf := make([]byte, 7)
+	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
+
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
+				return err
+			}
+			continue
+		}
+
+		switch string(nameBuf[:nameLen]) {
+		// t.LexiconTypeID (string) (string)
+		case "$type":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.LexiconTypeID = string(sval)
+			}
+			// t.Lexicon (int64) (int64)
+		case "lexicon":
+			{
+				maj, extra, err := cr.ReadHeader()
+				if err != nil {
+					return err
+				}
+				var extraI int64
+				switch maj {
+				case cbg.MajUnsignedInt:
+					extraI = int64(extra)
+					if extraI < 0 {
+						return fmt.Errorf("int64 positive overflow")
+					}
+				case cbg.MajNegativeInt:
+					extraI = int64(extra)
+					if extraI < 0 {
+						return fmt.Errorf("int64 negative overflow")
+					}
+					extraI = -1 - extraI
+				default:
+					return fmt.Errorf("wrong type for int64 field: %d", maj)
+				}
+
+				t.Lexicon = int64(extraI)
+			}
+
+		default:
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
 func (t *RepoStrongRef) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)

api/atproto/lexiconschema.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+package atproto
+
+// schema: com.atproto.lexicon.schema
+
+import (
+	"github.com/bluesky-social/indigo/lex/util"
+)
+
+func init() {
+	util.RegisterType("com.atproto.lexicon.schema", &LexiconSchema{})
+} //
+// RECORDTYPE: LexiconSchema
+type LexiconSchema struct {
+	LexiconTypeID string `json:"$type,const=com.atproto.lexicon.schema" cborgen:"$type,const=com.atproto.lexicon.schema"`
+	// lexicon: Indicates the 'version' of the Lexicon language. Must be '1' for the current atproto/Lexicon schema system.
+	Lexicon int64 `json:"lexicon" cborgen:"lexicon"`
+}

api/bsky/cbor_gen.go

···
 
 	return nil
 }
+func (t *FeedThreadgate_FollowerRule) 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.threadgate#followerRule"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("app.bsky.feed.threadgate#followerRule")); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (t *FeedThreadgate_FollowerRule) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = FeedThreadgate_FollowerRule{}
+
+	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("FeedThreadgate_FollowerRule: map struct too large (%d)", extra)
+	}
+
+	n := extra
+
+	nameBuf := make([]byte, 5)
+	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
+
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
+				return err
+			}
+			continue
+		}
+
+		switch string(nameBuf[:nameLen]) {
+		// t.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
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
 func (t *FeedThreadgate_FollowingRule) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)

api/bsky/feeddefs.go

···
 	Repost        string `json:"repost" cborgen:"repost"`
 }
 
+// FeedDefs_ThreadContext is a "threadContext" in the app.bsky.feed.defs schema.
+//
+// Metadata about this post within the context of the thread it is in.
+type FeedDefs_ThreadContext struct {
+	RootAuthorLike *string `json:"rootAuthorLike,omitempty" cborgen:"rootAuthorLike,omitempty"`
+}
+
 // FeedDefs_ThreadViewPost is a "threadViewPost" in the app.bsky.feed.defs schema.
 //
 // RECORDTYPE: FeedDefs_ThreadViewPost
···
 	Parent        *FeedDefs_ThreadViewPost_Parent         `json:"parent,omitempty" cborgen:"parent,omitempty"`
 	Post          *FeedDefs_PostView                      `json:"post" cborgen:"post"`
 	Replies       []*FeedDefs_ThreadViewPost_Replies_Elem `json:"replies,omitempty" cborgen:"replies,omitempty"`
+	ThreadContext *FeedDefs_ThreadContext                 `json:"threadContext,omitempty" cborgen:"threadContext,omitempty"`
 }
 
 type FeedDefs_ThreadViewPost_Parent struct {

api/bsky/feedthreadgate.go

···
 
 type FeedThreadgate_Allow_Elem struct {
 	FeedThreadgate_MentionRule   *FeedThreadgate_MentionRule
+	FeedThreadgate_FollowerRule  *FeedThreadgate_FollowerRule
 	FeedThreadgate_FollowingRule *FeedThreadgate_FollowingRule
 	FeedThreadgate_ListRule      *FeedThreadgate_ListRule
 }
···
 	if t.FeedThreadgate_MentionRule != nil {
 		t.FeedThreadgate_MentionRule.LexiconTypeID = "app.bsky.feed.threadgate#mentionRule"
 		return json.Marshal(t.FeedThreadgate_MentionRule)
+	}
+	if t.FeedThreadgate_FollowerRule != nil {
+		t.FeedThreadgate_FollowerRule.LexiconTypeID = "app.bsky.feed.threadgate#followerRule"
+		return json.Marshal(t.FeedThreadgate_FollowerRule)
 	}
 	if t.FeedThreadgate_FollowingRule != nil {
 		t.FeedThreadgate_FollowingRule.LexiconTypeID = "app.bsky.feed.threadgate#followingRule"
···
 	case "app.bsky.feed.threadgate#mentionRule":
 		t.FeedThreadgate_MentionRule = new(FeedThreadgate_MentionRule)
 		return json.Unmarshal(b, t.FeedThreadgate_MentionRule)
+	case "app.bsky.feed.threadgate#followerRule":
+		t.FeedThreadgate_FollowerRule = new(FeedThreadgate_FollowerRule)
+		return json.Unmarshal(b, t.FeedThreadgate_FollowerRule)
 	case "app.bsky.feed.threadgate#followingRule":
 		t.FeedThreadgate_FollowingRule = new(FeedThreadgate_FollowingRule)
 		return json.Unmarshal(b, t.FeedThreadgate_FollowingRule)
···
 	if t.FeedThreadgate_MentionRule != nil {
 		return t.FeedThreadgate_MentionRule.MarshalCBOR(w)
 	}
+	if t.FeedThreadgate_FollowerRule != nil {
+		return t.FeedThreadgate_FollowerRule.MarshalCBOR(w)
+	}
 	if t.FeedThreadgate_FollowingRule != nil {
 		return t.FeedThreadgate_FollowingRule.MarshalCBOR(w)
 	}
···
 	case "app.bsky.feed.threadgate#mentionRule":
 		t.FeedThreadgate_MentionRule = new(FeedThreadgate_MentionRule)
 		return t.FeedThreadgate_MentionRule.UnmarshalCBOR(bytes.NewReader(b))
+	case "app.bsky.feed.threadgate#followerRule":
+		t.FeedThreadgate_FollowerRule = new(FeedThreadgate_FollowerRule)
+		return t.FeedThreadgate_FollowerRule.UnmarshalCBOR(bytes.NewReader(b))
 	case "app.bsky.feed.threadgate#followingRule":
 		t.FeedThreadgate_FollowingRule = new(FeedThreadgate_FollowingRule)
 		return t.FeedThreadgate_FollowingRule.UnmarshalCBOR(bytes.NewReader(b))
···
 	default:
 		return nil
 	}
+}
+
+// FeedThreadgate_FollowerRule is a "followerRule" in the app.bsky.feed.threadgate schema.
+//
+// Allow replies from actors who follow you.
+//
+// RECORDTYPE: FeedThreadgate_FollowerRule
+type FeedThreadgate_FollowerRule struct {
+	LexiconTypeID string `json:"$type,const=app.bsky.feed.threadgate#followerRule" cborgen:"$type,const=app.bsky.feed.threadgate#followerRule"`
 }
 
 // FeedThreadgate_FollowingRule is a "followingRule" in the app.bsky.feed.threadgate schema.

api/ozone/moderationdefs.go

···
 	UpdatedAt     *string `json:"updatedAt,omitempty" cborgen:"updatedAt,omitempty"`
 }
 
+// ModerationDefs_AccountStats is a "accountStats" in the tools.ozone.moderation.defs schema.
+//
+// Statistics about a particular account subject
+type ModerationDefs_AccountStats struct {
+	// appealCount: Total number of appeals against a moderation action on the account
+	AppealCount *int64 `json:"appealCount,omitempty" cborgen:"appealCount,omitempty"`
+	// escalateCount: Number of times the account was escalated
+	EscalateCount *int64 `json:"escalateCount,omitempty" cborgen:"escalateCount,omitempty"`
+	// reportCount: Total number of reports on the account
+	ReportCount *int64 `json:"reportCount,omitempty" cborgen:"reportCount,omitempty"`
+	// suspendCount: Number of times the account was suspended
+	SuspendCount *int64 `json:"suspendCount,omitempty" cborgen:"suspendCount,omitempty"`
+	// takedownCount: Number of times the account was taken down
+	TakedownCount *int64 `json:"takedownCount,omitempty" cborgen:"takedownCount,omitempty"`
+}
+
 // ModerationDefs_BlobView is a "blobView" in the tools.ozone.moderation.defs schema.
 type ModerationDefs_BlobView struct {
 	Cid        string                           `json:"cid" cborgen:"cid"`
···
 	LexiconTypeID   string   `json:"$type,const=tools.ozone.moderation.defs#modEventLabel" cborgen:"$type,const=tools.ozone.moderation.defs#modEventLabel"`
 	Comment         *string  `json:"comment,omitempty" cborgen:"comment,omitempty"`
 	CreateLabelVals []string `json:"createLabelVals" cborgen:"createLabelVals"`
+	// durationInHours: Indicates how long the label will remain on the subject. Only applies on labels that are being added.
+	DurationInHours *int64   `json:"durationInHours,omitempty" cborgen:"durationInHours,omitempty"`
 	NegateLabelVals []string `json:"negateLabelVals" cborgen:"negateLabelVals"`
 }
 
···
 	Uri           string `json:"uri" cborgen:"uri"`
 }
 
+// ModerationDefs_RecordsStats is a "recordsStats" in the tools.ozone.moderation.defs schema.
+//
+// Statistics about a set of record subject items
+type ModerationDefs_RecordsStats struct {
+	// appealedCount: Number of items that were appealed at least once
+	AppealedCount *int64 `json:"appealedCount,omitempty" cborgen:"appealedCount,omitempty"`
+	// escalatedCount: Number of items that were escalated at least once
+	EscalatedCount *int64 `json:"escalatedCount,omitempty" cborgen:"escalatedCount,omitempty"`
+	// pendingCount: Number of item currently in "reviewOpen" or "reviewEscalated" state
+	PendingCount *int64 `json:"pendingCount,omitempty" cborgen:"pendingCount,omitempty"`
+	// processedCount: Number of item currently in "reviewNone" or "reviewClosed" state
+	ProcessedCount *int64 `json:"processedCount,omitempty" cborgen:"processedCount,omitempty"`
+	// reportedCount: Number of items that were reported at least once
+	ReportedCount *int64 `json:"reportedCount,omitempty" cborgen:"reportedCount,omitempty"`
+	// subjectCount: Total number of item in the set
+	SubjectCount *int64 `json:"subjectCount,omitempty" cborgen:"subjectCount,omitempty"`
+	// takendownCount: Number of item currently taken down
+	TakendownCount *int64 `json:"takendownCount,omitempty" cborgen:"takendownCount,omitempty"`
+	// totalReports: Cumulative sum of the number of reports on the items in the set
+	TotalReports *int64 `json:"totalReports,omitempty" cborgen:"totalReports,omitempty"`
+}
+
 // ModerationDefs_RepoView is a "repoView" in the tools.ozone.moderation.defs schema.
 //
 // RECORDTYPE: ModerationDefs_RepoView
···
 
 // ModerationDefs_SubjectStatusView is a "subjectStatusView" in the tools.ozone.moderation.defs schema.
 type ModerationDefs_SubjectStatusView struct {
+	// accountStats: Statistics related to the account subject
+	AccountStats *ModerationDefs_AccountStats `json:"accountStats,omitempty" cborgen:"accountStats,omitempty"`
 	// appealed: True indicates that the a previously taken moderator action was appealed against, by the author of the content. False indicates last appeal was resolved by moderators.
 	Appealed *bool `json:"appealed,omitempty" cborgen:"appealed,omitempty"`
 	// comment: Sticky comment on the subject.
···
 	Hosting   *ModerationDefs_SubjectStatusView_Hosting `json:"hosting,omitempty" cborgen:"hosting,omitempty"`
 	Id        int64                                     `json:"id" cborgen:"id"`
 	// lastAppealedAt: Timestamp referencing when the author of the subject appealed a moderation action
-	LastAppealedAt     *string                                   `json:"lastAppealedAt,omitempty" cborgen:"lastAppealedAt,omitempty"`
-	LastReportedAt     *string                                   `json:"lastReportedAt,omitempty" cborgen:"lastReportedAt,omitempty"`
-	LastReviewedAt     *string                                   `json:"lastReviewedAt,omitempty" cborgen:"lastReviewedAt,omitempty"`
-	LastReviewedBy     *string                                   `json:"lastReviewedBy,omitempty" cborgen:"lastReviewedBy,omitempty"`
-	MuteReportingUntil *string                                   `json:"muteReportingUntil,omitempty" cborgen:"muteReportingUntil,omitempty"`
-	MuteUntil          *string                                   `json:"muteUntil,omitempty" cborgen:"muteUntil,omitempty"`
-	ReviewState        *string                                   `json:"reviewState" cborgen:"reviewState"`
-	Subject            *ModerationDefs_SubjectStatusView_Subject `json:"subject" cborgen:"subject"`
-	SubjectBlobCids    []string                                  `json:"subjectBlobCids,omitempty" cborgen:"subjectBlobCids,omitempty"`
-	SubjectRepoHandle  *string                                   `json:"subjectRepoHandle,omitempty" cborgen:"subjectRepoHandle,omitempty"`
-	SuspendUntil       *string                                   `json:"suspendUntil,omitempty" cborgen:"suspendUntil,omitempty"`
-	Tags               []string                                  `json:"tags,omitempty" cborgen:"tags,omitempty"`
-	Takendown          *bool                                     `json:"takendown,omitempty" cborgen:"takendown,omitempty"`
+	LastAppealedAt     *string `json:"lastAppealedAt,omitempty" cborgen:"lastAppealedAt,omitempty"`
+	LastReportedAt     *string `json:"lastReportedAt,omitempty" cborgen:"lastReportedAt,omitempty"`
+	LastReviewedAt     *string `json:"lastReviewedAt,omitempty" cborgen:"lastReviewedAt,omitempty"`
+	LastReviewedBy     *string `json:"lastReviewedBy,omitempty" cborgen:"lastReviewedBy,omitempty"`
+	MuteReportingUntil *string `json:"muteReportingUntil,omitempty" cborgen:"muteReportingUntil,omitempty"`
+	MuteUntil          *string `json:"muteUntil,omitempty" cborgen:"muteUntil,omitempty"`
+	// recordsStats: Statistics related to the record subjects authored by the subject's account
+	RecordsStats      *ModerationDefs_RecordsStats              `json:"recordsStats,omitempty" cborgen:"recordsStats,omitempty"`
+	ReviewState       *string                                   `json:"reviewState" cborgen:"reviewState"`
+	Subject           *ModerationDefs_SubjectStatusView_Subject `json:"subject" cborgen:"subject"`
+	SubjectBlobCids   []string                                  `json:"subjectBlobCids,omitempty" cborgen:"subjectBlobCids,omitempty"`
+	SubjectRepoHandle *string                                   `json:"subjectRepoHandle,omitempty" cborgen:"subjectRepoHandle,omitempty"`
+	SuspendUntil      *string                                   `json:"suspendUntil,omitempty" cborgen:"suspendUntil,omitempty"`
+	Tags              []string                                  `json:"tags,omitempty" cborgen:"tags,omitempty"`
+	Takendown         *bool                                     `json:"takendown,omitempty" cborgen:"takendown,omitempty"`
 	// updatedAt: Timestamp referencing when the last update was made to the moderation status of the subject
 	UpdatedAt string `json:"updatedAt" cborgen:"updatedAt"`
 }

api/ozone/moderationqueryStatuses.go

···
 // includeAllUserRecords: All subjects, or subjects from given 'collections' param, belonging to the account specified in the 'subject' param will be returned.
 // includeMuted: By default, we don't include muted subjects in the results. Set this to true to include them.
 // lastReviewedBy: Get all subject statuses that were reviewed by a specific moderator
+// minAccountSuspendCount: If specified, only subjects that belong to an account that has at least this many suspensions will be returned.
+// minReportedRecordsCount: If specified, only subjects that belong to an account that has at least this many reported records will be returned.
+// minTakendownRecordsCount: If specified, only subjects that belong to an account that has at least this many taken down records will be returned.
 // onlyMuted: When set to true, only muted subjects and reporters will be returned.
 // queueCount: Number of queues being used by moderators. Subjects will be split among all queues.
 // queueIndex: Index of the queue to fetch subjects from. Works only when queueCount value is specified.
···
 // subject: The subject to get the status for.
 // subjectType: If specified, subjects of the given type (account or record) will be returned. When this is set to 'account' the 'collections' parameter will be ignored. When includeAllUserRecords or subject is set, this will be ignored.
 // takendown: Get subjects that were taken down
-func ModerationQueryStatuses(ctx context.Context, c *xrpc.Client, appealed bool, collections []string, comment string, cursor string, excludeTags []string, hostingDeletedAfter string, hostingDeletedBefore string, hostingStatuses []string, hostingUpdatedAfter string, hostingUpdatedBefore string, ignoreSubjects []string, includeAllUserRecords bool, includeMuted bool, lastReviewedBy string, limit int64, onlyMuted bool, queueCount int64, queueIndex int64, queueSeed string, reportedAfter string, reportedBefore string, reviewState string, reviewedAfter string, reviewedBefore string, sortDirection string, sortField string, subject string, subjectType string, tags []string, takendown bool) (*ModerationQueryStatuses_Output, error) {
+func ModerationQueryStatuses(ctx context.Context, c *xrpc.Client, appealed bool, collections []string, comment string, cursor string, excludeTags []string, hostingDeletedAfter string, hostingDeletedBefore string, hostingStatuses []string, hostingUpdatedAfter string, hostingUpdatedBefore string, ignoreSubjects []string, includeAllUserRecords bool, includeMuted bool, lastReviewedBy string, limit int64, minAccountSuspendCount int64, minReportedRecordsCount int64, minTakendownRecordsCount int64, onlyMuted bool, queueCount int64, queueIndex int64, queueSeed string, reportedAfter string, reportedBefore string, reviewState string, reviewedAfter string, reviewedBefore string, sortDirection string, sortField string, subject string, subjectType string, tags []string, takendown bool) (*ModerationQueryStatuses_Output, error) {
 	var out ModerationQueryStatuses_Output
 
 	params := map[string]interface{}{
-		"appealed":              appealed,
-		"collections":           collections,
-		"comment":               comment,
-		"cursor":                cursor,
-		"excludeTags":           excludeTags,
-		"hostingDeletedAfter":   hostingDeletedAfter,
-		"hostingDeletedBefore":  hostingDeletedBefore,
-		"hostingStatuses":       hostingStatuses,
-		"hostingUpdatedAfter":   hostingUpdatedAfter,
-		"hostingUpdatedBefore":  hostingUpdatedBefore,
-		"ignoreSubjects":        ignoreSubjects,
-		"includeAllUserRecords": includeAllUserRecords,
-		"includeMuted":          includeMuted,
-		"lastReviewedBy":        lastReviewedBy,
-		"limit":                 limit,
-		"onlyMuted":             onlyMuted,
-		"queueCount":            queueCount,
-		"queueIndex":            queueIndex,
-		"queueSeed":             queueSeed,
-		"reportedAfter":         reportedAfter,
-		"reportedBefore":        reportedBefore,
-		"reviewState":           reviewState,
-		"reviewedAfter":         reviewedAfter,
-		"reviewedBefore":        reviewedBefore,
-		"sortDirection":         sortDirection,
-		"sortField":             sortField,
-		"subject":               subject,
-		"subjectType":           subjectType,
-		"tags":                  tags,
-		"takendown":             takendown,
+		"appealed":                 appealed,
+		"collections":              collections,
+		"comment":                  comment,
+		"cursor":                   cursor,
+		"excludeTags":              excludeTags,
+		"hostingDeletedAfter":      hostingDeletedAfter,
+		"hostingDeletedBefore":     hostingDeletedBefore,
+		"hostingStatuses":          hostingStatuses,
+		"hostingUpdatedAfter":      hostingUpdatedAfter,
+		"hostingUpdatedBefore":     hostingUpdatedBefore,
+		"ignoreSubjects":           ignoreSubjects,
+		"includeAllUserRecords":    includeAllUserRecords,
+		"includeMuted":             includeMuted,
+		"lastReviewedBy":           lastReviewedBy,
+		"limit":                    limit,
+		"minAccountSuspendCount":   minAccountSuspendCount,
+		"minReportedRecordsCount":  minReportedRecordsCount,
+		"minTakendownRecordsCount": minTakendownRecordsCount,
+		"onlyMuted":                onlyMuted,
+		"queueCount":               queueCount,
+		"queueIndex":               queueIndex,
+		"queueSeed":                queueSeed,
+		"reportedAfter":            reportedAfter,
+		"reportedBefore":           reportedBefore,
+		"reviewState":              reviewState,
+		"reviewedAfter":            reviewedAfter,
+		"reviewedBefore":           reviewedBefore,
+		"sortDirection":            sortDirection,
+		"sortField":                sortField,
+		"subject":                  subject,
+		"subjectType":              subjectType,
+		"tags":                     tags,
+		"takendown":                takendown,
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.moderation.queryStatuses", params, nil, &out); err != nil {
 		return nil, err

gen/main.go

···
 		bsky.FeedThreadgate{},
 		bsky.FeedThreadgate_ListRule{},
 		bsky.FeedThreadgate_MentionRule{},
+		bsky.FeedThreadgate_FollowerRule{},
 		bsky.FeedThreadgate_FollowingRule{},
 		bsky.GraphStarterpack_FeedItem{},
 		bsky.GraphStarterpack{},
···
 	}
 
 	if err := genCfg.WriteMapEncodersToFile("api/atproto/cbor_gen.go", "atproto",
+		atproto.LexiconSchema{},
 		atproto.RepoStrongRef{},
 		atproto.SyncSubscribeRepos_Commit{},
 		atproto.SyncSubscribeRepos_Handle{},