moderation api v2 (event arch) lexgen+refactor (#450)

Ran lexgen against new (admin) mod api v2 ("evented architecture").
Manually removed/resolved some un-related lexicon changes (we are in a
bit of hacky-y situation still with didDoc and threadgates). Fixed the
build.

There was a weird issue with cborgen tests which mutate in-repo source
files when running tests (present on current `main`) so committed that
change.

api/atproto/admindefs.go

···
 	InvitesDisabled  *bool                    `json:"invitesDisabled,omitempty" cborgen:"invitesDisabled,omitempty"`
 }
 
-// AdminDefs_ActionReversal is a "actionReversal" in the com.atproto.admin.defs schema.
-type AdminDefs_ActionReversal struct {
-	CreatedAt string `json:"createdAt" cborgen:"createdAt"`
-	CreatedBy string `json:"createdBy" cborgen:"createdBy"`
-	Reason    string `json:"reason" cborgen:"reason"`
+// AdminDefs_BlobView is a "blobView" in the com.atproto.admin.defs schema.
+type AdminDefs_BlobView struct {
+	Cid        string                      `json:"cid" cborgen:"cid"`
+	CreatedAt  string                      `json:"createdAt" cborgen:"createdAt"`
+	Details    *AdminDefs_BlobView_Details `json:"details,omitempty" cborgen:"details,omitempty"`
+	MimeType   string                      `json:"mimeType" cborgen:"mimeType"`
+	Moderation *AdminDefs_Moderation       `json:"moderation,omitempty" cborgen:"moderation,omitempty"`
+	Size       int64                       `json:"size" cborgen:"size"`
+}
+
+type AdminDefs_BlobView_Details struct {
+	AdminDefs_ImageDetails *AdminDefs_ImageDetails
+	AdminDefs_VideoDetails *AdminDefs_VideoDetails
+}
+
+func (t *AdminDefs_BlobView_Details) MarshalJSON() ([]byte, error) {
+	if t.AdminDefs_ImageDetails != nil {
+		t.AdminDefs_ImageDetails.LexiconTypeID = "com.atproto.admin.defs#imageDetails"
+		return json.Marshal(t.AdminDefs_ImageDetails)
+	}
+	if t.AdminDefs_VideoDetails != nil {
+		t.AdminDefs_VideoDetails.LexiconTypeID = "com.atproto.admin.defs#videoDetails"
+		return json.Marshal(t.AdminDefs_VideoDetails)
+	}
+	return nil, fmt.Errorf("cannot marshal empty enum")
+}
+func (t *AdminDefs_BlobView_Details) UnmarshalJSON(b []byte) error {
+	typ, err := util.TypeExtract(b)
+	if err != nil {
+		return err
+	}
+
+	switch typ {
+	case "com.atproto.admin.defs#imageDetails":
+		t.AdminDefs_ImageDetails = new(AdminDefs_ImageDetails)
+		return json.Unmarshal(b, t.AdminDefs_ImageDetails)
+	case "com.atproto.admin.defs#videoDetails":
+		t.AdminDefs_VideoDetails = new(AdminDefs_VideoDetails)
+		return json.Unmarshal(b, t.AdminDefs_VideoDetails)
+
+	default:
+		return nil
+	}
+}
+
+// AdminDefs_ImageDetails is a "imageDetails" in the com.atproto.admin.defs schema.
+//
+// RECORDTYPE: AdminDefs_ImageDetails
+type AdminDefs_ImageDetails struct {
+	LexiconTypeID string `json:"$type,const=com.atproto.admin.defs#imageDetails" cborgen:"$type,const=com.atproto.admin.defs#imageDetails"`
+	Height        int64  `json:"height" cborgen:"height"`
+	Width         int64  `json:"width" cborgen:"width"`
+}
+
+// AdminDefs_ModEventAcknowledge is a "modEventAcknowledge" in the com.atproto.admin.defs schema.
+//
+// RECORDTYPE: AdminDefs_ModEventAcknowledge
+type AdminDefs_ModEventAcknowledge struct {
+	LexiconTypeID string  `json:"$type,const=com.atproto.admin.defs#modEventAcknowledge" cborgen:"$type,const=com.atproto.admin.defs#modEventAcknowledge"`
+	Comment       *string `json:"comment,omitempty" cborgen:"comment,omitempty"`
+}
+
+// AdminDefs_ModEventComment is a "modEventComment" in the com.atproto.admin.defs schema.
+//
+// # Add a comment to a subject
+//
+// RECORDTYPE: AdminDefs_ModEventComment
+type AdminDefs_ModEventComment struct {
+	LexiconTypeID string `json:"$type,const=com.atproto.admin.defs#modEventComment" cborgen:"$type,const=com.atproto.admin.defs#modEventComment"`
+	Comment       string `json:"comment" cborgen:"comment"`
+	// sticky: Make the comment persistent on the subject
+	Sticky *bool `json:"sticky,omitempty" cborgen:"sticky,omitempty"`
 }
 
-// AdminDefs_ActionView is a "actionView" in the com.atproto.admin.defs schema.
-type AdminDefs_ActionView struct {
-	Action          *string  `json:"action" cborgen:"action"`
-	CreateLabelVals []string `json:"createLabelVals,omitempty" cborgen:"createLabelVals,omitempty"`
-	CreatedAt       string   `json:"createdAt" cborgen:"createdAt"`
-	CreatedBy       string   `json:"createdBy" cborgen:"createdBy"`
-	// durationInHours: Indicates how long this action is meant to be in effect before automatically expiring.
-	DurationInHours   *int64                        `json:"durationInHours,omitempty" cborgen:"durationInHours,omitempty"`
-	Id                int64                         `json:"id" cborgen:"id"`
-	NegateLabelVals   []string                      `json:"negateLabelVals,omitempty" cborgen:"negateLabelVals,omitempty"`
-	Reason            string                        `json:"reason" cborgen:"reason"`
-	ResolvedReportIds []int64                       `json:"resolvedReportIds" cborgen:"resolvedReportIds"`
-	Reversal          *AdminDefs_ActionReversal     `json:"reversal,omitempty" cborgen:"reversal,omitempty"`
-	Subject           *AdminDefs_ActionView_Subject `json:"subject" cborgen:"subject"`
-	SubjectBlobCids   []string                      `json:"subjectBlobCids" cborgen:"subjectBlobCids"`
+// AdminDefs_ModEventEmail is a "modEventEmail" in the com.atproto.admin.defs schema.
+//
+// # Keep a log of outgoing email to a user
+//
+// RECORDTYPE: AdminDefs_ModEventEmail
+type AdminDefs_ModEventEmail struct {
+	LexiconTypeID string `json:"$type,const=com.atproto.admin.defs#modEventEmail" cborgen:"$type,const=com.atproto.admin.defs#modEventEmail"`
+	// subjectLine: The subject line of the email sent to the user.
+	SubjectLine string `json:"subjectLine" cborgen:"subjectLine"`
 }
 
-// AdminDefs_ActionViewCurrent is a "actionViewCurrent" in the com.atproto.admin.defs schema.
-type AdminDefs_ActionViewCurrent struct {
-	Action *string `json:"action" cborgen:"action"`
-	// durationInHours: Indicates how long this action is meant to be in effect before automatically expiring.
+// AdminDefs_ModEventEscalate is a "modEventEscalate" in the com.atproto.admin.defs schema.
+//
+// RECORDTYPE: AdminDefs_ModEventEscalate
+type AdminDefs_ModEventEscalate struct {
+	LexiconTypeID string  `json:"$type,const=com.atproto.admin.defs#modEventEscalate" cborgen:"$type,const=com.atproto.admin.defs#modEventEscalate"`
+	Comment       *string `json:"comment,omitempty" cborgen:"comment,omitempty"`
+}
+
+// AdminDefs_ModEventLabel is a "modEventLabel" in the com.atproto.admin.defs schema.
+//
+// Apply/Negate labels on a subject
+//
+// RECORDTYPE: AdminDefs_ModEventLabel
+type AdminDefs_ModEventLabel struct {
+	LexiconTypeID   string   `json:"$type,const=com.atproto.admin.defs#modEventLabel" cborgen:"$type,const=com.atproto.admin.defs#modEventLabel"`
+	Comment         *string  `json:"comment,omitempty" cborgen:"comment,omitempty"`
+	CreateLabelVals []string `json:"createLabelVals" cborgen:"createLabelVals"`
+	NegateLabelVals []string `json:"negateLabelVals" cborgen:"negateLabelVals"`
+}
+
+// AdminDefs_ModEventMute is a "modEventMute" in the com.atproto.admin.defs schema.
+//
+// # Mute incoming reports on a subject
+//
+// RECORDTYPE: AdminDefs_ModEventMute
+type AdminDefs_ModEventMute struct {
+	LexiconTypeID string  `json:"$type,const=com.atproto.admin.defs#modEventMute" cborgen:"$type,const=com.atproto.admin.defs#modEventMute"`
+	Comment       *string `json:"comment,omitempty" cborgen:"comment,omitempty"`
+	// durationInHours: Indicates how long the subject should remain muted.
+	DurationInHours int64 `json:"durationInHours" cborgen:"durationInHours"`
+}
+
+// AdminDefs_ModEventReport is a "modEventReport" in the com.atproto.admin.defs schema.
+//
+// # Report a subject
+//
+// RECORDTYPE: AdminDefs_ModEventReport
+type AdminDefs_ModEventReport struct {
+	LexiconTypeID string  `json:"$type,const=com.atproto.admin.defs#modEventReport" cborgen:"$type,const=com.atproto.admin.defs#modEventReport"`
+	Comment       *string `json:"comment,omitempty" cborgen:"comment,omitempty"`
+	ReportType    *string `json:"reportType" cborgen:"reportType"`
+}
+
+// AdminDefs_ModEventReverseTakedown is a "modEventReverseTakedown" in the com.atproto.admin.defs schema.
+//
+// # Revert take down action on a subject
+//
+// RECORDTYPE: AdminDefs_ModEventReverseTakedown
+type AdminDefs_ModEventReverseTakedown struct {
+	LexiconTypeID string `json:"$type,const=com.atproto.admin.defs#modEventReverseTakedown" cborgen:"$type,const=com.atproto.admin.defs#modEventReverseTakedown"`
+	// comment: Describe reasoning behind the reversal.
+	Comment *string `json:"comment,omitempty" cborgen:"comment,omitempty"`
+}
+
+// AdminDefs_ModEventTakedown is a "modEventTakedown" in the com.atproto.admin.defs schema.
+//
+// # Take down a subject permanently or temporarily
+//
+// RECORDTYPE: AdminDefs_ModEventTakedown
+type AdminDefs_ModEventTakedown struct {
+	LexiconTypeID string  `json:"$type,const=com.atproto.admin.defs#modEventTakedown" cborgen:"$type,const=com.atproto.admin.defs#modEventTakedown"`
+	Comment       *string `json:"comment,omitempty" cborgen:"comment,omitempty"`
+	// durationInHours: Indicates how long the takedown should be in effect before automatically expiring.
 	DurationInHours *int64 `json:"durationInHours,omitempty" cborgen:"durationInHours,omitempty"`
-	Id              int64  `json:"id" cborgen:"id"`
+}
+
+// AdminDefs_ModEventUnmute is a "modEventUnmute" in the com.atproto.admin.defs schema.
+//
+// # Unmute action on a subject
+//
+// RECORDTYPE: AdminDefs_ModEventUnmute
+type AdminDefs_ModEventUnmute struct {
+	LexiconTypeID string `json:"$type,const=com.atproto.admin.defs#modEventUnmute" cborgen:"$type,const=com.atproto.admin.defs#modEventUnmute"`
+	// comment: Describe reasoning behind the reversal.
+	Comment *string `json:"comment,omitempty" cborgen:"comment,omitempty"`
+}
+
+// AdminDefs_ModEventView is a "modEventView" in the com.atproto.admin.defs schema.
+type AdminDefs_ModEventView struct {
+	CreatedAt       string                          `json:"createdAt" cborgen:"createdAt"`
+	CreatedBy       string                          `json:"createdBy" cborgen:"createdBy"`
+	CreatorHandle   *string                         `json:"creatorHandle,omitempty" cborgen:"creatorHandle,omitempty"`
+	Event           *AdminDefs_ModEventView_Event   `json:"event" cborgen:"event"`
+	Id              int64                           `json:"id" cborgen:"id"`
+	Subject         *AdminDefs_ModEventView_Subject `json:"subject" cborgen:"subject"`
+	SubjectBlobCids []string                        `json:"subjectBlobCids" cborgen:"subjectBlobCids"`
+	SubjectHandle   *string                         `json:"subjectHandle,omitempty" cborgen:"subjectHandle,omitempty"`
+}
+
+// AdminDefs_ModEventViewDetail is a "modEventViewDetail" in the com.atproto.admin.defs schema.
+type AdminDefs_ModEventViewDetail struct {
+	CreatedAt    string                                `json:"createdAt" cborgen:"createdAt"`
+	CreatedBy    string                                `json:"createdBy" cborgen:"createdBy"`
+	Event        *AdminDefs_ModEventViewDetail_Event   `json:"event" cborgen:"event"`
+	Id           int64                                 `json:"id" cborgen:"id"`
+	Subject      *AdminDefs_ModEventViewDetail_Subject `json:"subject" cborgen:"subject"`
+	SubjectBlobs []*AdminDefs_BlobView                 `json:"subjectBlobs" cborgen:"subjectBlobs"`
 }
 
-// AdminDefs_ActionViewDetail is a "actionViewDetail" in the com.atproto.admin.defs schema.
-type AdminDefs_ActionViewDetail struct {
-	Action          *string  `json:"action" cborgen:"action"`
-	CreateLabelVals []string `json:"createLabelVals,omitempty" cborgen:"createLabelVals,omitempty"`
-	CreatedAt       string   `json:"createdAt" cborgen:"createdAt"`
-	CreatedBy       string   `json:"createdBy" cborgen:"createdBy"`
-	// durationInHours: Indicates how long this action is meant to be in effect before automatically expiring.
-	DurationInHours *int64                              `json:"durationInHours,omitempty" cborgen:"durationInHours,omitempty"`
-	Id              int64                               `json:"id" cborgen:"id"`
-	NegateLabelVals []string                            `json:"negateLabelVals,omitempty" cborgen:"negateLabelVals,omitempty"`
-	Reason          string                              `json:"reason" cborgen:"reason"`
-	ResolvedReports []*AdminDefs_ReportView             `json:"resolvedReports" cborgen:"resolvedReports"`
-	Reversal        *AdminDefs_ActionReversal           `json:"reversal,omitempty" cborgen:"reversal,omitempty"`
-	Subject         *AdminDefs_ActionViewDetail_Subject `json:"subject" cborgen:"subject"`
-	SubjectBlobs    []*AdminDefs_BlobView               `json:"subjectBlobs" cborgen:"subjectBlobs"`
+type AdminDefs_ModEventViewDetail_Event struct {
+	AdminDefs_ModEventTakedown        *AdminDefs_ModEventTakedown
+	AdminDefs_ModEventReverseTakedown *AdminDefs_ModEventReverseTakedown
+	AdminDefs_ModEventComment         *AdminDefs_ModEventComment
+	AdminDefs_ModEventReport          *AdminDefs_ModEventReport
+	AdminDefs_ModEventLabel           *AdminDefs_ModEventLabel
+	AdminDefs_ModEventAcknowledge     *AdminDefs_ModEventAcknowledge
+	AdminDefs_ModEventEscalate        *AdminDefs_ModEventEscalate
+	AdminDefs_ModEventMute            *AdminDefs_ModEventMute
 }
 
-type AdminDefs_ActionViewDetail_Subject struct {
+func (t *AdminDefs_ModEventViewDetail_Event) MarshalJSON() ([]byte, error) {
+	if t.AdminDefs_ModEventTakedown != nil {
+		t.AdminDefs_ModEventTakedown.LexiconTypeID = "com.atproto.admin.defs#modEventTakedown"
+		return json.Marshal(t.AdminDefs_ModEventTakedown)
+	}
+	if t.AdminDefs_ModEventReverseTakedown != nil {
+		t.AdminDefs_ModEventReverseTakedown.LexiconTypeID = "com.atproto.admin.defs#modEventReverseTakedown"
+		return json.Marshal(t.AdminDefs_ModEventReverseTakedown)
+	}
+	if t.AdminDefs_ModEventComment != nil {
+		t.AdminDefs_ModEventComment.LexiconTypeID = "com.atproto.admin.defs#modEventComment"
+		return json.Marshal(t.AdminDefs_ModEventComment)
+	}
+	if t.AdminDefs_ModEventReport != nil {
+		t.AdminDefs_ModEventReport.LexiconTypeID = "com.atproto.admin.defs#modEventReport"
+		return json.Marshal(t.AdminDefs_ModEventReport)
+	}
+	if t.AdminDefs_ModEventLabel != nil {
+		t.AdminDefs_ModEventLabel.LexiconTypeID = "com.atproto.admin.defs#modEventLabel"
+		return json.Marshal(t.AdminDefs_ModEventLabel)
+	}
+	if t.AdminDefs_ModEventAcknowledge != nil {
+		t.AdminDefs_ModEventAcknowledge.LexiconTypeID = "com.atproto.admin.defs#modEventAcknowledge"
+		return json.Marshal(t.AdminDefs_ModEventAcknowledge)
+	}
+	if t.AdminDefs_ModEventEscalate != nil {
+		t.AdminDefs_ModEventEscalate.LexiconTypeID = "com.atproto.admin.defs#modEventEscalate"
+		return json.Marshal(t.AdminDefs_ModEventEscalate)
+	}
+	if t.AdminDefs_ModEventMute != nil {
+		t.AdminDefs_ModEventMute.LexiconTypeID = "com.atproto.admin.defs#modEventMute"
+		return json.Marshal(t.AdminDefs_ModEventMute)
+	}
+	return nil, fmt.Errorf("cannot marshal empty enum")
+}
+func (t *AdminDefs_ModEventViewDetail_Event) UnmarshalJSON(b []byte) error {
+	typ, err := util.TypeExtract(b)
+	if err != nil {
+		return err
+	}
+
+	switch typ {
+	case "com.atproto.admin.defs#modEventTakedown":
+		t.AdminDefs_ModEventTakedown = new(AdminDefs_ModEventTakedown)
+		return json.Unmarshal(b, t.AdminDefs_ModEventTakedown)
+	case "com.atproto.admin.defs#modEventReverseTakedown":
+		t.AdminDefs_ModEventReverseTakedown = new(AdminDefs_ModEventReverseTakedown)
+		return json.Unmarshal(b, t.AdminDefs_ModEventReverseTakedown)
+	case "com.atproto.admin.defs#modEventComment":
+		t.AdminDefs_ModEventComment = new(AdminDefs_ModEventComment)
+		return json.Unmarshal(b, t.AdminDefs_ModEventComment)
+	case "com.atproto.admin.defs#modEventReport":
+		t.AdminDefs_ModEventReport = new(AdminDefs_ModEventReport)
+		return json.Unmarshal(b, t.AdminDefs_ModEventReport)
+	case "com.atproto.admin.defs#modEventLabel":
+		t.AdminDefs_ModEventLabel = new(AdminDefs_ModEventLabel)
+		return json.Unmarshal(b, t.AdminDefs_ModEventLabel)
+	case "com.atproto.admin.defs#modEventAcknowledge":
+		t.AdminDefs_ModEventAcknowledge = new(AdminDefs_ModEventAcknowledge)
+		return json.Unmarshal(b, t.AdminDefs_ModEventAcknowledge)
+	case "com.atproto.admin.defs#modEventEscalate":
+		t.AdminDefs_ModEventEscalate = new(AdminDefs_ModEventEscalate)
+		return json.Unmarshal(b, t.AdminDefs_ModEventEscalate)
+	case "com.atproto.admin.defs#modEventMute":
+		t.AdminDefs_ModEventMute = new(AdminDefs_ModEventMute)
+		return json.Unmarshal(b, t.AdminDefs_ModEventMute)
+
+	default:
+		return nil
+	}
+}
+
+type AdminDefs_ModEventViewDetail_Subject struct {
 	AdminDefs_RepoView           *AdminDefs_RepoView
 	AdminDefs_RepoViewNotFound   *AdminDefs_RepoViewNotFound
 	AdminDefs_RecordView         *AdminDefs_RecordView
 	AdminDefs_RecordViewNotFound *AdminDefs_RecordViewNotFound
 }
 
-func (t *AdminDefs_ActionViewDetail_Subject) MarshalJSON() ([]byte, error) {
+func (t *AdminDefs_ModEventViewDetail_Subject) MarshalJSON() ([]byte, error) {
 	if t.AdminDefs_RepoView != nil {
 		t.AdminDefs_RepoView.LexiconTypeID = "com.atproto.admin.defs#repoView"
 		return json.Marshal(t.AdminDefs_RepoView)
···
 	}
 	return nil, fmt.Errorf("cannot marshal empty enum")
 }
-func (t *AdminDefs_ActionViewDetail_Subject) UnmarshalJSON(b []byte) error {
+func (t *AdminDefs_ModEventViewDetail_Subject) UnmarshalJSON(b []byte) error {
 	typ, err := util.TypeExtract(b)
 	if err != nil {
 		return err
···
 	}
 }
 
-type AdminDefs_ActionView_Subject struct {
-	AdminDefs_RepoRef *AdminDefs_RepoRef
-	RepoStrongRef     *RepoStrongRef
+type AdminDefs_ModEventView_Event struct {
+	AdminDefs_ModEventTakedown        *AdminDefs_ModEventTakedown
+	AdminDefs_ModEventReverseTakedown *AdminDefs_ModEventReverseTakedown
+	AdminDefs_ModEventComment         *AdminDefs_ModEventComment
+	AdminDefs_ModEventReport          *AdminDefs_ModEventReport
+	AdminDefs_ModEventLabel           *AdminDefs_ModEventLabel
+	AdminDefs_ModEventAcknowledge     *AdminDefs_ModEventAcknowledge
+	AdminDefs_ModEventEscalate        *AdminDefs_ModEventEscalate
+	AdminDefs_ModEventMute            *AdminDefs_ModEventMute
+	AdminDefs_ModEventEmail           *AdminDefs_ModEventEmail
 }
 
-func (t *AdminDefs_ActionView_Subject) MarshalJSON() ([]byte, error) {
-	if t.AdminDefs_RepoRef != nil {
-		t.AdminDefs_RepoRef.LexiconTypeID = "com.atproto.admin.defs#repoRef"
-		return json.Marshal(t.AdminDefs_RepoRef)
+func (t *AdminDefs_ModEventView_Event) MarshalJSON() ([]byte, error) {
+	if t.AdminDefs_ModEventTakedown != nil {
+		t.AdminDefs_ModEventTakedown.LexiconTypeID = "com.atproto.admin.defs#modEventTakedown"
+		return json.Marshal(t.AdminDefs_ModEventTakedown)
+	}
+	if t.AdminDefs_ModEventReverseTakedown != nil {
+		t.AdminDefs_ModEventReverseTakedown.LexiconTypeID = "com.atproto.admin.defs#modEventReverseTakedown"
+		return json.Marshal(t.AdminDefs_ModEventReverseTakedown)
 	}
-	if t.RepoStrongRef != nil {
-		t.RepoStrongRef.LexiconTypeID = "com.atproto.repo.strongRef"
-		return json.Marshal(t.RepoStrongRef)
+	if t.AdminDefs_ModEventComment != nil {
+		t.AdminDefs_ModEventComment.LexiconTypeID = "com.atproto.admin.defs#modEventComment"
+		return json.Marshal(t.AdminDefs_ModEventComment)
+	}
+	if t.AdminDefs_ModEventReport != nil {
+		t.AdminDefs_ModEventReport.LexiconTypeID = "com.atproto.admin.defs#modEventReport"
+		return json.Marshal(t.AdminDefs_ModEventReport)
+	}
+	if t.AdminDefs_ModEventLabel != nil {
+		t.AdminDefs_ModEventLabel.LexiconTypeID = "com.atproto.admin.defs#modEventLabel"
+		return json.Marshal(t.AdminDefs_ModEventLabel)
+	}
+	if t.AdminDefs_ModEventAcknowledge != nil {
+		t.AdminDefs_ModEventAcknowledge.LexiconTypeID = "com.atproto.admin.defs#modEventAcknowledge"
+		return json.Marshal(t.AdminDefs_ModEventAcknowledge)
+	}
+	if t.AdminDefs_ModEventEscalate != nil {
+		t.AdminDefs_ModEventEscalate.LexiconTypeID = "com.atproto.admin.defs#modEventEscalate"
+		return json.Marshal(t.AdminDefs_ModEventEscalate)
+	}
+	if t.AdminDefs_ModEventMute != nil {
+		t.AdminDefs_ModEventMute.LexiconTypeID = "com.atproto.admin.defs#modEventMute"
+		return json.Marshal(t.AdminDefs_ModEventMute)
+	}
+	if t.AdminDefs_ModEventEmail != nil {
+		t.AdminDefs_ModEventEmail.LexiconTypeID = "com.atproto.admin.defs#modEventEmail"
+		return json.Marshal(t.AdminDefs_ModEventEmail)
 	}
 	return nil, fmt.Errorf("cannot marshal empty enum")
 }
-func (t *AdminDefs_ActionView_Subject) UnmarshalJSON(b []byte) error {
+func (t *AdminDefs_ModEventView_Event) UnmarshalJSON(b []byte) error {
 	typ, err := util.TypeExtract(b)
 	if err != nil {
 		return err
 	}
 
 	switch typ {
-	case "com.atproto.admin.defs#repoRef":
-		t.AdminDefs_RepoRef = new(AdminDefs_RepoRef)
-		return json.Unmarshal(b, t.AdminDefs_RepoRef)
-	case "com.atproto.repo.strongRef":
-		t.RepoStrongRef = new(RepoStrongRef)
-		return json.Unmarshal(b, t.RepoStrongRef)
+	case "com.atproto.admin.defs#modEventTakedown":
+		t.AdminDefs_ModEventTakedown = new(AdminDefs_ModEventTakedown)
+		return json.Unmarshal(b, t.AdminDefs_ModEventTakedown)
+	case "com.atproto.admin.defs#modEventReverseTakedown":
+		t.AdminDefs_ModEventReverseTakedown = new(AdminDefs_ModEventReverseTakedown)
+		return json.Unmarshal(b, t.AdminDefs_ModEventReverseTakedown)
+	case "com.atproto.admin.defs#modEventComment":
+		t.AdminDefs_ModEventComment = new(AdminDefs_ModEventComment)
+		return json.Unmarshal(b, t.AdminDefs_ModEventComment)
+	case "com.atproto.admin.defs#modEventReport":
+		t.AdminDefs_ModEventReport = new(AdminDefs_ModEventReport)
+		return json.Unmarshal(b, t.AdminDefs_ModEventReport)
+	case "com.atproto.admin.defs#modEventLabel":
+		t.AdminDefs_ModEventLabel = new(AdminDefs_ModEventLabel)
+		return json.Unmarshal(b, t.AdminDefs_ModEventLabel)
+	case "com.atproto.admin.defs#modEventAcknowledge":
+		t.AdminDefs_ModEventAcknowledge = new(AdminDefs_ModEventAcknowledge)
+		return json.Unmarshal(b, t.AdminDefs_ModEventAcknowledge)
+	case "com.atproto.admin.defs#modEventEscalate":
+		t.AdminDefs_ModEventEscalate = new(AdminDefs_ModEventEscalate)
+		return json.Unmarshal(b, t.AdminDefs_ModEventEscalate)
+	case "com.atproto.admin.defs#modEventMute":
+		t.AdminDefs_ModEventMute = new(AdminDefs_ModEventMute)
+		return json.Unmarshal(b, t.AdminDefs_ModEventMute)
+	case "com.atproto.admin.defs#modEventEmail":
+		t.AdminDefs_ModEventEmail = new(AdminDefs_ModEventEmail)
+		return json.Unmarshal(b, t.AdminDefs_ModEventEmail)
 
 	default:
 		return nil
 	}
 }
 
-// AdminDefs_BlobView is a "blobView" in the com.atproto.admin.defs schema.
-type AdminDefs_BlobView struct {
-	Cid        string                      `json:"cid" cborgen:"cid"`
-	CreatedAt  string                      `json:"createdAt" cborgen:"createdAt"`
-	Details    *AdminDefs_BlobView_Details `json:"details,omitempty" cborgen:"details,omitempty"`
-	MimeType   string                      `json:"mimeType" cborgen:"mimeType"`
-	Moderation *AdminDefs_Moderation       `json:"moderation,omitempty" cborgen:"moderation,omitempty"`
-	Size       int64                       `json:"size" cborgen:"size"`
+type AdminDefs_ModEventView_Subject struct {
+	AdminDefs_RepoRef *AdminDefs_RepoRef
+	RepoStrongRef     *RepoStrongRef
 }
 
-type AdminDefs_BlobView_Details struct {
-	AdminDefs_ImageDetails *AdminDefs_ImageDetails
-	AdminDefs_VideoDetails *AdminDefs_VideoDetails
-}
-
-func (t *AdminDefs_BlobView_Details) MarshalJSON() ([]byte, error) {
-	if t.AdminDefs_ImageDetails != nil {
-		t.AdminDefs_ImageDetails.LexiconTypeID = "com.atproto.admin.defs#imageDetails"
-		return json.Marshal(t.AdminDefs_ImageDetails)
+func (t *AdminDefs_ModEventView_Subject) MarshalJSON() ([]byte, error) {
+	if t.AdminDefs_RepoRef != nil {
+		t.AdminDefs_RepoRef.LexiconTypeID = "com.atproto.admin.defs#repoRef"
+		return json.Marshal(t.AdminDefs_RepoRef)
 	}
-	if t.AdminDefs_VideoDetails != nil {
-		t.AdminDefs_VideoDetails.LexiconTypeID = "com.atproto.admin.defs#videoDetails"
-		return json.Marshal(t.AdminDefs_VideoDetails)
+	if t.RepoStrongRef != nil {
+		t.RepoStrongRef.LexiconTypeID = "com.atproto.repo.strongRef"
+		return json.Marshal(t.RepoStrongRef)
 	}
 	return nil, fmt.Errorf("cannot marshal empty enum")
 }
-func (t *AdminDefs_BlobView_Details) UnmarshalJSON(b []byte) error {
+func (t *AdminDefs_ModEventView_Subject) UnmarshalJSON(b []byte) error {
 	typ, err := util.TypeExtract(b)
 	if err != nil {
 		return err
 	}
 
 	switch typ {
-	case "com.atproto.admin.defs#imageDetails":
-		t.AdminDefs_ImageDetails = new(AdminDefs_ImageDetails)
-		return json.Unmarshal(b, t.AdminDefs_ImageDetails)
-	case "com.atproto.admin.defs#videoDetails":
-		t.AdminDefs_VideoDetails = new(AdminDefs_VideoDetails)
-		return json.Unmarshal(b, t.AdminDefs_VideoDetails)
+	case "com.atproto.admin.defs#repoRef":
+		t.AdminDefs_RepoRef = new(AdminDefs_RepoRef)
+		return json.Unmarshal(b, t.AdminDefs_RepoRef)
+	case "com.atproto.repo.strongRef":
+		t.RepoStrongRef = new(RepoStrongRef)
+		return json.Unmarshal(b, t.RepoStrongRef)
 
 	default:
 		return nil
 	}
 }
 
-// AdminDefs_ImageDetails is a "imageDetails" in the com.atproto.admin.defs schema.
-//
-// RECORDTYPE: AdminDefs_ImageDetails
-type AdminDefs_ImageDetails struct {
-	LexiconTypeID string `json:"$type,const=com.atproto.admin.defs#imageDetails" cborgen:"$type,const=com.atproto.admin.defs#imageDetails"`
-	Height        int64  `json:"height" cborgen:"height"`
-	Width         int64  `json:"width" cborgen:"width"`
-}
-
 // AdminDefs_Moderation is a "moderation" in the com.atproto.admin.defs schema.
 type AdminDefs_Moderation struct {
-	CurrentAction *AdminDefs_ActionViewCurrent `json:"currentAction,omitempty" cborgen:"currentAction,omitempty"`
+	SubjectStatus *AdminDefs_SubjectStatusView `json:"subjectStatus,omitempty" cborgen:"subjectStatus,omitempty"`
 }
 
 // AdminDefs_ModerationDetail is a "moderationDetail" in the com.atproto.admin.defs schema.
 type AdminDefs_ModerationDetail struct {
-	Actions       []*AdminDefs_ActionView      `json:"actions" cborgen:"actions"`
-	CurrentAction *AdminDefs_ActionViewCurrent `json:"currentAction,omitempty" cborgen:"currentAction,omitempty"`
-	Reports       []*AdminDefs_ReportView      `json:"reports" cborgen:"reports"`
+	SubjectStatus *AdminDefs_SubjectStatusView `json:"subjectStatus,omitempty" cborgen:"subjectStatus,omitempty"`
 }
 
 // AdminDefs_RecordView is a "recordView" in the com.atproto.admin.defs schema.
···
 
 // AdminDefs_ReportView is a "reportView" in the com.atproto.admin.defs schema.
 type AdminDefs_ReportView struct {
+	Comment             *string                       `json:"comment,omitempty" cborgen:"comment,omitempty"`
 	CreatedAt           string                        `json:"createdAt" cborgen:"createdAt"`
 	Id                  int64                         `json:"id" cborgen:"id"`
-	Reason              *string                       `json:"reason,omitempty" cborgen:"reason,omitempty"`
 	ReasonType          *string                       `json:"reasonType" cborgen:"reasonType"`
 	ReportedBy          string                        `json:"reportedBy" cborgen:"reportedBy"`
 	ResolvedByActionIds []int64                       `json:"resolvedByActionIds" cborgen:"resolvedByActionIds"`
···
 
 // AdminDefs_ReportViewDetail is a "reportViewDetail" in the com.atproto.admin.defs schema.
 type AdminDefs_ReportViewDetail struct {
+	Comment           *string                             `json:"comment,omitempty" cborgen:"comment,omitempty"`
 	CreatedAt         string                              `json:"createdAt" cborgen:"createdAt"`
 	Id                int64                               `json:"id" cborgen:"id"`
-	Reason            *string                             `json:"reason,omitempty" cborgen:"reason,omitempty"`
 	ReasonType        *string                             `json:"reasonType" cborgen:"reasonType"`
 	ReportedBy        string                              `json:"reportedBy" cborgen:"reportedBy"`
-	ResolvedByActions []*AdminDefs_ActionView             `json:"resolvedByActions" cborgen:"resolvedByActions"`
+	ResolvedByActions []*AdminDefs_ModEventView           `json:"resolvedByActions" cborgen:"resolvedByActions"`
 	Subject           *AdminDefs_ReportViewDetail_Subject `json:"subject" cborgen:"subject"`
+	SubjectStatus     *AdminDefs_SubjectStatusView        `json:"subjectStatus,omitempty" cborgen:"subjectStatus,omitempty"`
 }
 
 type AdminDefs_ReportViewDetail_Subject struct {
···
 type AdminDefs_StatusAttr struct {
 	Applied bool    `json:"applied" cborgen:"applied"`
 	Ref     *string `json:"ref,omitempty" cborgen:"ref,omitempty"`
+}
+
+// AdminDefs_SubjectStatusView is a "subjectStatusView" in the com.atproto.admin.defs schema.
+type AdminDefs_SubjectStatusView struct {
+	// comment: Sticky comment on the subject.
+	Comment *string `json:"comment,omitempty" cborgen:"comment,omitempty"`
+	// createdAt: Timestamp referencing the first moderation status impacting event was emitted on the subject
+	CreatedAt         string                               `json:"createdAt" cborgen:"createdAt"`
+	Id                int64                                `json:"id" cborgen:"id"`
+	LastReportedAt    *string                              `json:"lastReportedAt,omitempty" cborgen:"lastReportedAt,omitempty"`
+	LastReviewedAt    *string                              `json:"lastReviewedAt,omitempty" cborgen:"lastReviewedAt,omitempty"`
+	LastReviewedBy    *string                              `json:"lastReviewedBy,omitempty" cborgen:"lastReviewedBy,omitempty"`
+	MuteUntil         *string                              `json:"muteUntil,omitempty" cborgen:"muteUntil,omitempty"`
+	ReviewState       *string                              `json:"reviewState" cborgen:"reviewState"`
+	Subject           *AdminDefs_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"`
+	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"`
+}
+
+type AdminDefs_SubjectStatusView_Subject struct {
+	AdminDefs_RepoRef *AdminDefs_RepoRef
+	RepoStrongRef     *RepoStrongRef
+}
+
+func (t *AdminDefs_SubjectStatusView_Subject) MarshalJSON() ([]byte, error) {
+	if t.AdminDefs_RepoRef != nil {
+		t.AdminDefs_RepoRef.LexiconTypeID = "com.atproto.admin.defs#repoRef"
+		return json.Marshal(t.AdminDefs_RepoRef)
+	}
+	if t.RepoStrongRef != nil {
+		t.RepoStrongRef.LexiconTypeID = "com.atproto.repo.strongRef"
+		return json.Marshal(t.RepoStrongRef)
+	}
+	return nil, fmt.Errorf("cannot marshal empty enum")
+}
+func (t *AdminDefs_SubjectStatusView_Subject) UnmarshalJSON(b []byte) error {
+	typ, err := util.TypeExtract(b)
+	if err != nil {
+		return err
+	}
+
+	switch typ {
+	case "com.atproto.admin.defs#repoRef":
+		t.AdminDefs_RepoRef = new(AdminDefs_RepoRef)
+		return json.Unmarshal(b, t.AdminDefs_RepoRef)
+	case "com.atproto.repo.strongRef":
+		t.RepoStrongRef = new(RepoStrongRef)
+		return json.Unmarshal(b, t.RepoStrongRef)
+
+	default:
+		return nil
+	}
 }
 
 // AdminDefs_VideoDetails is a "videoDetails" in the com.atproto.admin.defs schema.

api/atproto/adminemitModerationEvent.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+package atproto
+
+// schema: com.atproto.admin.emitModerationEvent
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"github.com/bluesky-social/indigo/lex/util"
+	"github.com/bluesky-social/indigo/xrpc"
+)
+
+// AdminEmitModerationEvent_Input is the input argument to a com.atproto.admin.emitModerationEvent call.
+type AdminEmitModerationEvent_Input struct {
+	CreatedBy       string                                  `json:"createdBy" cborgen:"createdBy"`
+	Event           *AdminEmitModerationEvent_Input_Event   `json:"event" cborgen:"event"`
+	Subject         *AdminEmitModerationEvent_Input_Subject `json:"subject" cborgen:"subject"`
+	SubjectBlobCids []string                                `json:"subjectBlobCids,omitempty" cborgen:"subjectBlobCids,omitempty"`
+}
+
+type AdminEmitModerationEvent_Input_Event struct {
+	AdminDefs_ModEventTakedown        *AdminDefs_ModEventTakedown
+	AdminDefs_ModEventAcknowledge     *AdminDefs_ModEventAcknowledge
+	AdminDefs_ModEventEscalate        *AdminDefs_ModEventEscalate
+	AdminDefs_ModEventComment         *AdminDefs_ModEventComment
+	AdminDefs_ModEventLabel           *AdminDefs_ModEventLabel
+	AdminDefs_ModEventReport          *AdminDefs_ModEventReport
+	AdminDefs_ModEventMute            *AdminDefs_ModEventMute
+	AdminDefs_ModEventReverseTakedown *AdminDefs_ModEventReverseTakedown
+	AdminDefs_ModEventUnmute          *AdminDefs_ModEventUnmute
+	AdminDefs_ModEventEmail           *AdminDefs_ModEventEmail
+}
+
+func (t *AdminEmitModerationEvent_Input_Event) MarshalJSON() ([]byte, error) {
+	if t.AdminDefs_ModEventTakedown != nil {
+		t.AdminDefs_ModEventTakedown.LexiconTypeID = "com.atproto.admin.defs#modEventTakedown"
+		return json.Marshal(t.AdminDefs_ModEventTakedown)
+	}
+	if t.AdminDefs_ModEventAcknowledge != nil {
+		t.AdminDefs_ModEventAcknowledge.LexiconTypeID = "com.atproto.admin.defs#modEventAcknowledge"
+		return json.Marshal(t.AdminDefs_ModEventAcknowledge)
+	}
+	if t.AdminDefs_ModEventEscalate != nil {
+		t.AdminDefs_ModEventEscalate.LexiconTypeID = "com.atproto.admin.defs#modEventEscalate"
+		return json.Marshal(t.AdminDefs_ModEventEscalate)
+	}
+	if t.AdminDefs_ModEventComment != nil {
+		t.AdminDefs_ModEventComment.LexiconTypeID = "com.atproto.admin.defs#modEventComment"
+		return json.Marshal(t.AdminDefs_ModEventComment)
+	}
+	if t.AdminDefs_ModEventLabel != nil {
+		t.AdminDefs_ModEventLabel.LexiconTypeID = "com.atproto.admin.defs#modEventLabel"
+		return json.Marshal(t.AdminDefs_ModEventLabel)
+	}
+	if t.AdminDefs_ModEventReport != nil {
+		t.AdminDefs_ModEventReport.LexiconTypeID = "com.atproto.admin.defs#modEventReport"
+		return json.Marshal(t.AdminDefs_ModEventReport)
+	}
+	if t.AdminDefs_ModEventMute != nil {
+		t.AdminDefs_ModEventMute.LexiconTypeID = "com.atproto.admin.defs#modEventMute"
+		return json.Marshal(t.AdminDefs_ModEventMute)
+	}
+	if t.AdminDefs_ModEventReverseTakedown != nil {
+		t.AdminDefs_ModEventReverseTakedown.LexiconTypeID = "com.atproto.admin.defs#modEventReverseTakedown"
+		return json.Marshal(t.AdminDefs_ModEventReverseTakedown)
+	}
+	if t.AdminDefs_ModEventUnmute != nil {
+		t.AdminDefs_ModEventUnmute.LexiconTypeID = "com.atproto.admin.defs#modEventUnmute"
+		return json.Marshal(t.AdminDefs_ModEventUnmute)
+	}
+	if t.AdminDefs_ModEventEmail != nil {
+		t.AdminDefs_ModEventEmail.LexiconTypeID = "com.atproto.admin.defs#modEventEmail"
+		return json.Marshal(t.AdminDefs_ModEventEmail)
+	}
+	return nil, fmt.Errorf("cannot marshal empty enum")
+}
+func (t *AdminEmitModerationEvent_Input_Event) UnmarshalJSON(b []byte) error {
+	typ, err := util.TypeExtract(b)
+	if err != nil {
+		return err
+	}
+
+	switch typ {
+	case "com.atproto.admin.defs#modEventTakedown":
+		t.AdminDefs_ModEventTakedown = new(AdminDefs_ModEventTakedown)
+		return json.Unmarshal(b, t.AdminDefs_ModEventTakedown)
+	case "com.atproto.admin.defs#modEventAcknowledge":
+		t.AdminDefs_ModEventAcknowledge = new(AdminDefs_ModEventAcknowledge)
+		return json.Unmarshal(b, t.AdminDefs_ModEventAcknowledge)
+	case "com.atproto.admin.defs#modEventEscalate":
+		t.AdminDefs_ModEventEscalate = new(AdminDefs_ModEventEscalate)
+		return json.Unmarshal(b, t.AdminDefs_ModEventEscalate)
+	case "com.atproto.admin.defs#modEventComment":
+		t.AdminDefs_ModEventComment = new(AdminDefs_ModEventComment)
+		return json.Unmarshal(b, t.AdminDefs_ModEventComment)
+	case "com.atproto.admin.defs#modEventLabel":
+		t.AdminDefs_ModEventLabel = new(AdminDefs_ModEventLabel)
+		return json.Unmarshal(b, t.AdminDefs_ModEventLabel)
+	case "com.atproto.admin.defs#modEventReport":
+		t.AdminDefs_ModEventReport = new(AdminDefs_ModEventReport)
+		return json.Unmarshal(b, t.AdminDefs_ModEventReport)
+	case "com.atproto.admin.defs#modEventMute":
+		t.AdminDefs_ModEventMute = new(AdminDefs_ModEventMute)
+		return json.Unmarshal(b, t.AdminDefs_ModEventMute)
+	case "com.atproto.admin.defs#modEventReverseTakedown":
+		t.AdminDefs_ModEventReverseTakedown = new(AdminDefs_ModEventReverseTakedown)
+		return json.Unmarshal(b, t.AdminDefs_ModEventReverseTakedown)
+	case "com.atproto.admin.defs#modEventUnmute":
+		t.AdminDefs_ModEventUnmute = new(AdminDefs_ModEventUnmute)
+		return json.Unmarshal(b, t.AdminDefs_ModEventUnmute)
+	case "com.atproto.admin.defs#modEventEmail":
+		t.AdminDefs_ModEventEmail = new(AdminDefs_ModEventEmail)
+		return json.Unmarshal(b, t.AdminDefs_ModEventEmail)
+
+	default:
+		return nil
+	}
+}
+
+type AdminEmitModerationEvent_Input_Subject struct {
+	AdminDefs_RepoRef *AdminDefs_RepoRef
+	RepoStrongRef     *RepoStrongRef
+}
+
+func (t *AdminEmitModerationEvent_Input_Subject) MarshalJSON() ([]byte, error) {
+	if t.AdminDefs_RepoRef != nil {
+		t.AdminDefs_RepoRef.LexiconTypeID = "com.atproto.admin.defs#repoRef"
+		return json.Marshal(t.AdminDefs_RepoRef)
+	}
+	if t.RepoStrongRef != nil {
+		t.RepoStrongRef.LexiconTypeID = "com.atproto.repo.strongRef"
+		return json.Marshal(t.RepoStrongRef)
+	}
+	return nil, fmt.Errorf("cannot marshal empty enum")
+}
+func (t *AdminEmitModerationEvent_Input_Subject) UnmarshalJSON(b []byte) error {
+	typ, err := util.TypeExtract(b)
+	if err != nil {
+		return err
+	}
+
+	switch typ {
+	case "com.atproto.admin.defs#repoRef":
+		t.AdminDefs_RepoRef = new(AdminDefs_RepoRef)
+		return json.Unmarshal(b, t.AdminDefs_RepoRef)
+	case "com.atproto.repo.strongRef":
+		t.RepoStrongRef = new(RepoStrongRef)
+		return json.Unmarshal(b, t.RepoStrongRef)
+
+	default:
+		return nil
+	}
+}
+
+// AdminEmitModerationEvent calls the XRPC method "com.atproto.admin.emitModerationEvent".
+func AdminEmitModerationEvent(ctx context.Context, c *xrpc.Client, input *AdminEmitModerationEvent_Input) (*AdminDefs_ModEventView, error) {
+	var out AdminDefs_ModEventView
+	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.admin.emitModerationEvent", nil, input, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/admingetModerationAction.go

···
-// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
-
-package atproto
-
-// schema: com.atproto.admin.getModerationAction
-
-import (
-	"context"
-
-	"github.com/bluesky-social/indigo/xrpc"
-)
-
-// AdminGetModerationAction calls the XRPC method "com.atproto.admin.getModerationAction".
-func AdminGetModerationAction(ctx context.Context, c *xrpc.Client, id int64) (*AdminDefs_ActionViewDetail, error) {
-	var out AdminDefs_ActionViewDetail
-
-	params := map[string]interface{}{
-		"id": id,
-	}
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.admin.getModerationAction", params, nil, &out); err != nil {
-		return nil, err
-	}
-
-	return &out, nil
-}

api/atproto/admingetModerationActions.go

···
-// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
-
-package atproto
-
-// schema: com.atproto.admin.getModerationActions
-
-import (
-	"context"
-
-	"github.com/bluesky-social/indigo/xrpc"
-)
-
-// AdminGetModerationActions_Output is the output of a com.atproto.admin.getModerationActions call.
-type AdminGetModerationActions_Output struct {
-	Actions []*AdminDefs_ActionView `json:"actions" cborgen:"actions"`
-	Cursor  *string                 `json:"cursor,omitempty" cborgen:"cursor,omitempty"`
-}
-
-// AdminGetModerationActions calls the XRPC method "com.atproto.admin.getModerationActions".
-func AdminGetModerationActions(ctx context.Context, c *xrpc.Client, cursor string, limit int64, subject string) (*AdminGetModerationActions_Output, error) {
-	var out AdminGetModerationActions_Output
-
-	params := map[string]interface{}{
-		"cursor":  cursor,
-		"limit":   limit,
-		"subject": subject,
-	}
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.admin.getModerationActions", params, nil, &out); err != nil {
-		return nil, err
-	}
-
-	return &out, nil
-}

api/atproto/admingetModerationEvent.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+package atproto
+
+// schema: com.atproto.admin.getModerationEvent
+
+import (
+	"context"
+
+	"github.com/bluesky-social/indigo/xrpc"
+)
+
+// AdminGetModerationEvent calls the XRPC method "com.atproto.admin.getModerationEvent".
+func AdminGetModerationEvent(ctx context.Context, c *xrpc.Client, id int64) (*AdminDefs_ModEventViewDetail, error) {
+	var out AdminDefs_ModEventViewDetail
+
+	params := map[string]interface{}{
+		"id": id,
+	}
+	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.admin.getModerationEvent", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/admingetModerationReport.go

···
-// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
-
-package atproto
-
-// schema: com.atproto.admin.getModerationReport
-
-import (
-	"context"
-
-	"github.com/bluesky-social/indigo/xrpc"
-)
-
-// AdminGetModerationReport calls the XRPC method "com.atproto.admin.getModerationReport".
-func AdminGetModerationReport(ctx context.Context, c *xrpc.Client, id int64) (*AdminDefs_ReportViewDetail, error) {
-	var out AdminDefs_ReportViewDetail
-
-	params := map[string]interface{}{
-		"id": id,
-	}
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.admin.getModerationReport", params, nil, &out); err != nil {
-		return nil, err
-	}
-
-	return &out, nil
-}

api/atproto/admingetModerationReports.go

···
-// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
-
-package atproto
-
-// schema: com.atproto.admin.getModerationReports
-
-import (
-	"context"
-
-	"github.com/bluesky-social/indigo/xrpc"
-)
-
-// AdminGetModerationReports_Output is the output of a com.atproto.admin.getModerationReports call.
-type AdminGetModerationReports_Output struct {
-	Cursor  *string                 `json:"cursor,omitempty" cborgen:"cursor,omitempty"`
-	Reports []*AdminDefs_ReportView `json:"reports" cborgen:"reports"`
-}
-
-// AdminGetModerationReports calls the XRPC method "com.atproto.admin.getModerationReports".
-//
-// actionedBy: Get all reports that were actioned by a specific moderator.
-// reporters: Filter reports made by one or more DIDs.
-// reverse: Reverse the order of the returned records. When true, returns reports in chronological order.
-func AdminGetModerationReports(ctx context.Context, c *xrpc.Client, actionType string, actionedBy string, cursor string, ignoreSubjects []string, limit int64, reporters []string, resolved bool, reverse bool, subject string) (*AdminGetModerationReports_Output, error) {
-	var out AdminGetModerationReports_Output
-
-	params := map[string]interface{}{
-		"actionType":     actionType,
-		"actionedBy":     actionedBy,
-		"cursor":         cursor,
-		"ignoreSubjects": ignoreSubjects,
-		"limit":          limit,
-		"reporters":      reporters,
-		"resolved":       resolved,
-		"reverse":        reverse,
-		"subject":        subject,
-	}
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.admin.getModerationReports", params, nil, &out); err != nil {
-		return nil, err
-	}
-
-	return &out, nil
-}

api/atproto/adminqueryModerationEvents.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+package atproto
+
+// schema: com.atproto.admin.queryModerationEvents
+
+import (
+	"context"
+
+	"github.com/bluesky-social/indigo/xrpc"
+)
+
+// AdminQueryModerationEvents_Output is the output of a com.atproto.admin.queryModerationEvents call.
+type AdminQueryModerationEvents_Output struct {
+	Cursor *string                   `json:"cursor,omitempty" cborgen:"cursor,omitempty"`
+	Events []*AdminDefs_ModEventView `json:"events" cborgen:"events"`
+}
+
+// AdminQueryModerationEvents calls the XRPC method "com.atproto.admin.queryModerationEvents".
+//
+// includeAllUserRecords: If true, events on all record types (posts, lists, profile etc.) owned by the did are returned
+// sortDirection: Sort direction for the events. Defaults to descending order of created at timestamp.
+// types: The types of events (fully qualified string in the format of com.atproto.admin#modEvent<name>) to filter by. If not specified, all events are returned.
+func AdminQueryModerationEvents(ctx context.Context, c *xrpc.Client, createdBy string, cursor string, includeAllUserRecords bool, limit int64, sortDirection string, subject string, types []string) (*AdminQueryModerationEvents_Output, error) {
+	var out AdminQueryModerationEvents_Output
+
+	params := map[string]interface{}{
+		"createdBy":             createdBy,
+		"cursor":                cursor,
+		"includeAllUserRecords": includeAllUserRecords,
+		"limit":                 limit,
+		"sortDirection":         sortDirection,
+		"subject":               subject,
+		"types":                 types,
+	}
+	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.admin.queryModerationEvents", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/adminqueryModerationStatuses.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+package atproto
+
+// schema: com.atproto.admin.queryModerationStatuses
+
+import (
+	"context"
+
+	"github.com/bluesky-social/indigo/xrpc"
+)
+
+// AdminQueryModerationStatuses_Output is the output of a com.atproto.admin.queryModerationStatuses call.
+type AdminQueryModerationStatuses_Output struct {
+	Cursor          *string                        `json:"cursor,omitempty" cborgen:"cursor,omitempty"`
+	SubjectStatuses []*AdminDefs_SubjectStatusView `json:"subjectStatuses" cborgen:"subjectStatuses"`
+}
+
+// AdminQueryModerationStatuses calls the XRPC method "com.atproto.admin.queryModerationStatuses".
+//
+// comment: Search subjects by keyword from comments
+// 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
+// reportedAfter: Search subjects reported after a given timestamp
+// reportedBefore: Search subjects reported before a given timestamp
+// reviewState: Specify when fetching subjects in a certain state
+// reviewedAfter: Search subjects reviewed after a given timestamp
+// reviewedBefore: Search subjects reviewed before a given timestamp
+// takendown: Get subjects that were taken down
+func AdminQueryModerationStatuses(ctx context.Context, c *xrpc.Client, comment string, cursor string, ignoreSubjects []string, includeMuted bool, lastReviewedBy string, limit int64, reportedAfter string, reportedBefore string, reviewState string, reviewedAfter string, reviewedBefore string, sortDirection string, sortField string, subject string, takendown bool) (*AdminQueryModerationStatuses_Output, error) {
+	var out AdminQueryModerationStatuses_Output
+
+	params := map[string]interface{}{
+		"comment":        comment,
+		"cursor":         cursor,
+		"ignoreSubjects": ignoreSubjects,
+		"includeMuted":   includeMuted,
+		"lastReviewedBy": lastReviewedBy,
+		"limit":          limit,
+		"reportedAfter":  reportedAfter,
+		"reportedBefore": reportedBefore,
+		"reviewState":    reviewState,
+		"reviewedAfter":  reviewedAfter,
+		"reviewedBefore": reviewedBefore,
+		"sortDirection":  sortDirection,
+		"sortField":      sortField,
+		"subject":        subject,
+		"takendown":      takendown,
+	}
+	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.admin.queryModerationStatuses", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/adminrebaseRepo.go

···
-// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
-
-package atproto
-
-// schema: com.atproto.admin.rebaseRepo
-
-import (
-	"context"
-
-	"github.com/bluesky-social/indigo/xrpc"
-)
-
-// AdminRebaseRepo_Input is the input argument to a com.atproto.admin.rebaseRepo call.
-type AdminRebaseRepo_Input struct {
-	// repo: The handle or DID of the repo.
-	Repo string `json:"repo" cborgen:"repo"`
-	// swapCommit: Compare and swap with the previous commit by cid.
-	SwapCommit *string `json:"swapCommit,omitempty" cborgen:"swapCommit,omitempty"`
-}
-
-// AdminRebaseRepo calls the XRPC method "com.atproto.admin.rebaseRepo".
-func AdminRebaseRepo(ctx context.Context, c *xrpc.Client, input *AdminRebaseRepo_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.admin.rebaseRepo", nil, input, nil); err != nil {
-		return err
-	}
-
-	return nil
-}

api/atproto/adminresolveModerationReports.go

···
-// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
-
-package atproto
-
-// schema: com.atproto.admin.resolveModerationReports
-
-import (
-	"context"
-
-	"github.com/bluesky-social/indigo/xrpc"
-)
-
-// AdminResolveModerationReports_Input is the input argument to a com.atproto.admin.resolveModerationReports call.
-type AdminResolveModerationReports_Input struct {
-	ActionId  int64   `json:"actionId" cborgen:"actionId"`
-	CreatedBy string  `json:"createdBy" cborgen:"createdBy"`
-	ReportIds []int64 `json:"reportIds" cborgen:"reportIds"`
-}
-
-// AdminResolveModerationReports calls the XRPC method "com.atproto.admin.resolveModerationReports".
-func AdminResolveModerationReports(ctx context.Context, c *xrpc.Client, input *AdminResolveModerationReports_Input) (*AdminDefs_ActionView, error) {
-	var out AdminDefs_ActionView
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.admin.resolveModerationReports", nil, input, &out); err != nil {
-		return nil, err
-	}
-
-	return &out, nil
-}

api/atproto/adminreverseModerationAction.go

···
-// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
-
-package atproto
-
-// schema: com.atproto.admin.reverseModerationAction
-
-import (
-	"context"
-
-	"github.com/bluesky-social/indigo/xrpc"
-)
-
-// AdminReverseModerationAction_Input is the input argument to a com.atproto.admin.reverseModerationAction call.
-type AdminReverseModerationAction_Input struct {
-	CreatedBy string `json:"createdBy" cborgen:"createdBy"`
-	Id        int64  `json:"id" cborgen:"id"`
-	Reason    string `json:"reason" cborgen:"reason"`
-}
-
-// AdminReverseModerationAction calls the XRPC method "com.atproto.admin.reverseModerationAction".
-func AdminReverseModerationAction(ctx context.Context, c *xrpc.Client, input *AdminReverseModerationAction_Input) (*AdminDefs_ActionView, error) {
-	var out AdminDefs_ActionView
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.admin.reverseModerationAction", nil, input, &out); err != nil {
-		return nil, err
-	}
-
-	return &out, nil
-}

api/atproto/adminsendEmail.go

···
 type AdminSendEmail_Input struct {
 	Content      string  `json:"content" cborgen:"content"`
 	RecipientDid string  `json:"recipientDid" cborgen:"recipientDid"`
+	SenderDid    string  `json:"senderDid" cborgen:"senderDid"`
 	Subject      *string `json:"subject,omitempty" cborgen:"subject,omitempty"`
 }
 

api/atproto/admintakeModerationAction.go

···
-// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
-
-package atproto
-
-// schema: com.atproto.admin.takeModerationAction
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-
-	"github.com/bluesky-social/indigo/lex/util"
-	"github.com/bluesky-social/indigo/xrpc"
-)
-
-// AdminTakeModerationAction_Input is the input argument to a com.atproto.admin.takeModerationAction call.
-type AdminTakeModerationAction_Input struct {
-	Action          string   `json:"action" cborgen:"action"`
-	CreateLabelVals []string `json:"createLabelVals,omitempty" cborgen:"createLabelVals,omitempty"`
-	CreatedBy       string   `json:"createdBy" cborgen:"createdBy"`
-	// durationInHours: Indicates how long this action is meant to be in effect before automatically expiring.
-	DurationInHours *int64                                   `json:"durationInHours,omitempty" cborgen:"durationInHours,omitempty"`
-	NegateLabelVals []string                                 `json:"negateLabelVals,omitempty" cborgen:"negateLabelVals,omitempty"`
-	Reason          string                                   `json:"reason" cborgen:"reason"`
-	Subject         *AdminTakeModerationAction_Input_Subject `json:"subject" cborgen:"subject"`
-	SubjectBlobCids []string                                 `json:"subjectBlobCids,omitempty" cborgen:"subjectBlobCids,omitempty"`
-}
-
-type AdminTakeModerationAction_Input_Subject struct {
-	AdminDefs_RepoRef *AdminDefs_RepoRef
-	RepoStrongRef     *RepoStrongRef
-}
-
-func (t *AdminTakeModerationAction_Input_Subject) MarshalJSON() ([]byte, error) {
-	if t.AdminDefs_RepoRef != nil {
-		t.AdminDefs_RepoRef.LexiconTypeID = "com.atproto.admin.defs#repoRef"
-		return json.Marshal(t.AdminDefs_RepoRef)
-	}
-	if t.RepoStrongRef != nil {
-		t.RepoStrongRef.LexiconTypeID = "com.atproto.repo.strongRef"
-		return json.Marshal(t.RepoStrongRef)
-	}
-	return nil, fmt.Errorf("cannot marshal empty enum")
-}
-func (t *AdminTakeModerationAction_Input_Subject) UnmarshalJSON(b []byte) error {
-	typ, err := util.TypeExtract(b)
-	if err != nil {
-		return err
-	}
-
-	switch typ {
-	case "com.atproto.admin.defs#repoRef":
-		t.AdminDefs_RepoRef = new(AdminDefs_RepoRef)
-		return json.Unmarshal(b, t.AdminDefs_RepoRef)
-	case "com.atproto.repo.strongRef":
-		t.RepoStrongRef = new(RepoStrongRef)
-		return json.Unmarshal(b, t.RepoStrongRef)
-
-	default:
-		return nil
-	}
-}
-
-// AdminTakeModerationAction calls the XRPC method "com.atproto.admin.takeModerationAction".
-func AdminTakeModerationAction(ctx context.Context, c *xrpc.Client, input *AdminTakeModerationAction_Input) (*AdminDefs_ActionView, error) {
-	var out AdminDefs_ActionView
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.admin.takeModerationAction", nil, input, &out); err != nil {
-		return nil, err
-	}
-
-	return &out, nil
-}

automod/event.go

···
 	}
 	xrpcc := e.Engine.AdminClient
 	if len(e.AccountLabels) > 0 {
-		_, err := comatproto.AdminTakeModerationAction(ctx, xrpcc, &comatproto.AdminTakeModerationAction_Input{
-			Action:          "com.atproto.admin.defs#flag",
-			CreateLabelVals: dedupeStrings(e.AccountLabels),
-			Reason:          "automod",
-			CreatedBy:       xrpcc.Auth.Did,
-			Subject: &comatproto.AdminTakeModerationAction_Input_Subject{
+		comment := "automod"
+		_, err := comatproto.AdminEmitModerationEvent(ctx, xrpcc, &comatproto.AdminEmitModerationEvent_Input{
+			CreatedBy: xrpcc.Auth.Did,
+			Event: &comatproto.AdminEmitModerationEvent_Input_Event{
+				AdminDefs_ModEventLabel: &comatproto.AdminDefs_ModEventLabel{
+					CreateLabelVals: dedupeStrings(e.AccountLabels),
+					Comment:         &comment,
+				},
+			},
+			Subject: &comatproto.AdminEmitModerationEvent_Input_Subject{
 				AdminDefs_RepoRef: &comatproto.AdminDefs_RepoRef{
 					Did: e.Account.Identity.DID.String(),
 				},
···
 		}
 	}
 	if e.AccountTakedown {
-		_, err := comatproto.AdminTakeModerationAction(ctx, xrpcc, &comatproto.AdminTakeModerationAction_Input{
-			Action:    "com.atproto.admin.defs#takedown",
-			Reason:    "automod",
+		comment := "automod"
+		_, err := comatproto.AdminEmitModerationEvent(ctx, xrpcc, &comatproto.AdminEmitModerationEvent_Input{
 			CreatedBy: xrpcc.Auth.Did,
-			Subject: &comatproto.AdminTakeModerationAction_Input_Subject{
+			Event: &comatproto.AdminEmitModerationEvent_Input_Event{
+				AdminDefs_ModEventTakedown: &comatproto.AdminDefs_ModEventTakedown{
+					Comment: &comment,
+				},
+			},
+			Subject: &comatproto.AdminEmitModerationEvent_Input_Subject{
 				AdminDefs_RepoRef: &comatproto.AdminDefs_RepoRef{
 					Did: e.Account.Identity.DID.String(),
 				},
···
 	}
 	xrpcc := e.Engine.AdminClient
 	if len(e.RecordLabels) > 0 {
-		// TODO: this does an action, not just create labels; will update after event refactor
-		_, err := comatproto.AdminTakeModerationAction(ctx, xrpcc, &comatproto.AdminTakeModerationAction_Input{
-			Action:          "com.atproto.admin.defs#flag",
-			CreateLabelVals: dedupeStrings(e.RecordLabels),
-			Reason:          "automod",
-			CreatedBy:       xrpcc.Auth.Did,
-			Subject: &comatproto.AdminTakeModerationAction_Input_Subject{
+		comment := "automod"
+		_, err := comatproto.AdminEmitModerationEvent(ctx, xrpcc, &comatproto.AdminEmitModerationEvent_Input{
+			CreatedBy: xrpcc.Auth.Did,
+			Event: &comatproto.AdminEmitModerationEvent_Input_Event{
+				AdminDefs_ModEventLabel: &comatproto.AdminDefs_ModEventLabel{
+					CreateLabelVals: dedupeStrings(e.RecordLabels),
+					Comment:         &comment,
+				},
+			},
+			Subject: &comatproto.AdminEmitModerationEvent_Input_Subject{
 				RepoStrongRef: &strongRef,
 			},
 		})
···
 		}
 	}
 	if e.RecordTakedown {
-		_, err := comatproto.AdminTakeModerationAction(ctx, xrpcc, &comatproto.AdminTakeModerationAction_Input{
-			Action:    "com.atproto.admin.defs#takedown",
-			Reason:    "automod",
+		comment := "automod"
+		_, err := comatproto.AdminEmitModerationEvent(ctx, xrpcc, &comatproto.AdminEmitModerationEvent_Input{
 			CreatedBy: xrpcc.Auth.Did,
-			Subject: &comatproto.AdminTakeModerationAction_Input_Subject{
+			Event: &comatproto.AdminEmitModerationEvent_Input_Event{
+				AdminDefs_ModEventTakedown: &comatproto.AdminDefs_ModEventTakedown{
+					Comment: &comment,
+				},
+			},
+			Subject: &comatproto.AdminEmitModerationEvent_Input_Subject{
 				RepoStrongRef: &strongRef,
 			},
 		})

cmd/beemo/main.go

···
 		xrpcc.Auth.AccessJwt = refresh.AccessJwt
 		xrpcc.Auth.RefreshJwt = refresh.RefreshJwt
 
-		// AdminGetModerationReports(ctx context.Context, c *xrpc.Client, actionType string, actionedBy string, cursor string, ignoreSubjects []string, limit int64, reporters []string, resolved bool, reverse bool, subject string) (*AdminGetModerationReports_Output, error)
-		resolved := false
+		// query just new reports (regardless of resolution state)
+		// AdminQueryModerationEvents(ctx context.Context, c *xrpc.Client, createdBy string, cursor string, includeAllUserRecords bool, limit int64, sortDirection string, subject string, types []string) (*AdminQueryModerationEvents_Output, error)
 		var limit int64 = 50
-		mrr, err := comatproto.AdminGetModerationReports(context.TODO(), xrpcc, "", "", "", nil, limit, nil, resolved, false, "")
+		me, err := comatproto.AdminQueryModerationEvents(context.TODO(), xrpcc, "", "", false, limit, "", "", []string{"com.atproto.admin.defs#modEventReport"})
 		if err != nil {
 			return err
 		}
 		// this works out to iterate from newest to oldest, which is the behavior we want (report only newest, then break)
-		for _, report := range mrr.Reports {
-			if len(report.ResolvedByActionIds) > 0 {
-				continue
-			}
-			createdAt, err := time.Parse(time.RFC3339, report.CreatedAt)
+		for _, evt := range me.Events {
+			report := evt.Event.AdminDefs_ModEventReport
+			// TODO: filter out based on subject state? similar to old "report.ResolvedByActionIds"
+			createdAt, err := time.Parse(time.RFC3339, evt.CreatedAt)
 			if err != nil {
 				return fmt.Errorf("invalid time format for 'createdAt': %w", err)
 			}
 			if createdAt.After(since) {
 				shortType := ""
-				if report.ReasonType != nil && strings.Contains(*report.ReasonType, "#") {
-					shortType = strings.SplitN(*report.ReasonType, "#", 2)[1]
+				if report.ReportType != nil && strings.Contains(*report.ReportType, "#") {
+					shortType = strings.SplitN(*report.ReportType, "#", 2)[1]
 				}
 				// ok, we found a "new" report, need to notify
-				msg := fmt.Sprintf("⚠️ New report at `%s` ⚠️\n", report.CreatedAt)
-				msg += fmt.Sprintf("report id: `%d`\t", report.Id)
-				msg += fmt.Sprintf("recent unresolved: `%d`\t", len(mrr.Reports))
+				msg := fmt.Sprintf("⚠️ New report at `%s` ⚠️\n", evt.CreatedAt)
+				msg += fmt.Sprintf("report id: `%d`\t", evt.Id)
 				msg += fmt.Sprintf("instance: `%s`\n", cctx.String("pds-host"))
 				msg += fmt.Sprintf("reasonType: `%s`\t", shortType)
-				msg += fmt.Sprintf("Admin: %s/reports/%d\n", cctx.String("admin-host"), report.Id)
+				msg += fmt.Sprintf("Admin: %s/reports/%d\n", cctx.String("admin-host"), evt.Id)
 				//msg += fmt.Sprintf("reportedByDid: `%s`\n", report.ReportedByDid)
 				log.Infof("found new report, notifying slack: %s", report)
 				err := sendSlackMsg(cctx, msg)

cmd/gosky/admin.go

···
 		createInviteCmd,
 		disableInvitesCmd,
 		enableInvitesCmd,
-		getModerationActionsCmd,
+		queryModerationStatusesCmd,
 		listInviteTreeCmd,
 		reportsCmd,
 		takeDownAccountCmd,
···
 		adminKey := cctx.String("admin-password")
 		xrpcc.AdminToken = &adminKey
 
-		// AdminGetModerationReports(ctx context.Context, c *xrpc.Client, actionType string, actionedBy string, cursor string, ignoreSubjects []string, limit int64, reporters []string, resolved bool, reverse bool, subject string) (*AdminGetModerationReports_Output, error)
-		resp, err := atproto.AdminGetModerationReports(ctx, xrpcc, "", "", "", nil, 100, nil, cctx.Bool("resolved"), false, "")
+		// fetch recent moderation reports
+		// AdminQueryModerationEvents(ctx context.Context, c *xrpc.Client, createdBy string, cursor string, includeAllUserRecords bool, limit int64, sortDirection string, subject string, types []string) (*AdminQueryModerationEvents_Output, error)
+		resp, err := atproto.AdminQueryModerationEvents(ctx, xrpcc, "", "", false, 100, "", "", []string{"com.atproto.admin.defs#modEventReport"})
 		if err != nil {
 			return err
 		}
 
-		tojson := func(i any) string {
-			b, err := json.MarshalIndent(i, "", "  ")
-			if err != nil {
-				panic(err)
-			}
-
-			return string(b)
-		}
-
-		for _, rep := range resp.Reports {
+		for _, rep := range resp.Events {
 			b, err := json.MarshalIndent(rep, "", "  ")
 			if err != nil {
 				return err
 			}
 			fmt.Println(string(b))
-			for _, act := range rep.ResolvedByActionIds {
-				action, err := atproto.AdminGetModerationAction(ctx, xrpcc, act)
-				if err != nil {
-					return err
-				}
-
-				fmt.Println(tojson(action))
-			}
 		}
 		return nil
 	},
···
 			Usage:    "account of person running this command, for recordkeeping",
 			Required: true,
 		},
-		&cli.BoolFlag{
-			Name:  "revert-actions",
-			Usage: "revert existing moderation actions on this user before taking down",
-		},
 	},
 	Action: func(cctx *cli.Context) error {
 
···
 				adminUser = resp
 			}
 
-			if cctx.Bool("revert-actions") {
-				resp, err := atproto.AdminGetModerationActions(ctx, xrpcc, "", 100, did)
-				if err != nil {
-					return err
-				}
-
-				for _, act := range resp.Actions {
-					if act.Action == nil || *act.Action != "com.atproto.admin.defs#acknowledge" {
-						return fmt.Errorf("will only revert acknowledge actions")
-					}
-
-					_, err := atproto.AdminReverseModerationAction(ctx, xrpcc, &atproto.AdminReverseModerationAction_Input{
-						CreatedBy: adminUser,
-						Id:        act.Id,
-						Reason:    "reverting for takedown",
-					})
-					if err != nil {
-						return fmt.Errorf("failed to revert existing action: %w", err)
-					}
-				}
-
-			}
-
-			resp, err := atproto.AdminTakeModerationAction(ctx, xrpcc, &atproto.AdminTakeModerationAction_Input{
-				Action:    "com.atproto.admin.defs#takedown",
-				Reason:    reason,
+			resp, err := atproto.AdminEmitModerationEvent(ctx, xrpcc, &atproto.AdminEmitModerationEvent_Input{
 				CreatedBy: adminUser,
-				Subject: &atproto.AdminTakeModerationAction_Input_Subject{
+				Event: &atproto.AdminEmitModerationEvent_Input_Event{
+					AdminDefs_ModEventTakedown: &atproto.AdminDefs_ModEventTakedown{
+						Comment: &reason,
+					},
+				},
+				Subject: &atproto.AdminEmitModerationEvent_Input_Subject{
 					AdminDefs_RepoRef: &atproto.AdminDefs_RepoRef{
 						Did: did,
 					},
···
 	},
 }
 
-var getModerationActionsCmd = &cli.Command{
-	Name: "get-moderation-actions",
+var queryModerationStatusesCmd = &cli.Command{
+	Name: "query-moderation-statuses",
 	Action: func(cctx *cli.Context) error {
 
 		xrpcc, err := cliutil.GetXrpcClient(cctx, false)
···
 			did = resp
 		}
 
-		resp, err := atproto.AdminGetModerationActions(ctx, xrpcc, "", 100, did)
+		resp, err := atproto.AdminQueryModerationStatuses(ctx, xrpcc, "", "", nil, true, "", 100, "", "", "", "", "", "", "", "", false)
 		if err != nil {
 			return err
 		}

labeler/admin.go

···
 	return &recordView
 }
 
-func (s *Server) hydrateModerationActionViews(ctx context.Context, rows []models.ModerationAction) ([]*comatproto.AdminDefs_ActionView, error) {
-
-	var out []*comatproto.AdminDefs_ActionView
-
-	for _, row := range rows {
-
-		resolvedReportIds := []int64{}
-		var resolutionRows []models.ModerationReportResolution
-		result := s.db.Where("action_id = ?", row.ID).Find(&resolutionRows)
-		if result.Error != nil {
-			return nil, result.Error
-		}
-		for _, row := range resolutionRows {
-			resolvedReportIds = append(resolvedReportIds, int64(row.ReportId))
-		}
-
-		subjectBlobCIDs := []string{}
-		var cidRows []models.ModerationActionSubjectBlobCid
-		result = s.db.Where("action_id = ?", row.ID).Find(&cidRows)
-		if result.Error != nil {
-			return nil, result.Error
-		}
-		for _, row := range cidRows {
-			subjectBlobCIDs = append(subjectBlobCIDs, row.Cid)
-		}
-
-		var reversal *comatproto.AdminDefs_ActionReversal
-		if row.ReversedAt != nil {
-			reversal = &comatproto.AdminDefs_ActionReversal{
-				CreatedAt: row.ReversedAt.Format(time.RFC3339),
-				CreatedBy: *row.ReversedByDid,
-				Reason:    *row.ReversedReason,
-			}
-		}
-		var subj *comatproto.AdminDefs_ActionView_Subject
-		switch row.SubjectType {
-		case "com.atproto.repo.repoRef":
-			subj = &comatproto.AdminDefs_ActionView_Subject{
-				AdminDefs_RepoRef: &comatproto.AdminDefs_RepoRef{
-					LexiconTypeID: "com.atproto.repo.repoRef",
-					Did:           row.SubjectDid,
-				},
-			}
-		case "com.atproto.repo.recordRef":
-			subj = &comatproto.AdminDefs_ActionView_Subject{
-				RepoStrongRef: &comatproto.RepoStrongRef{
-					LexiconTypeID: "com.atproto.repo.strongRef",
-					Uri:           *row.SubjectUri,
-					Cid:           *row.SubjectCid,
-				},
-			}
-		default:
-			return nil, fmt.Errorf("unsupported moderation SubjectType: %v", row.SubjectType)
-		}
-
-		view := &comatproto.AdminDefs_ActionView{
-			Action:            &row.Action,
-			CreatedAt:         row.CreatedAt.Format(time.RFC3339),
-			CreatedBy:         row.CreatedByDid,
-			Id:                int64(row.ID),
-			Reason:            row.Reason,
-			ResolvedReportIds: resolvedReportIds,
-			Reversal:          reversal,
-			Subject:           subj,
-			SubjectBlobCids:   subjectBlobCIDs,
-		}
-		out = append(out, view)
-	}
-	return out, nil
-}
-
-func (s *Server) hydrateModerationActionDetails(ctx context.Context, rows []models.ModerationAction) ([]*comatproto.AdminDefs_ActionViewDetail, error) {
-
-	var out []*comatproto.AdminDefs_ActionViewDetail
-	for _, row := range rows {
-
-		var reportRows []models.ModerationReport
-		result := s.db.Joins("left join moderation_report_resolutions on moderation_report_resolutions.report_id = moderation_reports.id").Where("moderation_report_resolutions.action_id = ?", row.ID).Find(&reportRows)
-		if result.Error != nil {
-			return nil, result.Error
-		}
-		resolvedReports, err := s.hydrateModerationReportViews(ctx, reportRows)
-		if err != nil {
-			return nil, err
-		}
-
-		subjectBlobViews := []*comatproto.AdminDefs_BlobView{}
-		var cidRows []models.ModerationActionSubjectBlobCid
-		result = s.db.Where("action_id = ?", row.ID).Find(&cidRows)
-		if result.Error != nil {
-			return nil, result.Error
-		}
-		for _, row := range cidRows {
-			subjectBlobViews = append(subjectBlobViews, &comatproto.AdminDefs_BlobView{
-				Cid: row.Cid,
-				/* TODO(bnewbold): all these other blob fields (from another backed)
-				CreatedAt     string
-				Details       *AdminDefs_BlobView_Details
-				MimeType      string
-				Moderation    *AdminDefs_Moderation
-				Size          int64
-				*/
-			})
-		}
-
-		var reversal *comatproto.AdminDefs_ActionReversal
-		if row.ReversedAt != nil {
-			reversal = &comatproto.AdminDefs_ActionReversal{
-				CreatedAt: row.ReversedAt.Format(time.RFC3339),
-				CreatedBy: *row.ReversedByDid,
-				Reason:    *row.ReversedReason,
-			}
-		}
-		var subj *comatproto.AdminDefs_ActionViewDetail_Subject
-		switch row.SubjectType {
-		case "com.atproto.repo.repoRef":
-			subj = &comatproto.AdminDefs_ActionViewDetail_Subject{
-				AdminDefs_RepoView: s.hydrateRepoView(ctx, row.SubjectDid, row.CreatedAt.Format(time.RFC3339)),
-			}
-		case "com.atproto.repo.recordRef":
-			subj = &comatproto.AdminDefs_ActionViewDetail_Subject{
-				AdminDefs_RecordView: s.hydrateRecordView(ctx, row.SubjectDid, row.SubjectUri, row.SubjectCid, row.CreatedAt.Format(time.RFC3339)),
-			}
-		default:
-			return nil, fmt.Errorf("unsupported moderation SubjectType: %v", row.SubjectType)
-		}
-
-		viewDetail := &comatproto.AdminDefs_ActionViewDetail{
-			Action:          &row.Action,
-			CreatedAt:       row.CreatedAt.Format(time.RFC3339),
-			CreatedBy:       row.CreatedByDid,
-			Id:              int64(row.ID),
-			Reason:          row.Reason,
-			ResolvedReports: resolvedReports,
-			Reversal:        reversal,
-			Subject:         subj,
-			SubjectBlobs:    subjectBlobViews,
-		}
-		out = append(out, viewDetail)
-	}
-	return out, nil
-}
-
 func (s *Server) hydrateModerationReportViews(ctx context.Context, rows []models.ModerationReport) ([]*comatproto.AdminDefs_ReportView, error) {
 
 	var out []*comatproto.AdminDefs_ReportView
···
 
 		view := &comatproto.AdminDefs_ReportView{
 			Id:                  int64(row.ID),
-			Reason:              row.Reason,
+			Comment:             row.Reason,
 			ReasonType:          &row.ReasonType,
 			Subject:             subj,
 			ReportedBy:          row.ReportedByDid,
···
 		if result.Error != nil {
 			return nil, result.Error
 		}
-		resolvedByActionViews, err := s.hydrateModerationActionViews(ctx, actionRows)
-		if err != nil {
-			return nil, err
-		}
 
 		var subj *comatproto.AdminDefs_ReportViewDetail_Subject
 		switch row.SubjectType {
···
 		}
 
 		viewDetail := &comatproto.AdminDefs_ReportViewDetail{
-			Id:                int64(row.ID),
-			Reason:            row.Reason,
-			ReasonType:        &row.ReasonType,
-			Subject:           subj,
-			ReportedBy:        row.ReportedByDid,
-			CreatedAt:         row.CreatedAt.Format(time.RFC3339),
-			ResolvedByActions: resolvedByActionViews,
+			Id:         int64(row.ID),
+			Comment:    row.Reason,
+			ReasonType: &row.ReasonType,
+			Subject:    subj,
+			ReportedBy: row.ReportedByDid,
+			CreatedAt:  row.CreatedAt.Format(time.RFC3339),
 		}
 		out = append(out, viewDetail)
 	}

labeler/helpers_test.go

···
 	label "github.com/bluesky-social/indigo/api/label"
 )
 
-// fetches report, both getModerationReport and getModerationReports, verifies match
+// fetches report via getModerationReport, verifies match
 func testGetReport(t *testing.T, e *echo.Echo, lm *Server, reportId int64) comatproto.AdminDefs_ReportViewDetail {
 	assert := assert.New(t)
 
···
 	}
 	assert.Equal(reportId, reportViewDetail.Id)
 
-	// read back (getModerationReports) and verify output
-	// TODO: include 'subject' param
-	req = httptest.NewRequest(http.MethodGet, "/xrpc/com.atproto.admin.getModerationReports", nil)
-	recorder = httptest.NewRecorder()
-	c = e.NewContext(req, recorder)
-	assert.NoError(lm.HandleComAtprotoAdminGetModerationReports(c))
-	assert.Equal(200, recorder.Code)
-	var reportsOut comatproto.AdminGetModerationReports_Output
-	if err := json.Unmarshal([]byte(recorder.Body.String()), &reportsOut); err != nil {
-		t.Fatal(err)
-	}
-	var reportView *comatproto.AdminDefs_ReportView
-	for _, rv := range reportsOut.Reports {
-		if rv.Id == reportId {
-			reportView = rv
-			break
-		}
-	}
-	if reportView == nil {
-		t.Fatal("expected to find report by subject")
-	}
-
-	assert.Equal(reportViewDetail.Id, reportView.Id)
-	assert.Equal(reportViewDetail.CreatedAt, reportView.CreatedAt)
-	assert.Equal(reportViewDetail.Reason, reportView.Reason)
-	assert.Equal(reportViewDetail.ReasonType, reportView.ReasonType)
-	assert.Equal(reportViewDetail.ReportedBy, reportView.ReportedBy)
-	assert.Equal(len(reportViewDetail.ResolvedByActions), len(reportView.ResolvedByActionIds))
-	for i, actionId := range reportView.ResolvedByActionIds {
-		assert.Equal(actionId, reportViewDetail.ResolvedByActions[i].Id)
-	}
-	if reportViewDetail.Subject.AdminDefs_RepoView != nil {
-		assert.Equal(reportViewDetail.Subject.AdminDefs_RepoView.Did, reportView.Subject.AdminDefs_RepoRef.Did)
-	} else if reportViewDetail.Subject.AdminDefs_RecordView != nil {
-		assert.Equal(reportViewDetail.Subject.AdminDefs_RecordView.Uri, reportView.Subject.RepoStrongRef.Uri)
-		assert.Equal(reportViewDetail.Subject.AdminDefs_RecordView.Cid, reportView.Subject.RepoStrongRef.Cid)
-	} else {
-		t.Fatal("expected non-empty reportviewdetail.subject enum")
-	}
-
 	return reportViewDetail
 }
 
···
 	assert.Equal(out.Id, reportViewDetail.Id)
 	assert.Equal(out.CreatedAt, reportViewDetail.CreatedAt)
 	assert.Equal(out.ReportedBy, reportViewDetail.ReportedBy)
-	assert.Equal(out.Reason, reportViewDetail.Reason)
+	assert.Equal(out.Reason, reportViewDetail.Comment)
 	assert.Equal(out.ReasonType, reportViewDetail.ReasonType)
 	assert.Equal(0, len(reportViewDetail.ResolvedByActions))
 	if out.Subject.AdminDefs_RepoRef != nil {
···
 	} else {
 		t.Fatal("expected non-empty actionviewdetail.subject enum")
 	}
-
-	return out
-}
-
-// fetches action, both getModerationAction and getModerationActions; verifies match
-func testGetAction(t *testing.T, e *echo.Echo, lm *Server, actionId int64) comatproto.AdminDefs_ActionViewDetail {
-	assert := assert.New(t)
-
-	params := make(url.Values)
-	params.Set("id", strconv.Itoa(int(actionId)))
-	req := httptest.NewRequest(http.MethodGet, "/xrpc/com.atproto.admin.getModerationAction?"+params.Encode(), nil)
-	recorder := httptest.NewRecorder()
-	c := e.NewContext(req, recorder)
-	assert.NoError(lm.HandleComAtprotoAdminGetModerationAction(c))
-	assert.Equal(200, recorder.Code)
-	var actionViewDetail comatproto.AdminDefs_ActionViewDetail
-	if err := json.Unmarshal([]byte(recorder.Body.String()), &actionViewDetail); err != nil {
-		t.Fatal(err)
-	}
-	assert.Equal(actionId, actionViewDetail.Id)
-
-	// read back (getModerationActions) and verify output
-	// TODO: include 'subject' param
-	req = httptest.NewRequest(http.MethodGet, "/xrpc/com.atproto.admin.getModerationActions", nil)
-	recorder = httptest.NewRecorder()
-	c = e.NewContext(req, recorder)
-	assert.NoError(lm.HandleComAtprotoAdminGetModerationActions(c))
-	assert.Equal(200, recorder.Code)
-	var actionsOut comatproto.AdminGetModerationActions_Output
-	if err := json.Unmarshal([]byte(recorder.Body.String()), &actionsOut); err != nil {
-		t.Fatal(err)
-	}
-	var actionView *comatproto.AdminDefs_ActionView
-	for _, rv := range actionsOut.Actions {
-		if rv.Id == actionId {
-			actionView = rv
-			break
-		}
-	}
-	if actionView == nil {
-		t.Fatal("expected to find action by subject")
-	}
-
-	assert.Equal(actionViewDetail.Id, actionView.Id)
-	assert.Equal(actionViewDetail.CreatedAt, actionView.CreatedAt)
-	assert.Equal(actionViewDetail.Action, actionView.Action)
-	assert.Equal(actionViewDetail.Reason, actionView.Reason)
-	assert.Equal(actionViewDetail.CreatedBy, actionView.CreatedBy)
-	assert.Equal(actionViewDetail.Reversal, actionView.Reversal)
-	assert.Equal(len(actionViewDetail.ResolvedReports), len(actionView.ResolvedReportIds))
-	for i, reportId := range actionView.ResolvedReportIds {
-		assert.Equal(reportId, actionViewDetail.ResolvedReports[i].Id)
-	}
-	for i, blobCid := range actionView.SubjectBlobCids {
-		assert.Equal(blobCid, actionViewDetail.SubjectBlobs[i].Cid)
-	}
-	if actionViewDetail.Subject.AdminDefs_RepoView != nil {
-		assert.Equal(actionViewDetail.Subject.AdminDefs_RepoView.Did, actionView.Subject.AdminDefs_RepoRef.Did)
-	} else if actionViewDetail.Subject.AdminDefs_RecordView != nil {
-		assert.Equal(actionViewDetail.Subject.AdminDefs_RecordView.Uri, actionView.Subject.RepoStrongRef.Uri)
-		assert.Equal(actionViewDetail.Subject.AdminDefs_RecordView.Cid, actionView.Subject.RepoStrongRef.Cid)
-	} else {
-		t.Fatal("expected non-empty actionviewdetail.subject enum")
-	}
-
-	return actionViewDetail
-}
-
-// "happy path" test helper. creates a action, reads it back 2x ways, verifies match, then returns the original output
-func testCreateAction(t *testing.T, e *echo.Echo, lm *Server, input *comatproto.AdminTakeModerationAction_Input) comatproto.AdminDefs_ActionView {
-	assert := assert.New(t)
-
-	// create action and verify output
-	actionJSON, err := json.Marshal(input)
-	if err != nil {
-		t.Fatal(err)
-	}
-	req := httptest.NewRequest(http.MethodPost, "/xrpc/com.atproto.action.create", strings.NewReader(string(actionJSON)))
-	req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
-	recorder := httptest.NewRecorder()
-	c := e.NewContext(req, recorder)
-
-	assert.NoError(lm.HandleComAtprotoAdminTakeModerationAction(c))
-	assert.Equal(200, recorder.Code)
-
-	var out comatproto.AdminDefs_ActionView
-	if err := json.Unmarshal([]byte(recorder.Body.String()), &out); err != nil {
-		t.Fatal(err)
-	}
-	assert.Equal(input.Action, *out.Action)
-	assert.Equal(input.CreatedBy, out.CreatedBy)
-	assert.Equal(input.Reason, out.Reason)
-	assert.Equal(input.Subject.RepoStrongRef, out.Subject.RepoStrongRef)
-	assert.Equal(input.Subject.AdminDefs_RepoRef, out.Subject.AdminDefs_RepoRef)
-	assert.Equal(input.SubjectBlobCids, out.SubjectBlobCids)
-
-	// read it back and verify output
-	actionViewDetail := testGetAction(t, e, lm, out.Id)
-	assert.Equal(out.Id, actionViewDetail.Id)
-	assert.Equal(out.CreatedAt, actionViewDetail.CreatedAt)
-
-	assert.Equal(out.Action, actionViewDetail.Action)
-	assert.Equal(out.CreatedBy, actionViewDetail.CreatedBy)
-	assert.Equal(out.Reason, actionViewDetail.Reason)
-	if out.Subject.AdminDefs_RepoRef != nil {
-		assert.Equal(out.Subject.AdminDefs_RepoRef.Did, actionViewDetail.Subject.AdminDefs_RepoView.Did)
-	} else if out.Subject.RepoStrongRef != nil {
-		assert.Equal(out.Subject.RepoStrongRef.Uri, actionViewDetail.Subject.AdminDefs_RecordView.Uri)
-		assert.Equal(out.Subject.RepoStrongRef.Cid, actionViewDetail.Subject.AdminDefs_RecordView.Cid)
-	} else {
-		t.Fatal("expected non-empty actionviewdetail.subject enum")
-	}
-	for i, blobCid := range out.SubjectBlobCids {
-		assert.Equal(blobCid, actionViewDetail.SubjectBlobs[i].Cid)
-	}
-	assert.Equal(0, len(actionViewDetail.ResolvedReports))
-	assert.Nil(actionViewDetail.Reversal)
 
 	return out
 }

labeler/xrpc_endpoints.go

···
 	// TODO: session create/refresh/delete?
 
 	// minimal moderation reporting/actioning
-	e.GET("/xrpc/com.atproto.admin.getModerationAction", s.HandleComAtprotoAdminGetModerationAction)
-	e.GET("/xrpc/com.atproto.admin.getModerationActions", s.HandleComAtprotoAdminGetModerationActions)
-	e.GET("/xrpc/com.atproto.admin.getModerationReport", s.HandleComAtprotoAdminGetModerationReport)
-	e.GET("/xrpc/com.atproto.admin.getModerationReports", s.HandleComAtprotoAdminGetModerationReports)
-	e.POST("/xrpc/com.atproto.admin.resolveModerationReports", s.HandleComAtprotoAdminResolveModerationReports)
-	e.POST("/xrpc/com.atproto.admin.reverseModerationAction", s.HandleComAtprotoAdminReverseModerationAction)
-	e.POST("/xrpc/com.atproto.admin.takeModerationAction", s.HandleComAtprotoAdminTakeModerationAction)
 	e.POST("/xrpc/com.atproto.report.create", s.HandleComAtprotoReportCreate)
 
 	// label-specific
···
 	return c.JSON(200, out)
 }
 
-func (s *Server) HandleComAtprotoAdminGetModerationAction(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoAdminGetModerationAction")
-	defer span.End()
-
-	id, err := strconv.Atoi(c.QueryParam("id"))
-	if err != nil {
-		return err
-	}
-	var out *atproto.AdminDefs_ActionViewDetail
-	var handleErr error
-	// func (s *Server) handleComAtprotoAdminGetModerationAction(ctx context.Context,id int) (*atproto.AdminDefs_ActionViewDetail, error)
-	out, handleErr = s.handleComAtprotoAdminGetModerationAction(ctx, id)
-	if handleErr != nil {
-		return handleErr
-	}
-	return c.JSON(200, out)
-}
-
-func (s *Server) HandleComAtprotoAdminGetModerationActions(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoAdminGetModerationActions")
-	defer span.End()
-	before := c.QueryParam("before")
-
-	var limit int
-	if p := c.QueryParam("limit"); p != "" {
-		var err error
-		limit, err = strconv.Atoi(p)
-		if err != nil {
-			return err
-		}
-	} else {
-		limit = 50
-	}
-	subject := c.QueryParam("subject")
-	var out *atproto.AdminGetModerationActions_Output
-	var handleErr error
-	// func (s *Server) handleComAtprotoAdminGetModerationActions(ctx context.Context,before string,limit int,subject string) (*atproto.AdminGetModerationActions_Output, error)
-	out, handleErr = s.handleComAtprotoAdminGetModerationActions(ctx, before, limit, subject)
-	if handleErr != nil {
-		return handleErr
-	}
-	return c.JSON(200, out)
-}
-
 func (s *Server) HandleComAtprotoAdminGetModerationReport(c echo.Context) error {
 	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoAdminGetModerationReport")
 	defer span.End()
···
 	var handleErr error
 	// func (s *Server) handleComAtprotoAdminGetModerationReport(ctx context.Context,id int) (*atproto.AdminDefs_ReportViewDetail, error)
 	out, handleErr = s.handleComAtprotoAdminGetModerationReport(ctx, id)
-	if handleErr != nil {
-		return handleErr
-	}
-	return c.JSON(200, out)
-}
-
-func (s *Server) HandleComAtprotoAdminGetModerationReports(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoAdminGetModerationReports")
-	defer span.End()
-	before := c.QueryParam("before")
-
-	var limit int
-	if p := c.QueryParam("limit"); p != "" {
-		var err error
-		limit, err = strconv.Atoi(p)
-		if err != nil {
-			return err
-		}
-	} else {
-		limit = 50
-	}
-
-	var resolved *bool
-	if p := c.QueryParam("resolved"); p != "" {
-		resolved_val, err := strconv.ParseBool(p)
-		if err != nil {
-			return err
-		}
-		resolved = &resolved_val
-	}
-	subject := c.QueryParam("subject")
-	var out *atproto.AdminGetModerationReports_Output
-	var handleErr error
-	// func (s *Server) handleComAtprotoAdminGetModerationReports(ctx context.Context,before string,limit int,resolved *bool,subject string) (*atproto.AdminGetModerationReports_Output, error)
-	out, handleErr = s.handleComAtprotoAdminGetModerationReports(ctx, before, limit, resolved, subject)
-	if handleErr != nil {
-		return handleErr
-	}
-	return c.JSON(200, out)
-}
-
-func (s *Server) HandleComAtprotoAdminResolveModerationReports(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoAdminResolveModerationReports")
-	defer span.End()
-
-	var body atproto.AdminResolveModerationReports_Input
-	if err := c.Bind(&body); err != nil {
-		return err
-	}
-	var out *atproto.AdminDefs_ActionView
-	var handleErr error
-	// func (s *Server) handleComAtprotoAdminResolveModerationReports(ctx context.Context,body *atproto.AdminResolveModerationReports_Input) (*atproto.AdminDefs_ActionView, error)
-	out, handleErr = s.handleComAtprotoAdminResolveModerationReports(ctx, &body)
-	if handleErr != nil {
-		return handleErr
-	}
-	return c.JSON(200, out)
-}
-
-func (s *Server) HandleComAtprotoAdminReverseModerationAction(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoAdminReverseModerationAction")
-	defer span.End()
-
-	var body atproto.AdminReverseModerationAction_Input
-	if err := c.Bind(&body); err != nil {
-		return err
-	}
-	var out *atproto.AdminDefs_ActionView
-	var handleErr error
-	// func (s *Server) handleComAtprotoAdminReverseModerationAction(ctx context.Context,body *atproto.AdminReverseModerationAction_Input) (*atproto.AdminDefs_ActionView, error)
-	out, handleErr = s.handleComAtprotoAdminReverseModerationAction(ctx, &body)
-	if handleErr != nil {
-		return handleErr
-	}
-	return c.JSON(200, out)
-}
-
-func (s *Server) HandleComAtprotoAdminTakeModerationAction(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoAdminTakeModerationAction")
-	defer span.End()
-
-	var body atproto.AdminTakeModerationAction_Input
-	if err := c.Bind(&body); err != nil {
-		return err
-	}
-	var out *atproto.AdminDefs_ActionView
-	var handleErr error
-	// func (s *Server) handleComAtprotoAdminTakeModerationAction(ctx context.Context,body *atproto.AdminTakeModerationAction_Input) (*atproto.AdminDefs_ActionView, error)
-	out, handleErr = s.handleComAtprotoAdminTakeModerationAction(ctx, &body)
 	if handleErr != nil {
 		return handleErr
 	}

labeler/xrpc_handlers.go

···
 
 import (
 	"context"
-	"errors"
 	"strconv"
 	"strings"
 	"time"
···
 	"github.com/bluesky-social/indigo/util"
 
 	"github.com/labstack/echo/v4"
-	"gorm.io/gorm"
 )
 
 func (s *Server) handleComAtprotoServerDescribeServer(ctx context.Context) (*atproto.ServerDescribeServer_Output, error) {
···
 	return &out, nil
 }
 
-func (s *Server) handleComAtprotoAdminGetModerationAction(ctx context.Context, id int) (*atproto.AdminDefs_ActionViewDetail, error) {
-
-	var row models.ModerationAction
-	result := s.db.First(&row, id)
-	if result.Error != nil {
-		return nil, result.Error
-	}
-
-	full, err := s.hydrateModerationActionDetails(ctx, []models.ModerationAction{row})
-	if err != nil {
-		return nil, err
-	}
-	return full[0], nil
-}
-
-func (s *Server) handleComAtprotoAdminGetModerationActions(ctx context.Context, before string, limit int, subject string) (*atproto.AdminGetModerationActions_Output, error) {
-
-	if limit <= 0 {
-		limit = 20
-	}
-	if limit > 100 {
-		limit = 100
-	}
-
-	q := s.db.Limit(limit).Order("id desc")
-	cursor := before
-	if cursor != "" {
-		cursorID, err := strconv.Atoi(cursor)
-		if err != nil {
-			return nil, echo.NewHTTPError(400, "invalid cursor param: %v", cursor)
-		}
-		q = q.Where("id < ?", cursorID)
-	}
-
-	if subject != "" {
-		q = q.Where("subject = ?", subject)
-	}
-
-	var actionRows []models.ModerationAction
-	result := q.Find(&actionRows)
-	if result.Error != nil {
-		return nil, result.Error
-	}
-
-	var nextCursor string
-	if len(actionRows) >= 1 && len(actionRows) == limit {
-		nextCursor = strconv.FormatUint(actionRows[len(actionRows)-1].ID, 10)
-	}
-
-	actionObjs, err := s.hydrateModerationActionViews(ctx, actionRows)
-	if err != nil {
-		return nil, err
-	}
-	out := atproto.AdminGetModerationActions_Output{
-		Actions: actionObjs,
-	}
-	if nextCursor != "" {
-		out.Cursor = &nextCursor
-	}
-	return &out, nil
-}
-
 func (s *Server) handleComAtprotoAdminGetModerationReport(ctx context.Context, id int) (*atproto.AdminDefs_ReportViewDetail, error) {
 
 	var row models.ModerationReport
···
 	return full[0], nil
 }
 
-func (s *Server) handleComAtprotoAdminGetModerationReports(ctx context.Context, before string, limit int, resolved *bool, subject string) (*atproto.AdminGetModerationReports_Output, error) {
-
-	if limit <= 0 {
-		limit = 20
-	}
-	if limit > 100 {
-		limit = 100
-	}
-
-	q := s.db.Limit(limit).Order("id desc")
-	cursor := before
-	if cursor != "" {
-		cursorID, err := strconv.Atoi(cursor)
-		if err != nil {
-			return nil, echo.NewHTTPError(400, "invalid cursor param: %v", cursor)
-		}
-		q = q.Where("id < ?", cursorID)
-	}
-
-	if subject != "" {
-		q = q.Where("subject = ?", subject)
-	}
-
-	var reportRows []models.ModerationReport
-	result := q.Find(&reportRows)
-	if result.Error != nil {
-		return nil, result.Error
-	}
-
-	var nextCursor string
-	if len(reportRows) >= 1 && len(reportRows) == limit {
-		nextCursor = strconv.FormatUint(reportRows[len(reportRows)-1].ID, 10)
-	}
-
-	reportObjs, err := s.hydrateModerationReportViews(ctx, reportRows)
-	if err != nil {
-		return nil, err
-	}
-
-	// TODO: a bit inefficient to do this filter after hydration. could do it
-	// in the SQL query instead, but this was faster to implement right now
-	if resolved != nil {
-		var filtered []*atproto.AdminDefs_ReportView
-		for _, obj := range reportObjs {
-			if *resolved == true && len(obj.ResolvedByActionIds) > 0 {
-				filtered = append(filtered, obj)
-			}
-			if *resolved == false && len(obj.ResolvedByActionIds) == 0 {
-				filtered = append(filtered, obj)
-			}
-		}
-		reportObjs = filtered
-	}
-
-	out := atproto.AdminGetModerationReports_Output{
-		Reports: reportObjs,
-	}
-	if nextCursor != "" {
-		out.Cursor = &nextCursor
-	}
-	return &out, nil
-}
-
-func (s *Server) handleComAtprotoAdminResolveModerationReports(ctx context.Context, body *atproto.AdminResolveModerationReports_Input) (*atproto.AdminDefs_ActionView, error) {
-
-	if body.CreatedBy == "" {
-		return nil, echo.NewHTTPError(400, "createdBy param must be non-empty")
-	}
-	if len(body.ReportIds) == 0 {
-		return nil, echo.NewHTTPError(400, "at least one reportId required")
-	}
-
-	var rows []models.ModerationReportResolution
-	for _, reportId := range body.ReportIds {
-		rows = append(rows, models.ModerationReportResolution{
-			ReportId:     uint64(reportId),
-			ActionId:     uint64(body.ActionId),
-			CreatedByDid: body.CreatedBy,
-		})
-	}
-	result := s.db.Create(&rows)
-	if result.Error != nil {
-		return nil, result.Error
-	}
-
-	return s.fetchSingleModerationAction(ctx, body.ActionId)
-}
-
-// helper for endpoints that return a partially hydrated moderation action
-func (s *Server) fetchSingleModerationAction(ctx context.Context, actionId int64) (*atproto.AdminDefs_ActionView, error) {
-	var actionRow models.ModerationAction
-	result := s.db.First(&actionRow, actionId)
-	if result.Error != nil {
-		return nil, result.Error
-	}
-
-	actionObjs, err := s.hydrateModerationActionViews(ctx, []models.ModerationAction{actionRow})
-	if err != nil {
-		return nil, err
-	}
-	return actionObjs[0], nil
-}
-
-func (s *Server) handleComAtprotoAdminReverseModerationAction(ctx context.Context, body *atproto.AdminReverseModerationAction_Input) (*atproto.AdminDefs_ActionView, error) {
-
-	if body.CreatedBy == "" {
-		return nil, echo.NewHTTPError(400, "createBy param must be non-empty")
-	}
-	if body.Reason == "" {
-		return nil, echo.NewHTTPError(400, "reason param was provided, but empty string")
-	}
-
-	row := models.ModerationAction{ID: uint64(body.Id)}
-	result := s.db.First(&row)
-	if result.Error != nil {
-		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
-			return nil, echo.NewHTTPError(404, "moderation action not found: %d", body.Id)
-		} else {
-			return nil, result.Error
-		}
-	}
-
-	if row.ReversedAt != nil {
-		return nil, echo.NewHTTPError(400, "action has already been reversed actionId=%d", body.Id)
-	}
-
-	now := time.Now()
-	row.ReversedByDid = &body.CreatedBy
-	row.ReversedReason = &body.Reason
-	row.ReversedAt = &now
-
-	result = s.db.Save(&row)
-	if result.Error != nil {
-		return nil, result.Error
-	}
-
-	return s.fetchSingleModerationAction(ctx, body.Id)
-}
-
 func didFromURI(uri string) string {
 	parts := strings.SplitN(uri, "/", 4)
 	if len(parts) < 3 {
···
 		return parts[2]
 	}
 	return ""
-}
-
-func (s *Server) handleComAtprotoAdminTakeModerationAction(ctx context.Context, body *atproto.AdminTakeModerationAction_Input) (*atproto.AdminDefs_ActionView, error) {
-
-	if body.Action == "" {
-		return nil, echo.NewHTTPError(400, "action param must be non-empty")
-	}
-	if body.CreatedBy == "" {
-		return nil, echo.NewHTTPError(400, "createBy param must be non-empty")
-	}
-	if body.Reason == "" {
-		return nil, echo.NewHTTPError(400, "reason param was provided, but empty string")
-	}
-
-	row := models.ModerationAction{
-		Action:       body.Action,
-		Reason:       body.Reason,
-		CreatedByDid: body.CreatedBy,
-	}
-
-	var outSubj atproto.AdminDefs_ActionView_Subject
-	if body.Subject.AdminDefs_RepoRef != nil {
-		row.SubjectType = "com.atproto.repo.repoRef"
-		row.SubjectDid = body.Subject.AdminDefs_RepoRef.Did
-		outSubj.AdminDefs_RepoRef = &atproto.AdminDefs_RepoRef{
-			LexiconTypeID: "com.atproto.repo.repoRef",
-			Did:           row.SubjectDid,
-		}
-	} else if body.Subject.RepoStrongRef != nil {
-		if body.Subject.RepoStrongRef.Cid == "" {
-			return nil, echo.NewHTTPError(400, "this implementation requires a strong record ref (aka, with CID) in reports")
-		}
-		row.SubjectType = "com.atproto.repo.recordRef"
-		row.SubjectUri = &body.Subject.RepoStrongRef.Uri
-		row.SubjectDid = didFromURI(body.Subject.RepoStrongRef.Uri)
-		if row.SubjectDid == "" {
-			return nil, echo.NewHTTPError(400, "expected URI with a DID: ", row.SubjectUri)
-		}
-		row.SubjectCid = &body.Subject.RepoStrongRef.Cid
-		outSubj.RepoStrongRef = &atproto.RepoStrongRef{
-			LexiconTypeID: "com.atproto.repo.strongRef",
-			Uri:           *row.SubjectUri,
-			Cid:           *row.SubjectCid,
-		}
-	} else {
-		return nil, echo.NewHTTPError(400, "report subject must be a repoRef or a recordRef")
-	}
-
-	result := s.db.Create(&row)
-	if result.Error != nil {
-		return nil, result.Error
-	}
-
-	var cidRows []models.ModerationActionSubjectBlobCid
-	for _, sbc := range body.SubjectBlobCids {
-		cidRows = append(cidRows, models.ModerationActionSubjectBlobCid{
-			ActionId: row.ID,
-			Cid:      sbc,
-		})
-	}
-
-	if len(cidRows) > 0 {
-		result = s.db.Create(&cidRows)
-		if result.Error != nil {
-			return nil, result.Error
-		}
-	}
-
-	out := atproto.AdminDefs_ActionView{
-		Id:              int64(row.ID),
-		Action:          &row.Action,
-		Reason:          row.Reason,
-		CreatedBy:       row.CreatedByDid,
-		CreatedAt:       row.CreatedAt.Format(time.RFC3339),
-		Subject:         &outSubj,
-		SubjectBlobCids: body.SubjectBlobCids,
-	}
-	return &out, nil
 }
 
 func (s *Server) handleComAtprotoReportCreate(ctx context.Context, body *atproto.ModerationCreateReport_Input) (*atproto.ModerationCreateReport_Output, error) {

labeler/xrpc_test.go

···
 import (
 	"context"
 	"encoding/json"
-	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"net/url"
···
 			assert.Equal(row.statusCode, recorder.Code)
 		}
 	}
-}
-
-func TestLabelMakerXRPCReportAction(t *testing.T) {
-	assert := assert.New(t)
-	e := echo.New()
-	lm := testLabelMaker(t)
-
-	// create report
-	reasonType := "spam"
-	reportReason := "I just don't like it!"
-	uri := "at://did:plc:123/com.example.record/bcd234"
-	cid := "bafyreie5cvv4h45feadgeuwhbcutmh6t2ceseocckahdoe6uat64zmz454"
-	report := comatproto.ModerationCreateReport_Input{
-		Reason:     &reportReason,
-		ReasonType: &reasonType,
-		Subject: &comatproto.ModerationCreateReport_Input_Subject{
-			RepoStrongRef: &comatproto.RepoStrongRef{
-				//com.atproto.repo.strongRef
-				Uri: uri,
-				Cid: cid,
-			},
-		},
-	}
-	reportOut := testCreateReport(t, e, lm, &report)
-	reportId := reportOut.Id
-
-	// create action
-	actionVerb := "acknowledge"
-	actionDid := "did:plc:ADMIN"
-	actionReason := "chaos reigns"
-	action := comatproto.AdminTakeModerationAction_Input{
-		Action:    actionVerb,
-		CreatedBy: actionDid,
-		Reason:    actionReason,
-		Subject: &comatproto.AdminTakeModerationAction_Input_Subject{
-			RepoStrongRef: &comatproto.RepoStrongRef{
-				//com.atproto.repo.strongRef
-				Uri: uri,
-				Cid: cid,
-			},
-		},
-		SubjectBlobCids: []string{
-			"abc",
-			"onetwothree",
-		},
-	}
-	actionOut := testCreateAction(t, e, lm, &action)
-	actionId := actionOut.Id
-
-	// resolve report with action
-	resolution := comatproto.AdminResolveModerationReports_Input{
-		ActionId:  actionId,
-		CreatedBy: actionDid,
-		ReportIds: []int64{reportId},
-	}
-	resolutionJSON, err := json.Marshal(resolution)
-	if err != nil {
-		t.Fatal(err)
-	}
-	req := httptest.NewRequest(http.MethodPost, "/xrpc/com.atproto.report.resolveModerationReports", strings.NewReader(string(resolutionJSON)))
-	req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
-	recorder := httptest.NewRecorder()
-	c := e.NewContext(req, recorder)
-	assert.NoError(lm.HandleComAtprotoAdminResolveModerationReports(c))
-	var resolutionOut comatproto.AdminDefs_ActionView
-	if err := json.Unmarshal([]byte(recorder.Body.String()), &resolutionOut); err != nil {
-		t.Fatal(err)
-	}
-	fmt.Println(recorder.Body.String())
-	assert.Equal(actionId, resolutionOut.Id)
-	assert.Equal(1, len(resolutionOut.ResolvedReportIds))
-	assert.Equal(reportId, resolutionOut.ResolvedReportIds[0])
-
-	// get report (should have action included)
-	reportOutDetail := testGetReport(t, e, lm, reportId)
-	assert.Equal(reportId, reportOutDetail.Id)
-	assert.Equal(1, len(reportOutDetail.ResolvedByActions))
-	assert.Equal(actionId, reportOutDetail.ResolvedByActions[0].Id)
-
-	// get action (should have report included)
-	actionOutDetail := testGetAction(t, e, lm, actionId)
-	assert.Equal(actionId, actionOutDetail.Id)
-	assert.Equal(1, len(actionOutDetail.ResolvedReports))
-	assert.Equal(reportId, actionOutDetail.ResolvedReports[0].Id)
-
-	// reverse action
-	reversalReason := "changed my mind"
-	reversal := comatproto.AdminReverseModerationAction_Input{
-		Id:        actionId,
-		CreatedBy: actionDid,
-		Reason:    reversalReason,
-	}
-	reversalJSON, err := json.Marshal(reversal)
-	if err != nil {
-		t.Fatal(err)
-	}
-	req = httptest.NewRequest(http.MethodPost, "/xrpc/com.atproto.report.reverseModerationAction", strings.NewReader(string(reversalJSON)))
-	req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
-	recorder = httptest.NewRecorder()
-	c = e.NewContext(req, recorder)
-	assert.NoError(lm.HandleComAtprotoAdminReverseModerationAction(c))
-	var reversalOut comatproto.AdminDefs_ActionView
-	if err := json.Unmarshal([]byte(recorder.Body.String()), &reversalOut); err != nil {
-		t.Fatal(err)
-	}
-	assert.Equal(actionId, reversalOut.Id)
-	assert.Equal(1, len(reversalOut.ResolvedReportIds))
-	assert.Equal(reportId, reversalOut.ResolvedReportIds[0])
-	assert.Equal(reversal.Reason, reversalOut.Reversal.Reason)
-	assert.Equal(reversal.CreatedBy, reversalOut.Reversal.CreatedBy)
-	assert.NotNil(reversalOut.Reversal.CreatedAt)
-
-	// get report (should *not* have action included)
-	reportOutDetail = testGetReport(t, e, lm, reportId)
-	assert.Equal(reportId, reportOutDetail.Id)
-	assert.Equal(0, len(reportOutDetail.ResolvedByActions))
-
-	// get action (should still have report included)
-	actionOutDetail = testGetAction(t, e, lm, actionId)
-	assert.Equal(actionId, actionOutDetail.Id)
-	assert.Equal(1, len(actionOutDetail.ResolvedReports))
-	assert.Equal(reportId, actionOutDetail.ResolvedReports[0].Id)
-	assert.Equal(reversalOut.Reversal, actionOutDetail.Reversal)
 }
 
 func TestLabelMakerXRPCLabelQuery(t *testing.T) {

lex/util/cbor_gen_test.go

···
 			}
 
 			for i := 0; i < int(extra); i++ {
-
 				{
-					sval, err := cbg.ReadString(cr)
-					if err != nil {
-						return err
-					}
+					var maj byte
+					var extra uint64
+					var err error
+					_ = maj
+					_ = extra
+					_ = err
 
-					t.Array[i] = string(sval)
+					{
+						sval, err := cbg.ReadString(cr)
+						if err != nil {
+							return err
+						}
+
+						t.Array[i] = string(sval)
+					}
 				}
 			}
 
···
 			}
 
 			for i := 0; i < int(extra); i++ {
-
 				{
-					sval, err := cbg.ReadString(cr)
-					if err != nil {
-						return err
-					}
+					var maj byte
+					var extra uint64
+					var err error
+					_ = maj
+					_ = extra
+					_ = err
 
-					t.Arr[i] = string(sval)
+					{
+						sval, err := cbg.ReadString(cr)
+						if err != nil {
+							return err
+						}
+
+						t.Arr[i] = string(sval)
+					}
 				}
 			}
 
···
 			}
 
 			for i := 0; i < int(extra); i++ {
-
 				{
-					sval, err := cbg.ReadString(cr)
-					if err != nil {
-						return err
-					}
+					var maj byte
+					var extra uint64
+					var err error
+					_ = maj
+					_ = extra
+					_ = err
 
-					t.F[i] = string(sval)
+					{
+						sval, err := cbg.ReadString(cr)
+						if err != nil {
+							return err
+						}
+
+						t.F[i] = string(sval)
+					}
 				}
 			}
 
···
 			}
 
 			for i := 0; i < int(extra); i++ {
-
 				{
-					sval, err := cbg.ReadString(cr)
-					if err != nil {
-						return err
-					}
+					var maj byte
+					var extra uint64
+					var err error
+					_ = maj
+					_ = extra
+					_ = err
 
-					t.K[i] = string(sval)
+					{
+						sval, err := cbg.ReadString(cr)
+						if err != nil {
+							return err
+						}
+
+						t.K[i] = string(sval)
+					}
 				}
 			}
 

pds/handlers.go

···
 	panic("nyi")
 }
 
-func (s *Server) handleComAtprotoAdminGetModerationAction(ctx context.Context, id int) (*comatprototypes.AdminDefs_ActionViewDetail, error) {
-	panic("nyi")
-}
-func (s *Server) handleComAtprotoAdminGetModerationActions(ctx context.Context, before string, limit int, subject string) (*comatprototypes.AdminGetModerationActions_Output, error) {
-	panic("nyi")
-}
-func (s *Server) handleComAtprotoAdminGetModerationReport(ctx context.Context, id int) (*comatprototypes.AdminDefs_ReportViewDetail, error) {
-	panic("nyi")
-}
-
-func (s *Server) handleComAtprotoAdminGetModerationReports(ctx context.Context, actionType string, actionedBy string, cursor string, ignoreSubjects []string, limit int, reporters []string, resolved *bool, reverse *bool, subject string) (*comatprototypes.AdminGetModerationReports_Output, error) {
-	panic("nyi")
-}
-
 func (s *Server) handleComAtprotoAdminGetRecord(ctx context.Context, cid string, uri string) (*comatprototypes.AdminDefs_RecordViewDetail, error) {
 	panic("nyi")
 }
···
 func (s *Server) handleComAtprotoAdminGetRepo(ctx context.Context, did string) (*comatprototypes.AdminDefs_RepoViewDetail, error) {
 	panic("nyi")
 }
-func (s *Server) handleComAtprotoAdminResolveModerationReports(ctx context.Context, body *comatprototypes.AdminResolveModerationReports_Input) (*comatprototypes.AdminDefs_ActionView, error) {
-	panic("nyi")
-}
-func (s *Server) handleComAtprotoAdminReverseModerationAction(ctx context.Context, body *comatprototypes.AdminReverseModerationAction_Input) (*comatprototypes.AdminDefs_ActionView, error) {
-	panic("nyi")
-}
 func (s *Server) handleComAtprotoAdminSearchRepos(ctx context.Context, cursor string, limit int, q string, term string) (*comatprototypes.AdminSearchRepos_Output, error) {
-	panic("nyi")
-}
-func (s *Server) handleComAtprotoAdminTakeModerationAction(ctx context.Context, body *comatprototypes.AdminTakeModerationAction_Input) (*comatprototypes.AdminDefs_ActionView, error) {
 	panic("nyi")
 }
 
···
 	panic("nyi")
 }
 func (s *Server) handleAppBskyUnspeccedGetTimelineSkeleton(ctx context.Context, cursor string, limit int) (*appbskytypes.UnspeccedGetTimelineSkeleton_Output, error) {
-	panic("nyi")
-}
-
-func (s *Server) handleComAtprotoAdminRebaseRepo(ctx context.Context, body *comatprototypes.AdminRebaseRepo_Input) error {
 	panic("nyi")
 }
 

pds/stubs.go

···
 	e.POST("/xrpc/com.atproto.admin.enableAccountInvites", s.HandleComAtprotoAdminEnableAccountInvites)
 	e.GET("/xrpc/com.atproto.admin.getAccountInfo", s.HandleComAtprotoAdminGetAccountInfo)
 	e.GET("/xrpc/com.atproto.admin.getInviteCodes", s.HandleComAtprotoAdminGetInviteCodes)
-	e.GET("/xrpc/com.atproto.admin.getModerationAction", s.HandleComAtprotoAdminGetModerationAction)
-	e.GET("/xrpc/com.atproto.admin.getModerationActions", s.HandleComAtprotoAdminGetModerationActions)
-	e.GET("/xrpc/com.atproto.admin.getModerationReport", s.HandleComAtprotoAdminGetModerationReport)
-	e.GET("/xrpc/com.atproto.admin.getModerationReports", s.HandleComAtprotoAdminGetModerationReports)
 	e.GET("/xrpc/com.atproto.admin.getRecord", s.HandleComAtprotoAdminGetRecord)
 	e.GET("/xrpc/com.atproto.admin.getRepo", s.HandleComAtprotoAdminGetRepo)
 	e.GET("/xrpc/com.atproto.admin.getSubjectStatus", s.HandleComAtprotoAdminGetSubjectStatus)
-	e.POST("/xrpc/com.atproto.admin.resolveModerationReports", s.HandleComAtprotoAdminResolveModerationReports)
-	e.POST("/xrpc/com.atproto.admin.reverseModerationAction", s.HandleComAtprotoAdminReverseModerationAction)
 	e.GET("/xrpc/com.atproto.admin.searchRepos", s.HandleComAtprotoAdminSearchRepos)
 	e.POST("/xrpc/com.atproto.admin.sendEmail", s.HandleComAtprotoAdminSendEmail)
-	e.POST("/xrpc/com.atproto.admin.takeModerationAction", s.HandleComAtprotoAdminTakeModerationAction)
 	e.POST("/xrpc/com.atproto.admin.updateAccountEmail", s.HandleComAtprotoAdminUpdateAccountEmail)
 	e.POST("/xrpc/com.atproto.admin.updateAccountHandle", s.HandleComAtprotoAdminUpdateAccountHandle)
 	e.POST("/xrpc/com.atproto.admin.updateSubjectStatus", s.HandleComAtprotoAdminUpdateSubjectStatus)
···
 	return c.JSON(200, out)
 }
 
-func (s *Server) HandleComAtprotoAdminGetModerationAction(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoAdminGetModerationAction")
-	defer span.End()
-
-	id, err := strconv.Atoi(c.QueryParam("id"))
-	if err != nil {
-		return err
-	}
-	var out *comatprototypes.AdminDefs_ActionViewDetail
-	var handleErr error
-	// func (s *Server) handleComAtprotoAdminGetModerationAction(ctx context.Context,id int) (*comatprototypes.AdminDefs_ActionViewDetail, error)
-	out, handleErr = s.handleComAtprotoAdminGetModerationAction(ctx, id)
-	if handleErr != nil {
-		return handleErr
-	}
-	return c.JSON(200, out)
-}
-
-func (s *Server) HandleComAtprotoAdminGetModerationActions(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoAdminGetModerationActions")
-	defer span.End()
-	cursor := c.QueryParam("cursor")
-
-	var limit int
-	if p := c.QueryParam("limit"); p != "" {
-		var err error
-		limit, err = strconv.Atoi(p)
-		if err != nil {
-			return err
-		}
-	} else {
-		limit = 50
-	}
-	subject := c.QueryParam("subject")
-	var out *comatprototypes.AdminGetModerationActions_Output
-	var handleErr error
-	// func (s *Server) handleComAtprotoAdminGetModerationActions(ctx context.Context,cursor string,limit int,subject string) (*comatprototypes.AdminGetModerationActions_Output, error)
-	out, handleErr = s.handleComAtprotoAdminGetModerationActions(ctx, cursor, limit, subject)
-	if handleErr != nil {
-		return handleErr
-	}
-	return c.JSON(200, out)
-}
-
-func (s *Server) HandleComAtprotoAdminGetModerationReport(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoAdminGetModerationReport")
-	defer span.End()
-
-	id, err := strconv.Atoi(c.QueryParam("id"))
-	if err != nil {
-		return err
-	}
-	var out *comatprototypes.AdminDefs_ReportViewDetail
-	var handleErr error
-	// func (s *Server) handleComAtprotoAdminGetModerationReport(ctx context.Context,id int) (*comatprototypes.AdminDefs_ReportViewDetail, error)
-	out, handleErr = s.handleComAtprotoAdminGetModerationReport(ctx, id)
-	if handleErr != nil {
-		return handleErr
-	}
-	return c.JSON(200, out)
-}
-
-func (s *Server) HandleComAtprotoAdminGetModerationReports(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoAdminGetModerationReports")
-	defer span.End()
-	actionType := c.QueryParam("actionType")
-	actionedBy := c.QueryParam("actionedBy")
-	cursor := c.QueryParam("cursor")
-
-	ignoreSubjects := c.QueryParams()["ignoreSubjects"]
-
-	var limit int
-	if p := c.QueryParam("limit"); p != "" {
-		var err error
-		limit, err = strconv.Atoi(p)
-		if err != nil {
-			return err
-		}
-	} else {
-		limit = 50
-	}
-
-	reporters := c.QueryParams()["reporters"]
-
-	var resolved *bool
-	if p := c.QueryParam("resolved"); p != "" {
-		resolved_val, err := strconv.ParseBool(p)
-		if err != nil {
-			return err
-		}
-		resolved = &resolved_val
-	}
-
-	var reverse *bool
-	if p := c.QueryParam("reverse"); p != "" {
-		reverse_val, err := strconv.ParseBool(p)
-		if err != nil {
-			return err
-		}
-		reverse = &reverse_val
-	}
-	subject := c.QueryParam("subject")
-	var out *comatprototypes.AdminGetModerationReports_Output
-	var handleErr error
-	// func (s *Server) handleComAtprotoAdminGetModerationReports(ctx context.Context,actionType string,actionedBy string,cursor string,ignoreSubjects []string,limit int,reporters []string,resolved *bool,reverse *bool,subject string) (*comatprototypes.AdminGetModerationReports_Output, error)
-	out, handleErr = s.handleComAtprotoAdminGetModerationReports(ctx, actionType, actionedBy, cursor, ignoreSubjects, limit, reporters, resolved, reverse, subject)
-	if handleErr != nil {
-		return handleErr
-	}
-	return c.JSON(200, out)
-}
-
 func (s *Server) HandleComAtprotoAdminGetRecord(c echo.Context) error {
 	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoAdminGetRecord")
 	defer span.End()
···
 	return c.JSON(200, out)
 }
 
-func (s *Server) HandleComAtprotoAdminResolveModerationReports(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoAdminResolveModerationReports")
-	defer span.End()
-
-	var body comatprototypes.AdminResolveModerationReports_Input
-	if err := c.Bind(&body); err != nil {
-		return err
-	}
-	var out *comatprototypes.AdminDefs_ActionView
-	var handleErr error
-	// func (s *Server) handleComAtprotoAdminResolveModerationReports(ctx context.Context,body *comatprototypes.AdminResolveModerationReports_Input) (*comatprototypes.AdminDefs_ActionView, error)
-	out, handleErr = s.handleComAtprotoAdminResolveModerationReports(ctx, &body)
-	if handleErr != nil {
-		return handleErr
-	}
-	return c.JSON(200, out)
-}
-
-func (s *Server) HandleComAtprotoAdminReverseModerationAction(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoAdminReverseModerationAction")
-	defer span.End()
-
-	var body comatprototypes.AdminReverseModerationAction_Input
-	if err := c.Bind(&body); err != nil {
-		return err
-	}
-	var out *comatprototypes.AdminDefs_ActionView
-	var handleErr error
-	// func (s *Server) handleComAtprotoAdminReverseModerationAction(ctx context.Context,body *comatprototypes.AdminReverseModerationAction_Input) (*comatprototypes.AdminDefs_ActionView, error)
-	out, handleErr = s.handleComAtprotoAdminReverseModerationAction(ctx, &body)
-	if handleErr != nil {
-		return handleErr
-	}
-	return c.JSON(200, out)
-}
-
 func (s *Server) HandleComAtprotoAdminSearchRepos(c echo.Context) error {
 	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoAdminSearchRepos")
 	defer span.End()
···
 	var handleErr error
 	// func (s *Server) handleComAtprotoAdminSendEmail(ctx context.Context,body *comatprototypes.AdminSendEmail_Input) (*comatprototypes.AdminSendEmail_Output, error)
 	out, handleErr = s.handleComAtprotoAdminSendEmail(ctx, &body)
-	if handleErr != nil {
-		return handleErr
-	}
-	return c.JSON(200, out)
-}
-
-func (s *Server) HandleComAtprotoAdminTakeModerationAction(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoAdminTakeModerationAction")
-	defer span.End()
-
-	var body comatprototypes.AdminTakeModerationAction_Input
-	if err := c.Bind(&body); err != nil {
-		return err
-	}
-	var out *comatprototypes.AdminDefs_ActionView
-	var handleErr error
-	// func (s *Server) handleComAtprotoAdminTakeModerationAction(ctx context.Context,body *comatprototypes.AdminTakeModerationAction_Input) (*comatprototypes.AdminDefs_ActionView, error)
-	out, handleErr = s.handleComAtprotoAdminTakeModerationAction(ctx, &body)
 	if handleErr != nil {
 		return handleErr
 	}

testing/labelmaker_fakedata_test.go

···
 	"testing"
 	"time"
 
-	comatproto "github.com/bluesky-social/indigo/api/atproto"
 	label "github.com/bluesky-social/indigo/api/label"
 	"github.com/bluesky-social/indigo/carstore"
 	"github.com/bluesky-social/indigo/events"
···
 	assert.NoError(err)
 	assert.Equal(0, len(queryOut.Labels))
 	assert.Nil(queryOut.Cursor)
-
-	// auth is required
-	_, err = comatproto.AdminGetModerationReports(ctx, &xrpcc, "", "", "", nil, 20, nil, false, false, "")
-	assert.Error(err)
-
-	adminPassword := "test-admin-pass"
-	xrpcc.AdminToken = &adminPassword
-	_, err = comatproto.AdminGetModerationReports(ctx, &xrpcc, "", "", "", nil, 20, nil, false, false, "")
-	assert.NoError(err)
 
 	// TODO: many more tests
 }