lex: add some minimal docs to the generated code

Not perfect, but a step.

api/atproto/admindefs.go

···
 
 package atproto
 
+// schema: com.atproto.admin.defs
+
 import (
 	"encoding/json"
 	"fmt"
···
 	"github.com/bluesky-social/indigo/lex/util"
 )
 
-// schema: com.atproto.admin.defs
-
+// 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_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"`
···
 	SubjectBlobCids   []string                      `json:"subjectBlobCids" cborgen:"subjectBlobCids"`
 }
 
+// AdminDefs_ActionViewCurrent is a "actionViewCurrent" in the com.atproto.admin.defs schema.
 type AdminDefs_ActionViewCurrent struct {
 	Action *string `json:"action" cborgen:"action"`
 	Id     int64   `json:"id" cborgen:"id"`
 }
 
+// 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"`
···
 	}
 }
 
+// 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"`
···
 	}
 }
 
+// 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" cborgen:"$type,const=com.atproto.admin.defs"`
···
 	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"`
 }
 
+// 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"`
 }
 
+// AdminDefs_RecordView is a "recordView" in the com.atproto.admin.defs schema.
+//
 // RECORDTYPE: AdminDefs_RecordView
 type AdminDefs_RecordView struct {
 	LexiconTypeID string                   `json:"$type,const=com.atproto.admin.defs" cborgen:"$type,const=com.atproto.admin.defs"`
···
 	Value         *util.LexiconTypeDecoder `json:"value" cborgen:"value"`
 }
 
+// AdminDefs_RecordViewDetail is a "recordViewDetail" in the com.atproto.admin.defs schema.
 type AdminDefs_RecordViewDetail struct {
 	Blobs      []*AdminDefs_BlobView       `json:"blobs" cborgen:"blobs"`
 	Cid        string                      `json:"cid" cborgen:"cid"`
···
 	Value      *util.LexiconTypeDecoder    `json:"value" cborgen:"value"`
 }
 
+// AdminDefs_RepoRef is a "repoRef" in the com.atproto.admin.defs schema.
+//
 // RECORDTYPE: AdminDefs_RepoRef
 type AdminDefs_RepoRef struct {
 	LexiconTypeID string `json:"$type,const=com.atproto.admin.defs" cborgen:"$type,const=com.atproto.admin.defs"`
 	Did           string `json:"did" cborgen:"did"`
 }
 
+// AdminDefs_RepoView is a "repoView" in the com.atproto.admin.defs schema.
+//
 // RECORDTYPE: AdminDefs_RepoView
 type AdminDefs_RepoView struct {
 	LexiconTypeID  string                     `json:"$type,const=com.atproto.admin.defs" cborgen:"$type,const=com.atproto.admin.defs"`
···
 	RelatedRecords []*util.LexiconTypeDecoder `json:"relatedRecords" cborgen:"relatedRecords"`
 }
 
+// AdminDefs_RepoViewDetail is a "repoViewDetail" in the com.atproto.admin.defs schema.
 type AdminDefs_RepoViewDetail struct {
 	Did            string                      `json:"did" cborgen:"did"`
 	Email          *string                     `json:"email,omitempty" cborgen:"email,omitempty"`
···
 	RelatedRecords []*util.LexiconTypeDecoder  `json:"relatedRecords" cborgen:"relatedRecords"`
 }
 
+// AdminDefs_ReportView is a "reportView" in the com.atproto.admin.defs schema.
 type AdminDefs_ReportView struct {
 	CreatedAt           string                        `json:"createdAt" cborgen:"createdAt"`
 	Id                  int64                         `json:"id" cborgen:"id"`
···
 	Subject             *AdminDefs_ReportView_Subject `json:"subject" cborgen:"subject"`
 }
 
+// AdminDefs_ReportViewDetail is a "reportViewDetail" in the com.atproto.admin.defs schema.
 type AdminDefs_ReportViewDetail struct {
 	CreatedAt         string                              `json:"createdAt" cborgen:"createdAt"`
 	Id                int64                               `json:"id" cborgen:"id"`
···
 	}
 }
 
+// AdminDefs_VideoDetails is a "videoDetails" in the com.atproto.admin.defs schema.
+//
 // RECORDTYPE: AdminDefs_VideoDetails
 type AdminDefs_VideoDetails struct {
 	LexiconTypeID string `json:"$type,const=com.atproto.admin.defs" cborgen:"$type,const=com.atproto.admin.defs"`

api/atproto/admindisableInviteCodes.go

···
 
 package atproto
 
+// schema: com.atproto.admin.disableInviteCodes
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.admin.disableInviteCodes
-
+// AdminDisableInviteCodes_Input is the input argument to a com.atproto.admin.disableInviteCodes call.
 type AdminDisableInviteCodes_Input struct {
 	Accounts []string `json:"accounts,omitempty" cborgen:"accounts,omitempty"`
 	Codes    []string `json:"codes,omitempty" cborgen:"codes,omitempty"`
 }
 
+// AdminDisableInviteCodes calls the XRPC method "com.atproto.admin.disableInviteCodes".
 func AdminDisableInviteCodes(ctx context.Context, c *xrpc.Client, input *AdminDisableInviteCodes_Input) error {
 	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.admin.disableInviteCodes", nil, input, nil); err != nil {
 		return err

api/atproto/admingetInviteCodes.go

···
 
 package atproto
 
+// schema: com.atproto.admin.getInviteCodes
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.admin.getInviteCodes
-
+// AdminGetInviteCodes_Output is the output of a com.atproto.admin.getInviteCodes call.
 type AdminGetInviteCodes_Output struct {
 	Codes  []*ServerDefs_InviteCode `json:"codes" cborgen:"codes"`
 	Cursor *string                  `json:"cursor,omitempty" cborgen:"cursor,omitempty"`
 }
 
+// AdminGetInviteCodes calls the XRPC method "com.atproto.admin.getInviteCodes".
 func AdminGetInviteCodes(ctx context.Context, c *xrpc.Client, cursor string, limit int64, sort string) (*AdminGetInviteCodes_Output, error) {
 	var out AdminGetInviteCodes_Output
 

api/atproto/admingetModerationAction.go

···
 
 package atproto
 
+// schema: com.atproto.admin.getModerationAction
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.admin.getModerationAction
-
+// 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
 

api/atproto/admingetModerationActions.go

···
 
 package atproto
 
+// schema: com.atproto.admin.getModerationActions
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.admin.getModerationActions
-
+// 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
 

api/atproto/admingetModerationReport.go

···
 
 package atproto
 
+// schema: com.atproto.admin.getModerationReport
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.admin.getModerationReport
-
+// 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
 

api/atproto/admingetModerationReports.go

···
 
 package atproto
 
+// schema: com.atproto.admin.getModerationReports
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.admin.getModerationReports
-
+// 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".
 func AdminGetModerationReports(ctx context.Context, c *xrpc.Client, cursor string, limit int64, resolved bool, subject string) (*AdminGetModerationReports_Output, error) {
 	var out AdminGetModerationReports_Output
 

api/atproto/admingetRecord.go

···
 
 package atproto
 
+// schema: com.atproto.admin.getRecord
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.admin.getRecord
-
+// AdminGetRecord calls the XRPC method "com.atproto.admin.getRecord".
 func AdminGetRecord(ctx context.Context, c *xrpc.Client, cid string, uri string) (*AdminDefs_RecordViewDetail, error) {
 	var out AdminDefs_RecordViewDetail
 

api/atproto/admingetRepo.go

···
 
 package atproto
 
+// schema: com.atproto.admin.getRepo
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.admin.getRepo
-
+// AdminGetRepo calls the XRPC method "com.atproto.admin.getRepo".
 func AdminGetRepo(ctx context.Context, c *xrpc.Client, did string) (*AdminDefs_RepoViewDetail, error) {
 	var out AdminDefs_RepoViewDetail
 

api/atproto/adminresolveModerationReports.go

···
 
 package atproto
 
+// schema: com.atproto.admin.resolveModerationReports
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.admin.resolveModerationReports
-
+// 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 {

api/atproto/adminreverseModerationAction.go

···
 
 package atproto
 
+// schema: com.atproto.admin.reverseModerationAction
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.admin.reverseModerationAction
-
+// 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 {

api/atproto/adminsearchRepos.go

···
 
 package atproto
 
+// schema: com.atproto.admin.searchRepos
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.admin.searchRepos
-
+// AdminSearchRepos_Output is the output of a com.atproto.admin.searchRepos call.
 type AdminSearchRepos_Output struct {
 	Cursor *string               `json:"cursor,omitempty" cborgen:"cursor,omitempty"`
 	Repos  []*AdminDefs_RepoView `json:"repos" cborgen:"repos"`
 }
 
+// AdminSearchRepos calls the XRPC method "com.atproto.admin.searchRepos".
 func AdminSearchRepos(ctx context.Context, c *xrpc.Client, cursor string, invitedBy string, limit int64, term string) (*AdminSearchRepos_Output, error) {
 	var out AdminSearchRepos_Output
 

api/atproto/admintakeModerationAction.go

···
 
 package atproto
 
+// schema: com.atproto.admin.takeModerationAction
+
 import (
 	"context"
 	"encoding/json"
···
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.admin.takeModerationAction
-
+// 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"`
···
 	}
 }
 
+// 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 {

api/atproto/adminupdateAccountEmail.go

···
 
 package atproto
 
+// schema: com.atproto.admin.updateAccountEmail
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.admin.updateAccountEmail
-
+// AdminUpdateAccountEmail_Input is the input argument to a com.atproto.admin.updateAccountEmail call.
 type AdminUpdateAccountEmail_Input struct {
+	// account: The handle or DID of the repo.
 	Account string `json:"account" cborgen:"account"`
 	Email   string `json:"email" cborgen:"email"`
 }
 
+// AdminUpdateAccountEmail calls the XRPC method "com.atproto.admin.updateAccountEmail".
 func AdminUpdateAccountEmail(ctx context.Context, c *xrpc.Client, input *AdminUpdateAccountEmail_Input) error {
 	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.admin.updateAccountEmail", nil, input, nil); err != nil {
 		return err

api/atproto/adminupdateAccountHandle.go

···
 
 package atproto
 
+// schema: com.atproto.admin.updateAccountHandle
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.admin.updateAccountHandle
-
+// AdminUpdateAccountHandle_Input is the input argument to a com.atproto.admin.updateAccountHandle call.
 type AdminUpdateAccountHandle_Input struct {
 	Did    string `json:"did" cborgen:"did"`
 	Handle string `json:"handle" cborgen:"handle"`
 }
 
+// AdminUpdateAccountHandle calls the XRPC method "com.atproto.admin.updateAccountHandle".
 func AdminUpdateAccountHandle(ctx context.Context, c *xrpc.Client, input *AdminUpdateAccountHandle_Input) error {
 	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.admin.updateAccountHandle", nil, input, nil); err != nil {
 		return err

api/atproto/identityresolveHandle.go

···
 
 package atproto
 
+// schema: com.atproto.identity.resolveHandle
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.identity.resolveHandle
-
+// IdentityResolveHandle_Output is the output of a com.atproto.identity.resolveHandle call.
 type IdentityResolveHandle_Output struct {
 	Did string `json:"did" cborgen:"did"`
 }
 
+// IdentityResolveHandle calls the XRPC method "com.atproto.identity.resolveHandle".
+//
+// handle: The handle to resolve. If not supplied, will resolve the host's own handle.
 func IdentityResolveHandle(ctx context.Context, c *xrpc.Client, handle string) (*IdentityResolveHandle_Output, error) {
 	var out IdentityResolveHandle_Output
 

api/atproto/identityupdateHandle.go

···
 
 package atproto
 
+// schema: com.atproto.identity.updateHandle
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.identity.updateHandle
-
+// IdentityUpdateHandle_Input is the input argument to a com.atproto.identity.updateHandle call.
 type IdentityUpdateHandle_Input struct {
 	Handle string `json:"handle" cborgen:"handle"`
 }
 
+// IdentityUpdateHandle calls the XRPC method "com.atproto.identity.updateHandle".
 func IdentityUpdateHandle(ctx context.Context, c *xrpc.Client, input *IdentityUpdateHandle_Input) error {
 	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.identity.updateHandle", nil, input, nil); err != nil {
 		return err

api/atproto/labeldefs.go

···
 
 // schema: com.atproto.label.defs
 
+// LabelDefs_Label is a "label" in the com.atproto.label.defs schema.
+//
+// Metadata tag on an atproto resource (eg, repo or record)
 type LabelDefs_Label struct {
+	// cid: optionally, CID specifying the specific version of 'uri' resource this label applies to
 	Cid *string `json:"cid,omitempty" cborgen:"cid,omitempty"`
-	Cts string  `json:"cts" cborgen:"cts"`
-	Neg *bool   `json:"neg,omitempty" cborgen:"neg,omitempty"`
-	Src string  `json:"src" cborgen:"src"`
-	Uri string  `json:"uri" cborgen:"uri"`
-	Val string  `json:"val" cborgen:"val"`
+	// cts: timestamp when this label was created
+	Cts string `json:"cts" cborgen:"cts"`
+	// neg: if true, this is a negation label, overwriting a previous label
+	Neg *bool `json:"neg,omitempty" cborgen:"neg,omitempty"`
+	// src: DID of the actor who created this label
+	Src string `json:"src" cborgen:"src"`
+	// uri: AT URI of the record, repository (account), or other resource which this label applies to
+	Uri string `json:"uri" cborgen:"uri"`
+	// val: the short string name of the value or type of this label
+	Val string `json:"val" cborgen:"val"`
 }

api/atproto/labelqueryLabels.go

···
 
 package atproto
 
+// schema: com.atproto.label.queryLabels
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.label.queryLabels
-
+// LabelQueryLabels_Output is the output of a com.atproto.label.queryLabels call.
 type LabelQueryLabels_Output struct {
 	Cursor *string            `json:"cursor,omitempty" cborgen:"cursor,omitempty"`
 	Labels []*LabelDefs_Label `json:"labels" cborgen:"labels"`
 }
 
+// LabelQueryLabels calls the XRPC method "com.atproto.label.queryLabels".
+//
+// sources: Optional list of label sources (DIDs) to filter on
+// uriPatterns: List of AT URI patterns to match (boolean 'OR'). Each may be a prefix (ending with '*'; will match inclusive of the string leading to '*'), or a full URI
 func LabelQueryLabels(ctx context.Context, c *xrpc.Client, cursor string, limit int64, sources []string, uriPatterns []string) (*LabelQueryLabels_Output, error) {
 	var out LabelQueryLabels_Output
 

api/atproto/labelsubscribeLabels.go

···
 
 // schema: com.atproto.label.subscribeLabels
 
+// LabelSubscribeLabels_Info is a "info" in the com.atproto.label.subscribeLabels schema.
 type LabelSubscribeLabels_Info struct {
 	Message *string `json:"message,omitempty" cborgen:"message,omitempty"`
 	Name    string  `json:"name" cborgen:"name"`
 }
 
+// LabelSubscribeLabels_Labels is a "labels" in the com.atproto.label.subscribeLabels schema.
 type LabelSubscribeLabels_Labels struct {
 	Labels []*LabelDefs_Label `json:"labels" cborgen:"labels"`
 	Seq    int64              `json:"seq" cborgen:"seq"`

api/atproto/moderationcreateReport.go

···
 
 package atproto
 
+// schema: com.atproto.moderation.createReport
+
 import (
 	"context"
 	"encoding/json"
···
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.moderation.createReport
-
+// ModerationCreateReport_Input is the input argument to a com.atproto.moderation.createReport call.
 type ModerationCreateReport_Input struct {
 	Reason     *string                               `json:"reason,omitempty" cborgen:"reason,omitempty"`
 	ReasonType *string                               `json:"reasonType" cborgen:"reasonType"`
···
 	}
 }
 
+// ModerationCreateReport_Output is the output of a com.atproto.moderation.createReport call.
 type ModerationCreateReport_Output struct {
 	CreatedAt  string                                 `json:"createdAt" cborgen:"createdAt"`
 	Id         int64                                  `json:"id" cborgen:"id"`
···
 	}
 }
 
+// ModerationCreateReport calls the XRPC method "com.atproto.moderation.createReport".
 func ModerationCreateReport(ctx context.Context, c *xrpc.Client, input *ModerationCreateReport_Input) (*ModerationCreateReport_Output, error) {
 	var out ModerationCreateReport_Output
 	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.moderation.createReport", nil, input, &out); err != nil {

api/atproto/repoapplyWrites.go

···
 
 package atproto
 
+// schema: com.atproto.repo.applyWrites
+
 import (
 	"context"
 	"encoding/json"
···
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.repo.applyWrites
-
+// RepoApplyWrites_Create is a "create" in the com.atproto.repo.applyWrites schema.
+//
+// Create a new record.
+//
 // RECORDTYPE: RepoApplyWrites_Create
 type RepoApplyWrites_Create struct {
 	LexiconTypeID string                   `json:"$type,const=com.atproto.repo.applyWrites" cborgen:"$type,const=com.atproto.repo.applyWrites"`
···
 	Value         *util.LexiconTypeDecoder `json:"value" cborgen:"value"`
 }
 
+// RepoApplyWrites_Delete is a "delete" in the com.atproto.repo.applyWrites schema.
+//
+// Delete an existing record.
+//
 // RECORDTYPE: RepoApplyWrites_Delete
 type RepoApplyWrites_Delete struct {
 	LexiconTypeID string `json:"$type,const=com.atproto.repo.applyWrites" cborgen:"$type,const=com.atproto.repo.applyWrites"`
···
 	Rkey          string `json:"rkey" cborgen:"rkey"`
 }
 
+// RepoApplyWrites_Input is the input argument to a com.atproto.repo.applyWrites call.
 type RepoApplyWrites_Input struct {
-	Repo       string                               `json:"repo" cborgen:"repo"`
-	SwapCommit *string                              `json:"swapCommit,omitempty" cborgen:"swapCommit,omitempty"`
-	Validate   *bool                                `json:"validate,omitempty" cborgen:"validate,omitempty"`
-	Writes     []*RepoApplyWrites_Input_Writes_Elem `json:"writes" cborgen:"writes"`
+	// repo: The handle or DID of the repo.
+	Repo       string  `json:"repo" cborgen:"repo"`
+	SwapCommit *string `json:"swapCommit,omitempty" cborgen:"swapCommit,omitempty"`
+	// validate: Validate the records?
+	Validate *bool                                `json:"validate,omitempty" cborgen:"validate,omitempty"`
+	Writes   []*RepoApplyWrites_Input_Writes_Elem `json:"writes" cborgen:"writes"`
 }
 
 type RepoApplyWrites_Input_Writes_Elem struct {
···
 	}
 }
 
+// RepoApplyWrites_Update is a "update" in the com.atproto.repo.applyWrites schema.
+//
+// Update an existing record.
+//
 // RECORDTYPE: RepoApplyWrites_Update
 type RepoApplyWrites_Update struct {
 	LexiconTypeID string                   `json:"$type,const=com.atproto.repo.applyWrites" cborgen:"$type,const=com.atproto.repo.applyWrites"`
···
 	Value         *util.LexiconTypeDecoder `json:"value" cborgen:"value"`
 }
 
+// RepoApplyWrites calls the XRPC method "com.atproto.repo.applyWrites".
 func RepoApplyWrites(ctx context.Context, c *xrpc.Client, input *RepoApplyWrites_Input) error {
 	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.repo.applyWrites", nil, input, nil); err != nil {
 		return err

api/atproto/repocreateRecord.go

···
 
 package atproto
 
+// schema: com.atproto.repo.createRecord
+
 import (
 	"context"
 
···
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.repo.createRecord
-
+// RepoCreateRecord_Input is the input argument to a com.atproto.repo.createRecord call.
 type RepoCreateRecord_Input struct {
-	Collection string                   `json:"collection" cborgen:"collection"`
-	Record     *util.LexiconTypeDecoder `json:"record" cborgen:"record"`
-	Repo       string                   `json:"repo" cborgen:"repo"`
-	Rkey       *string                  `json:"rkey,omitempty" cborgen:"rkey,omitempty"`
-	SwapCommit *string                  `json:"swapCommit,omitempty" cborgen:"swapCommit,omitempty"`
-	Validate   *bool                    `json:"validate,omitempty" cborgen:"validate,omitempty"`
+	// collection: The NSID of the record collection.
+	Collection string `json:"collection" cborgen:"collection"`
+	// record: The record to create.
+	Record *util.LexiconTypeDecoder `json:"record" cborgen:"record"`
+	// repo: The handle or DID of the repo.
+	Repo string `json:"repo" cborgen:"repo"`
+	// rkey: The key of the record.
+	Rkey *string `json:"rkey,omitempty" cborgen:"rkey,omitempty"`
+	// swapCommit: Compare and swap with the previous commit by cid.
+	SwapCommit *string `json:"swapCommit,omitempty" cborgen:"swapCommit,omitempty"`
+	// validate: Validate the record?
+	Validate *bool `json:"validate,omitempty" cborgen:"validate,omitempty"`
 }
 
+// RepoCreateRecord_Output is the output of a com.atproto.repo.createRecord call.
 type RepoCreateRecord_Output struct {
 	Cid string `json:"cid" cborgen:"cid"`
 	Uri string `json:"uri" cborgen:"uri"`
 }
 
+// RepoCreateRecord calls the XRPC method "com.atproto.repo.createRecord".
 func RepoCreateRecord(ctx context.Context, c *xrpc.Client, input *RepoCreateRecord_Input) (*RepoCreateRecord_Output, error) {
 	var out RepoCreateRecord_Output
 	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.repo.createRecord", nil, input, &out); err != nil {

api/atproto/repodeleteRecord.go

···
 
 package atproto
 
+// schema: com.atproto.repo.deleteRecord
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.repo.deleteRecord
-
+// RepoDeleteRecord_Input is the input argument to a com.atproto.repo.deleteRecord call.
 type RepoDeleteRecord_Input struct {
-	Collection string  `json:"collection" cborgen:"collection"`
-	Repo       string  `json:"repo" cborgen:"repo"`
-	Rkey       string  `json:"rkey" cborgen:"rkey"`
+	// collection: The NSID of the record collection.
+	Collection string `json:"collection" cborgen:"collection"`
+	// repo: The handle or DID of the repo.
+	Repo string `json:"repo" cborgen:"repo"`
+	// rkey: The key of the record.
+	Rkey string `json:"rkey" cborgen:"rkey"`
+	// swapCommit: Compare and swap with the previous commit by cid.
 	SwapCommit *string `json:"swapCommit,omitempty" cborgen:"swapCommit,omitempty"`
+	// swapRecord: Compare and swap with the previous record by cid.
 	SwapRecord *string `json:"swapRecord,omitempty" cborgen:"swapRecord,omitempty"`
 }
 
+// RepoDeleteRecord calls the XRPC method "com.atproto.repo.deleteRecord".
 func RepoDeleteRecord(ctx context.Context, c *xrpc.Client, input *RepoDeleteRecord_Input) error {
 	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.repo.deleteRecord", nil, input, nil); err != nil {
 		return err

api/atproto/repodescribeRepo.go

···
 
 package atproto
 
+// schema: com.atproto.repo.describeRepo
+
 import (
 	"context"
 
···
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.repo.describeRepo
-
+// RepoDescribeRepo_Output is the output of a com.atproto.repo.describeRepo call.
 type RepoDescribeRepo_Output struct {
 	Collections     []string                 `json:"collections" cborgen:"collections"`
 	Did             string                   `json:"did" cborgen:"did"`
···
 	HandleIsCorrect bool                     `json:"handleIsCorrect" cborgen:"handleIsCorrect"`
 }
 
+// RepoDescribeRepo calls the XRPC method "com.atproto.repo.describeRepo".
+//
+// repo: The handle or DID of the repo.
 func RepoDescribeRepo(ctx context.Context, c *xrpc.Client, repo string) (*RepoDescribeRepo_Output, error) {
 	var out RepoDescribeRepo_Output
 

api/atproto/repogetRecord.go

···
 
 package atproto
 
+// schema: com.atproto.repo.getRecord
+
 import (
 	"context"
 
···
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.repo.getRecord
-
+// RepoGetRecord_Output is the output of a com.atproto.repo.getRecord call.
 type RepoGetRecord_Output struct {
 	Cid   *string                  `json:"cid,omitempty" cborgen:"cid,omitempty"`
 	Uri   string                   `json:"uri" cborgen:"uri"`
 	Value *util.LexiconTypeDecoder `json:"value" cborgen:"value"`
 }
 
+// RepoGetRecord calls the XRPC method "com.atproto.repo.getRecord".
+//
+// cid: The CID of the version of the record. If not specified, then return the most recent version.
+// collection: The NSID of the record collection.
+// repo: The handle or DID of the repo.
+// rkey: The key of the record.
 func RepoGetRecord(ctx context.Context, c *xrpc.Client, cid string, collection string, repo string, rkey string) (*RepoGetRecord_Output, error) {
 	var out RepoGetRecord_Output
 

api/atproto/repolistRecords.go

···
 
 package atproto
 
+// schema: com.atproto.repo.listRecords
+
 import (
 	"context"
 
···
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.repo.listRecords
-
+// RepoListRecords_Output is the output of a com.atproto.repo.listRecords call.
 type RepoListRecords_Output struct {
 	Cursor  *string                   `json:"cursor,omitempty" cborgen:"cursor,omitempty"`
 	Records []*RepoListRecords_Record `json:"records" cborgen:"records"`
 }
 
+// RepoListRecords_Record is a "record" in the com.atproto.repo.listRecords schema.
 type RepoListRecords_Record struct {
 	Cid   string                   `json:"cid" cborgen:"cid"`
 	Uri   string                   `json:"uri" cborgen:"uri"`
 	Value *util.LexiconTypeDecoder `json:"value" cborgen:"value"`
 }
 
+// RepoListRecords calls the XRPC method "com.atproto.repo.listRecords".
+//
+// collection: The NSID of the record type.
+// limit: The number of records to return.
+// repo: The handle or DID of the repo.
+// reverse: Reverse the order of the returned records?
+// rkeyEnd: DEPRECATED: The highest sort-ordered rkey to stop at (exclusive)
+// rkeyStart: DEPRECATED: The lowest sort-ordered rkey to start from (exclusive)
 func RepoListRecords(ctx context.Context, c *xrpc.Client, collection string, cursor string, limit int64, repo string, reverse bool, rkeyEnd string, rkeyStart string) (*RepoListRecords_Output, error) {
 	var out RepoListRecords_Output
 

api/atproto/repoputRecord.go

···
 
 package atproto
 
+// schema: com.atproto.repo.putRecord
+
 import (
 	"context"
 
···
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.repo.putRecord
-
+// RepoPutRecord_Input is the input argument to a com.atproto.repo.putRecord call.
 type RepoPutRecord_Input struct {
-	Collection string                   `json:"collection" cborgen:"collection"`
-	Record     *util.LexiconTypeDecoder `json:"record" cborgen:"record"`
-	Repo       string                   `json:"repo" cborgen:"repo"`
-	Rkey       string                   `json:"rkey" cborgen:"rkey"`
-	SwapCommit *string                  `json:"swapCommit,omitempty" cborgen:"swapCommit,omitempty"`
-	SwapRecord *string                  `json:"swapRecord" cborgen:"swapRecord"`
-	Validate   *bool                    `json:"validate,omitempty" cborgen:"validate,omitempty"`
+	// collection: The NSID of the record collection.
+	Collection string `json:"collection" cborgen:"collection"`
+	// record: The record to write.
+	Record *util.LexiconTypeDecoder `json:"record" cborgen:"record"`
+	// repo: The handle or DID of the repo.
+	Repo string `json:"repo" cborgen:"repo"`
+	// rkey: The key of the record.
+	Rkey string `json:"rkey" cborgen:"rkey"`
+	// swapCommit: Compare and swap with the previous commit by cid.
+	SwapCommit *string `json:"swapCommit,omitempty" cborgen:"swapCommit,omitempty"`
+	// swapRecord: Compare and swap with the previous record by cid.
+	SwapRecord *string `json:"swapRecord" cborgen:"swapRecord"`
+	// validate: Validate the record?
+	Validate *bool `json:"validate,omitempty" cborgen:"validate,omitempty"`
 }
 
+// RepoPutRecord_Output is the output of a com.atproto.repo.putRecord call.
 type RepoPutRecord_Output struct {
 	Cid string `json:"cid" cborgen:"cid"`
 	Uri string `json:"uri" cborgen:"uri"`
 }
 
+// RepoPutRecord calls the XRPC method "com.atproto.repo.putRecord".
 func RepoPutRecord(ctx context.Context, c *xrpc.Client, input *RepoPutRecord_Input) (*RepoPutRecord_Output, error) {
 	var out RepoPutRecord_Output
 	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.repo.putRecord", nil, input, &out); err != nil {

api/atproto/repostrongRef.go

···
 
 package atproto
 
+// schema: com.atproto.repo.strongRef
+
 import (
 	"github.com/bluesky-social/indigo/lex/util"
 )
-
-// schema: com.atproto.repo.strongRef
 
 func init() {
 	util.RegisterType("com.atproto.repo.strongRef#main", &RepoStrongRef{})
-} // RECORDTYPE: RepoStrongRef
+} // RepoStrongRef is a "main" in the com.atproto.repo.strongRef schema.
+// RECORDTYPE: RepoStrongRef
 type RepoStrongRef struct {
 	LexiconTypeID string `json:"$type,const=com.atproto.repo.strongRef,omitempty" cborgen:"$type,const=com.atproto.repo.strongRef,omitempty"`
 	Cid           string `json:"cid" cborgen:"cid"`

api/atproto/repouploadBlob.go

···
 
 package atproto
 
+// schema: com.atproto.repo.uploadBlob
+
 import (
 	"context"
 	"io"
···
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.repo.uploadBlob
-
+// RepoUploadBlob_Output is the output of a com.atproto.repo.uploadBlob call.
 type RepoUploadBlob_Output struct {
 	Blob *util.LexBlob `json:"blob" cborgen:"blob"`
 }
 
+// RepoUploadBlob calls the XRPC method "com.atproto.repo.uploadBlob".
 func RepoUploadBlob(ctx context.Context, c *xrpc.Client, input io.Reader) (*RepoUploadBlob_Output, error) {
 	var out RepoUploadBlob_Output
 	if err := c.Do(ctx, xrpc.Procedure, "*/*", "com.atproto.repo.uploadBlob", nil, input, &out); err != nil {

api/atproto/servercreateAccount.go

···
 
 package atproto
 
+// schema: com.atproto.server.createAccount
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.server.createAccount
-
+// ServerCreateAccount_Input is the input argument to a com.atproto.server.createAccount call.
 type ServerCreateAccount_Input struct {
 	Email       string  `json:"email" cborgen:"email"`
 	Handle      string  `json:"handle" cborgen:"handle"`
···
 	RecoveryKey *string `json:"recoveryKey,omitempty" cborgen:"recoveryKey,omitempty"`
 }
 
+// ServerCreateAccount_Output is the output of a com.atproto.server.createAccount call.
 type ServerCreateAccount_Output struct {
 	AccessJwt  string `json:"accessJwt" cborgen:"accessJwt"`
 	Did        string `json:"did" cborgen:"did"`
···
 	RefreshJwt string `json:"refreshJwt" cborgen:"refreshJwt"`
 }
 
+// ServerCreateAccount calls the XRPC method "com.atproto.server.createAccount".
 func ServerCreateAccount(ctx context.Context, c *xrpc.Client, input *ServerCreateAccount_Input) (*ServerCreateAccount_Output, error) {
 	var out ServerCreateAccount_Output
 	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.server.createAccount", nil, input, &out); err != nil {

api/atproto/servercreateAppPassword.go

···
 
 package atproto
 
+// schema: com.atproto.server.createAppPassword
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.server.createAppPassword
-
+// ServerCreateAppPassword_AppPassword is a "appPassword" in the com.atproto.server.createAppPassword schema.
 type ServerCreateAppPassword_AppPassword struct {
 	CreatedAt string `json:"createdAt" cborgen:"createdAt"`
 	Name      string `json:"name" cborgen:"name"`
 	Password  string `json:"password" cborgen:"password"`
 }
 
+// ServerCreateAppPassword_Input is the input argument to a com.atproto.server.createAppPassword call.
 type ServerCreateAppPassword_Input struct {
 	Name string `json:"name" cborgen:"name"`
 }
 
+// ServerCreateAppPassword calls the XRPC method "com.atproto.server.createAppPassword".
 func ServerCreateAppPassword(ctx context.Context, c *xrpc.Client, input *ServerCreateAppPassword_Input) (*ServerCreateAppPassword_AppPassword, error) {
 	var out ServerCreateAppPassword_AppPassword
 	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.server.createAppPassword", nil, input, &out); err != nil {

api/atproto/servercreateInviteCode.go

···
 
 package atproto
 
+// schema: com.atproto.server.createInviteCode
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.server.createInviteCode
-
+// ServerCreateInviteCode_Input is the input argument to a com.atproto.server.createInviteCode call.
 type ServerCreateInviteCode_Input struct {
 	ForAccount *string `json:"forAccount,omitempty" cborgen:"forAccount,omitempty"`
 	UseCount   int64   `json:"useCount" cborgen:"useCount"`
 }
 
+// ServerCreateInviteCode_Output is the output of a com.atproto.server.createInviteCode call.
 type ServerCreateInviteCode_Output struct {
 	Code string `json:"code" cborgen:"code"`
 }
 
+// ServerCreateInviteCode calls the XRPC method "com.atproto.server.createInviteCode".
 func ServerCreateInviteCode(ctx context.Context, c *xrpc.Client, input *ServerCreateInviteCode_Input) (*ServerCreateInviteCode_Output, error) {
 	var out ServerCreateInviteCode_Output
 	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.server.createInviteCode", nil, input, &out); err != nil {

api/atproto/servercreateInviteCodes.go

···
 
 package atproto
 
+// schema: com.atproto.server.createInviteCodes
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.server.createInviteCodes
-
+// ServerCreateInviteCodes_AccountCodes is a "accountCodes" in the com.atproto.server.createInviteCodes schema.
 type ServerCreateInviteCodes_AccountCodes struct {
 	Account string   `json:"account" cborgen:"account"`
 	Codes   []string `json:"codes" cborgen:"codes"`
 }
 
+// ServerCreateInviteCodes_Input is the input argument to a com.atproto.server.createInviteCodes call.
 type ServerCreateInviteCodes_Input struct {
 	CodeCount   int64    `json:"codeCount" cborgen:"codeCount"`
 	ForAccounts []string `json:"forAccounts,omitempty" cborgen:"forAccounts,omitempty"`
 	UseCount    int64    `json:"useCount" cborgen:"useCount"`
 }
 
+// ServerCreateInviteCodes_Output is the output of a com.atproto.server.createInviteCodes call.
 type ServerCreateInviteCodes_Output struct {
 	Codes []*ServerCreateInviteCodes_AccountCodes `json:"codes" cborgen:"codes"`
 }
 
+// ServerCreateInviteCodes calls the XRPC method "com.atproto.server.createInviteCodes".
 func ServerCreateInviteCodes(ctx context.Context, c *xrpc.Client, input *ServerCreateInviteCodes_Input) (*ServerCreateInviteCodes_Output, error) {
 	var out ServerCreateInviteCodes_Output
 	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.server.createInviteCodes", nil, input, &out); err != nil {

api/atproto/servercreateSession.go

···
 
 package atproto
 
+// schema: com.atproto.server.createSession
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.server.createSession
-
+// ServerCreateSession_Input is the input argument to a com.atproto.server.createSession call.
 type ServerCreateSession_Input struct {
+	// identifier: Handle or other identifier supported by the server for the authenticating user.
 	Identifier string `json:"identifier" cborgen:"identifier"`
 	Password   string `json:"password" cborgen:"password"`
 }
 
+// ServerCreateSession_Output is the output of a com.atproto.server.createSession call.
 type ServerCreateSession_Output struct {
 	AccessJwt  string  `json:"accessJwt" cborgen:"accessJwt"`
 	Did        string  `json:"did" cborgen:"did"`
···
 	RefreshJwt string  `json:"refreshJwt" cborgen:"refreshJwt"`
 }
 
+// ServerCreateSession calls the XRPC method "com.atproto.server.createSession".
 func ServerCreateSession(ctx context.Context, c *xrpc.Client, input *ServerCreateSession_Input) (*ServerCreateSession_Output, error) {
 	var out ServerCreateSession_Output
 	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.server.createSession", nil, input, &out); err != nil {

api/atproto/serverdefs.go

···
 
 // schema: com.atproto.server.defs
 
+// ServerDefs_InviteCode is a "inviteCode" in the com.atproto.server.defs schema.
 type ServerDefs_InviteCode struct {
 	Available  int64                       `json:"available" cborgen:"available"`
 	Code       string                      `json:"code" cborgen:"code"`
···
 	Uses       []*ServerDefs_InviteCodeUse `json:"uses" cborgen:"uses"`
 }
 
+// ServerDefs_InviteCodeUse is a "inviteCodeUse" in the com.atproto.server.defs schema.
 type ServerDefs_InviteCodeUse struct {
 	UsedAt string `json:"usedAt" cborgen:"usedAt"`
 	UsedBy string `json:"usedBy" cborgen:"usedBy"`

api/atproto/serverdeleteAccount.go

···
 
 package atproto
 
+// schema: com.atproto.server.deleteAccount
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.server.deleteAccount
-
+// ServerDeleteAccount_Input is the input argument to a com.atproto.server.deleteAccount call.
 type ServerDeleteAccount_Input struct {
 	Did      string `json:"did" cborgen:"did"`
 	Password string `json:"password" cborgen:"password"`
 	Token    string `json:"token" cborgen:"token"`
 }
 
+// ServerDeleteAccount calls the XRPC method "com.atproto.server.deleteAccount".
 func ServerDeleteAccount(ctx context.Context, c *xrpc.Client, input *ServerDeleteAccount_Input) error {
 	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.server.deleteAccount", nil, input, nil); err != nil {
 		return err

api/atproto/serverdeleteSession.go

···
 
 package atproto
 
+// schema: com.atproto.server.deleteSession
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.server.deleteSession
-
+// ServerDeleteSession calls the XRPC method "com.atproto.server.deleteSession".
 func ServerDeleteSession(ctx context.Context, c *xrpc.Client) error {
 	if err := c.Do(ctx, xrpc.Procedure, "", "com.atproto.server.deleteSession", nil, nil, nil); err != nil {
 		return err

api/atproto/serverdescribeServer.go

···
 
 package atproto
 
+// schema: com.atproto.server.describeServer
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.server.describeServer
-
+// ServerDescribeServer_Links is a "links" in the com.atproto.server.describeServer schema.
 type ServerDescribeServer_Links struct {
 	PrivacyPolicy  *string `json:"privacyPolicy,omitempty" cborgen:"privacyPolicy,omitempty"`
 	TermsOfService *string `json:"termsOfService,omitempty" cborgen:"termsOfService,omitempty"`
 }
 
+// ServerDescribeServer_Output is the output of a com.atproto.server.describeServer call.
 type ServerDescribeServer_Output struct {
 	AvailableUserDomains []string                    `json:"availableUserDomains" cborgen:"availableUserDomains"`
 	InviteCodeRequired   *bool                       `json:"inviteCodeRequired,omitempty" cborgen:"inviteCodeRequired,omitempty"`
 	Links                *ServerDescribeServer_Links `json:"links,omitempty" cborgen:"links,omitempty"`
 }
 
+// ServerDescribeServer calls the XRPC method "com.atproto.server.describeServer".
 func ServerDescribeServer(ctx context.Context, c *xrpc.Client) (*ServerDescribeServer_Output, error) {
 	var out ServerDescribeServer_Output
 	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.server.describeServer", nil, nil, &out); err != nil {

api/atproto/servergetAccountInviteCodes.go

···
 
 package atproto
 
+// schema: com.atproto.server.getAccountInviteCodes
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.server.getAccountInviteCodes
-
+// ServerGetAccountInviteCodes_Output is the output of a com.atproto.server.getAccountInviteCodes call.
 type ServerGetAccountInviteCodes_Output struct {
 	Codes []*ServerDefs_InviteCode `json:"codes" cborgen:"codes"`
 }
 
+// ServerGetAccountInviteCodes calls the XRPC method "com.atproto.server.getAccountInviteCodes".
 func ServerGetAccountInviteCodes(ctx context.Context, c *xrpc.Client, createAvailable bool, includeUsed bool) (*ServerGetAccountInviteCodes_Output, error) {
 	var out ServerGetAccountInviteCodes_Output
 

api/atproto/servergetSession.go

···
 
 package atproto
 
+// schema: com.atproto.server.getSession
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.server.getSession
-
+// ServerGetSession_Output is the output of a com.atproto.server.getSession call.
 type ServerGetSession_Output struct {
 	Did    string  `json:"did" cborgen:"did"`
 	Email  *string `json:"email,omitempty" cborgen:"email,omitempty"`
 	Handle string  `json:"handle" cborgen:"handle"`
 }
 
+// ServerGetSession calls the XRPC method "com.atproto.server.getSession".
 func ServerGetSession(ctx context.Context, c *xrpc.Client) (*ServerGetSession_Output, error) {
 	var out ServerGetSession_Output
 	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.server.getSession", nil, nil, &out); err != nil {

api/atproto/serverlistAppPasswords.go

···
 
 package atproto
 
+// schema: com.atproto.server.listAppPasswords
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.server.listAppPasswords
-
+// ServerListAppPasswords_AppPassword is a "appPassword" in the com.atproto.server.listAppPasswords schema.
 type ServerListAppPasswords_AppPassword struct {
 	CreatedAt string `json:"createdAt" cborgen:"createdAt"`
 	Name      string `json:"name" cborgen:"name"`
 }
 
+// ServerListAppPasswords_Output is the output of a com.atproto.server.listAppPasswords call.
 type ServerListAppPasswords_Output struct {
 	Passwords []*ServerListAppPasswords_AppPassword `json:"passwords" cborgen:"passwords"`
 }
 
+// ServerListAppPasswords calls the XRPC method "com.atproto.server.listAppPasswords".
 func ServerListAppPasswords(ctx context.Context, c *xrpc.Client) (*ServerListAppPasswords_Output, error) {
 	var out ServerListAppPasswords_Output
 	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.server.listAppPasswords", nil, nil, &out); err != nil {

api/atproto/serverrefreshSession.go

···
 
 package atproto
 
+// schema: com.atproto.server.refreshSession
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.server.refreshSession
-
+// ServerRefreshSession_Output is the output of a com.atproto.server.refreshSession call.
 type ServerRefreshSession_Output struct {
 	AccessJwt  string `json:"accessJwt" cborgen:"accessJwt"`
 	Did        string `json:"did" cborgen:"did"`
···
 	RefreshJwt string `json:"refreshJwt" cborgen:"refreshJwt"`
 }
 
+// ServerRefreshSession calls the XRPC method "com.atproto.server.refreshSession".
 func ServerRefreshSession(ctx context.Context, c *xrpc.Client) (*ServerRefreshSession_Output, error) {
 	var out ServerRefreshSession_Output
 	if err := c.Do(ctx, xrpc.Procedure, "", "com.atproto.server.refreshSession", nil, nil, &out); err != nil {

api/atproto/serverrequestAccountDelete.go

···
 
 package atproto
 
+// schema: com.atproto.server.requestAccountDelete
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.server.requestAccountDelete
-
+// ServerRequestAccountDelete calls the XRPC method "com.atproto.server.requestAccountDelete".
 func ServerRequestAccountDelete(ctx context.Context, c *xrpc.Client) error {
 	if err := c.Do(ctx, xrpc.Procedure, "", "com.atproto.server.requestAccountDelete", nil, nil, nil); err != nil {
 		return err

api/atproto/serverrequestPasswordReset.go

···
 
 package atproto
 
+// schema: com.atproto.server.requestPasswordReset
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.server.requestPasswordReset
-
+// ServerRequestPasswordReset_Input is the input argument to a com.atproto.server.requestPasswordReset call.
 type ServerRequestPasswordReset_Input struct {
 	Email string `json:"email" cborgen:"email"`
 }
 
+// ServerRequestPasswordReset calls the XRPC method "com.atproto.server.requestPasswordReset".
 func ServerRequestPasswordReset(ctx context.Context, c *xrpc.Client, input *ServerRequestPasswordReset_Input) error {
 	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.server.requestPasswordReset", nil, input, nil); err != nil {
 		return err

api/atproto/serverresetPassword.go

···
 
 package atproto
 
+// schema: com.atproto.server.resetPassword
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.server.resetPassword
-
+// ServerResetPassword_Input is the input argument to a com.atproto.server.resetPassword call.
 type ServerResetPassword_Input struct {
 	Password string `json:"password" cborgen:"password"`
 	Token    string `json:"token" cborgen:"token"`
 }
 
+// ServerResetPassword calls the XRPC method "com.atproto.server.resetPassword".
 func ServerResetPassword(ctx context.Context, c *xrpc.Client, input *ServerResetPassword_Input) error {
 	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.server.resetPassword", nil, input, nil); err != nil {
 		return err

api/atproto/serverrevokeAppPassword.go

···
 
 package atproto
 
+// schema: com.atproto.server.revokeAppPassword
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.server.revokeAppPassword
-
+// ServerRevokeAppPassword_Input is the input argument to a com.atproto.server.revokeAppPassword call.
 type ServerRevokeAppPassword_Input struct {
 	Name string `json:"name" cborgen:"name"`
 }
 
+// ServerRevokeAppPassword calls the XRPC method "com.atproto.server.revokeAppPassword".
 func ServerRevokeAppPassword(ctx context.Context, c *xrpc.Client, input *ServerRevokeAppPassword_Input) error {
 	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.server.revokeAppPassword", nil, input, nil); err != nil {
 		return err

api/atproto/syncgetBlob.go

···
 
 package atproto
 
+// schema: com.atproto.sync.getBlob
+
 import (
 	"bytes"
 	"context"
···
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.sync.getBlob
-
+// SyncGetBlob calls the XRPC method "com.atproto.sync.getBlob".
+//
+// cid: The CID of the blob to fetch
+// did: The DID of the repo.
 func SyncGetBlob(ctx context.Context, c *xrpc.Client, cid string, did string) ([]byte, error) {
 	buf := new(bytes.Buffer)
 

api/atproto/syncgetBlocks.go

···
 
 package atproto
 
+// schema: com.atproto.sync.getBlocks
+
 import (
 	"bytes"
 	"context"
···
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.sync.getBlocks
-
+// SyncGetBlocks calls the XRPC method "com.atproto.sync.getBlocks".
+//
+// did: The DID of the repo.
 func SyncGetBlocks(ctx context.Context, c *xrpc.Client, cids []string, did string) ([]byte, error) {
 	buf := new(bytes.Buffer)
 

api/atproto/syncgetCheckout.go

···
 
 package atproto
 
+// schema: com.atproto.sync.getCheckout
+
 import (
 	"bytes"
 	"context"
···
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.sync.getCheckout
-
+// SyncGetCheckout calls the XRPC method "com.atproto.sync.getCheckout".
+//
+// commit: The commit to get the checkout from. Defaults to current HEAD.
+// did: The DID of the repo.
 func SyncGetCheckout(ctx context.Context, c *xrpc.Client, commit string, did string) ([]byte, error) {
 	buf := new(bytes.Buffer)
 

api/atproto/syncgetCommitPath.go

···
 
 package atproto
 
+// schema: com.atproto.sync.getCommitPath
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.sync.getCommitPath
-
+// SyncGetCommitPath_Output is the output of a com.atproto.sync.getCommitPath call.
 type SyncGetCommitPath_Output struct {
 	Commits []string `json:"commits" cborgen:"commits"`
 }
 
+// SyncGetCommitPath calls the XRPC method "com.atproto.sync.getCommitPath".
+//
+// did: The DID of the repo.
+// earliest: The earliest commit to start from
+// latest: The most recent commit
 func SyncGetCommitPath(ctx context.Context, c *xrpc.Client, did string, earliest string, latest string) (*SyncGetCommitPath_Output, error) {
 	var out SyncGetCommitPath_Output
 

api/atproto/syncgetHead.go

···
 
 package atproto
 
+// schema: com.atproto.sync.getHead
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.sync.getHead
-
+// SyncGetHead_Output is the output of a com.atproto.sync.getHead call.
 type SyncGetHead_Output struct {
 	Root string `json:"root" cborgen:"root"`
 }
 
+// SyncGetHead calls the XRPC method "com.atproto.sync.getHead".
+//
+// did: The DID of the repo.
 func SyncGetHead(ctx context.Context, c *xrpc.Client, did string) (*SyncGetHead_Output, error) {
 	var out SyncGetHead_Output
 

api/atproto/syncgetRecord.go

···
 
 package atproto
 
+// schema: com.atproto.sync.getRecord
+
 import (
 	"bytes"
 	"context"
···
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.sync.getRecord
-
+// SyncGetRecord calls the XRPC method "com.atproto.sync.getRecord".
+//
+// commit: An optional past commit CID.
+// did: The DID of the repo.
 func SyncGetRecord(ctx context.Context, c *xrpc.Client, collection string, commit string, did string, rkey string) ([]byte, error) {
 	buf := new(bytes.Buffer)
 

api/atproto/syncgetRepo.go

···
 
 package atproto
 
+// schema: com.atproto.sync.getRepo
+
 import (
 	"bytes"
 	"context"
···
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.sync.getRepo
-
+// SyncGetRepo calls the XRPC method "com.atproto.sync.getRepo".
+//
+// did: The DID of the repo.
+// earliest: The earliest commit in the commit range (not inclusive)
+// latest: The latest commit in the commit range (inclusive)
 func SyncGetRepo(ctx context.Context, c *xrpc.Client, did string, earliest string, latest string) ([]byte, error) {
 	buf := new(bytes.Buffer)
 

api/atproto/synclistBlobs.go

···
 
 package atproto
 
+// schema: com.atproto.sync.listBlobs
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.sync.listBlobs
-
+// SyncListBlobs_Output is the output of a com.atproto.sync.listBlobs call.
 type SyncListBlobs_Output struct {
 	Cids []string `json:"cids" cborgen:"cids"`
 }
 
+// SyncListBlobs calls the XRPC method "com.atproto.sync.listBlobs".
+//
+// did: The DID of the repo.
+// earliest: The earliest commit to start from
+// latest: The most recent commit
 func SyncListBlobs(ctx context.Context, c *xrpc.Client, did string, earliest string, latest string) (*SyncListBlobs_Output, error) {
 	var out SyncListBlobs_Output
 

api/atproto/synclistRepos.go

···
 
 package atproto
 
+// schema: com.atproto.sync.listRepos
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.sync.listRepos
-
+// SyncListRepos_Output is the output of a com.atproto.sync.listRepos call.
 type SyncListRepos_Output struct {
 	Cursor *string               `json:"cursor,omitempty" cborgen:"cursor,omitempty"`
 	Repos  []*SyncListRepos_Repo `json:"repos" cborgen:"repos"`
 }
 
+// SyncListRepos_Repo is a "repo" in the com.atproto.sync.listRepos schema.
 type SyncListRepos_Repo struct {
 	Did  string `json:"did" cborgen:"did"`
 	Head string `json:"head" cborgen:"head"`
 }
 
+// SyncListRepos calls the XRPC method "com.atproto.sync.listRepos".
 func SyncListRepos(ctx context.Context, c *xrpc.Client, cursor string, limit int64) (*SyncListRepos_Output, error) {
 	var out SyncListRepos_Output
 

api/atproto/syncnotifyOfUpdate.go

···
 
 package atproto
 
+// schema: com.atproto.sync.notifyOfUpdate
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.sync.notifyOfUpdate
-
+// SyncNotifyOfUpdate calls the XRPC method "com.atproto.sync.notifyOfUpdate".
+//
+// hostname: Hostname of the service that is notifying of update.
 func SyncNotifyOfUpdate(ctx context.Context, c *xrpc.Client, hostname string) error {
 
 	params := map[string]interface{}{

api/atproto/syncrequestCrawl.go

···
 
 package atproto
 
+// schema: com.atproto.sync.requestCrawl
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: com.atproto.sync.requestCrawl
-
+// SyncRequestCrawl calls the XRPC method "com.atproto.sync.requestCrawl".
+//
+// hostname: Hostname of the service that is requesting to be crawled.
 func SyncRequestCrawl(ctx context.Context, c *xrpc.Client, hostname string) error {
 
 	params := map[string]interface{}{

api/atproto/syncsubscribeRepos.go

···
 
 package atproto
 
+// schema: com.atproto.sync.subscribeRepos
+
 import (
 	"github.com/bluesky-social/indigo/lex/util"
 )
 
-// schema: com.atproto.sync.subscribeRepos
-
+// SyncSubscribeRepos_Commit is a "commit" in the com.atproto.sync.subscribeRepos schema.
 type SyncSubscribeRepos_Commit struct {
-	Blobs  []util.LexLink               `json:"blobs" cborgen:"blobs"`
+	Blobs []util.LexLink `json:"blobs" cborgen:"blobs"`
+	// blocks: CAR file containing relevant blocks
 	Blocks util.LexBytes                `json:"blocks,omitempty" cborgen:"blocks"`
 	Commit util.LexLink                 `json:"commit" cborgen:"commit"`
 	Ops    []*SyncSubscribeRepos_RepoOp `json:"ops" cborgen:"ops"`
···
 	TooBig bool                         `json:"tooBig" cborgen:"tooBig"`
 }
 
+// SyncSubscribeRepos_Handle is a "handle" in the com.atproto.sync.subscribeRepos schema.
 type SyncSubscribeRepos_Handle struct {
 	Did    string `json:"did" cborgen:"did"`
 	Handle string `json:"handle" cborgen:"handle"`
···
 	Time   string `json:"time" cborgen:"time"`
 }
 
+// SyncSubscribeRepos_Info is a "info" in the com.atproto.sync.subscribeRepos schema.
 type SyncSubscribeRepos_Info struct {
 	Message *string `json:"message,omitempty" cborgen:"message,omitempty"`
 	Name    string  `json:"name" cborgen:"name"`
 }
 
+// SyncSubscribeRepos_Migrate is a "migrate" in the com.atproto.sync.subscribeRepos schema.
 type SyncSubscribeRepos_Migrate struct {
 	Did       string  `json:"did" cborgen:"did"`
 	MigrateTo *string `json:"migrateTo" cborgen:"migrateTo"`
···
 	Time      string  `json:"time" cborgen:"time"`
 }
 
+// SyncSubscribeRepos_RepoOp is a "repoOp" in the com.atproto.sync.subscribeRepos schema.
 type SyncSubscribeRepos_RepoOp struct {
 	Action string        `json:"action" cborgen:"action"`
 	Cid    *util.LexLink `json:"cid" cborgen:"cid"`
 	Path   string        `json:"path" cborgen:"path"`
 }
 
+// SyncSubscribeRepos_Tombstone is a "tombstone" in the com.atproto.sync.subscribeRepos schema.
 type SyncSubscribeRepos_Tombstone struct {
 	Did  string `json:"did" cborgen:"did"`
 	Seq  int64  `json:"seq" cborgen:"seq"`

api/bsky/actordefs.go

···
 
 package bsky
 
+// schema: app.bsky.actor.defs
+
 import (
 	comatprototypes "github.com/bluesky-social/indigo/api/atproto"
 )
 
-// schema: app.bsky.actor.defs
-
+// ActorDefs_ProfileView is a "profileView" in the app.bsky.actor.defs schema.
 type ActorDefs_ProfileView struct {
 	Avatar      *string                            `json:"avatar,omitempty" cborgen:"avatar,omitempty"`
 	Description *string                            `json:"description,omitempty" cborgen:"description,omitempty"`
···
 	Viewer      *ActorDefs_ViewerState             `json:"viewer,omitempty" cborgen:"viewer,omitempty"`
 }
 
+// ActorDefs_ProfileViewBasic is a "profileViewBasic" in the app.bsky.actor.defs schema.
 type ActorDefs_ProfileViewBasic struct {
 	Avatar      *string                            `json:"avatar,omitempty" cborgen:"avatar,omitempty"`
 	Did         string                             `json:"did" cborgen:"did"`
···
 	Viewer      *ActorDefs_ViewerState             `json:"viewer,omitempty" cborgen:"viewer,omitempty"`
 }
 
+// ActorDefs_ProfileViewDetailed is a "profileViewDetailed" in the app.bsky.actor.defs schema.
 type ActorDefs_ProfileViewDetailed struct {
 	Avatar         *string                            `json:"avatar,omitempty" cborgen:"avatar,omitempty"`
 	Banner         *string                            `json:"banner,omitempty" cborgen:"banner,omitempty"`
···
 	Viewer         *ActorDefs_ViewerState             `json:"viewer,omitempty" cborgen:"viewer,omitempty"`
 }
 
+// ActorDefs_ViewerState is a "viewerState" in the app.bsky.actor.defs schema.
 type ActorDefs_ViewerState struct {
 	FollowedBy *string `json:"followedBy,omitempty" cborgen:"followedBy,omitempty"`
 	Following  *string `json:"following,omitempty" cborgen:"following,omitempty"`

api/bsky/actorgetProfile.go

···
 
 package bsky
 
+// schema: app.bsky.actor.getProfile
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: app.bsky.actor.getProfile
-
+// ActorGetProfile calls the XRPC method "app.bsky.actor.getProfile".
 func ActorGetProfile(ctx context.Context, c *xrpc.Client, actor string) (*ActorDefs_ProfileViewDetailed, error) {
 	var out ActorDefs_ProfileViewDetailed
 

api/bsky/actorgetProfiles.go

···
 
 package bsky
 
+// schema: app.bsky.actor.getProfiles
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: app.bsky.actor.getProfiles
-
+// ActorGetProfiles_Output is the output of a app.bsky.actor.getProfiles call.
 type ActorGetProfiles_Output struct {
 	Profiles []*ActorDefs_ProfileViewDetailed `json:"profiles" cborgen:"profiles"`
 }
 
+// ActorGetProfiles calls the XRPC method "app.bsky.actor.getProfiles".
 func ActorGetProfiles(ctx context.Context, c *xrpc.Client, actors []string) (*ActorGetProfiles_Output, error) {
 	var out ActorGetProfiles_Output
 

api/bsky/actorgetSuggestions.go

···
 
 package bsky
 
+// schema: app.bsky.actor.getSuggestions
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: app.bsky.actor.getSuggestions
-
+// ActorGetSuggestions_Output is the output of a app.bsky.actor.getSuggestions call.
 type ActorGetSuggestions_Output struct {
 	Actors []*ActorDefs_ProfileView `json:"actors" cborgen:"actors"`
 	Cursor *string                  `json:"cursor,omitempty" cborgen:"cursor,omitempty"`
 }
 
+// ActorGetSuggestions calls the XRPC method "app.bsky.actor.getSuggestions".
 func ActorGetSuggestions(ctx context.Context, c *xrpc.Client, cursor string, limit int64) (*ActorGetSuggestions_Output, error) {
 	var out ActorGetSuggestions_Output
 

api/bsky/actorprofile.go

···
 
 package bsky
 
+// schema: app.bsky.actor.profile
+
 import (
 	"github.com/bluesky-social/indigo/lex/util"
 )
-
-// schema: app.bsky.actor.profile
 
 func init() {
 	util.RegisterType("app.bsky.actor.profile", &ActorProfile{})
-} // RECORDTYPE: ActorProfile
+} //
+// RECORDTYPE: ActorProfile
 type ActorProfile struct {
 	LexiconTypeID string        `json:"$type,const=app.bsky.actor.profile" cborgen:"$type,const=app.bsky.actor.profile"`
 	Avatar        *util.LexBlob `json:"avatar,omitempty" cborgen:"avatar,omitempty"`

api/bsky/actorsearchActors.go

···
 
 package bsky
 
+// schema: app.bsky.actor.searchActors
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: app.bsky.actor.searchActors
-
+// ActorSearchActors_Output is the output of a app.bsky.actor.searchActors call.
 type ActorSearchActors_Output struct {
 	Actors []*ActorDefs_ProfileView `json:"actors" cborgen:"actors"`
 	Cursor *string                  `json:"cursor,omitempty" cborgen:"cursor,omitempty"`
 }
 
+// ActorSearchActors calls the XRPC method "app.bsky.actor.searchActors".
 func ActorSearchActors(ctx context.Context, c *xrpc.Client, cursor string, limit int64, term string) (*ActorSearchActors_Output, error) {
 	var out ActorSearchActors_Output
 

api/bsky/actorsearchActorsTypeahead.go

···
 
 package bsky
 
+// schema: app.bsky.actor.searchActorsTypeahead
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: app.bsky.actor.searchActorsTypeahead
-
+// ActorSearchActorsTypeahead_Output is the output of a app.bsky.actor.searchActorsTypeahead call.
 type ActorSearchActorsTypeahead_Output struct {
 	Actors []*ActorDefs_ProfileViewBasic `json:"actors" cborgen:"actors"`
 }
 
+// ActorSearchActorsTypeahead calls the XRPC method "app.bsky.actor.searchActorsTypeahead".
 func ActorSearchActorsTypeahead(ctx context.Context, c *xrpc.Client, limit int64, term string) (*ActorSearchActorsTypeahead_Output, error) {
 	var out ActorSearchActorsTypeahead_Output
 

api/bsky/embedexternal.go

···
 
 package bsky
 
+// schema: app.bsky.embed.external
+
 import (
 	"github.com/bluesky-social/indigo/lex/util"
 )
 
-// schema: app.bsky.embed.external
-
 func init() {
 	util.RegisterType("app.bsky.embed.external#main", &EmbedExternal{})
-} // RECORDTYPE: EmbedExternal
+} // EmbedExternal is a "main" in the app.bsky.embed.external schema.
+// RECORDTYPE: EmbedExternal
 type EmbedExternal struct {
 	LexiconTypeID string                  `json:"$type,const=app.bsky.embed.external" cborgen:"$type,const=app.bsky.embed.external"`
 	External      *EmbedExternal_External `json:"external" cborgen:"external"`
 }
 
+// EmbedExternal_External is a "external" in the app.bsky.embed.external schema.
 type EmbedExternal_External struct {
 	Description string        `json:"description" cborgen:"description"`
 	Thumb       *util.LexBlob `json:"thumb,omitempty" cborgen:"thumb,omitempty"`
···
 	Uri         string        `json:"uri" cborgen:"uri"`
 }
 
+// EmbedExternal_View is a "view" in the app.bsky.embed.external schema.
+//
 // RECORDTYPE: EmbedExternal_View
 type EmbedExternal_View struct {
 	LexiconTypeID string                      `json:"$type,const=app.bsky.embed.external" cborgen:"$type,const=app.bsky.embed.external"`
 	External      *EmbedExternal_ViewExternal `json:"external" cborgen:"external"`
 }
 
+// EmbedExternal_ViewExternal is a "viewExternal" in the app.bsky.embed.external schema.
 type EmbedExternal_ViewExternal struct {
 	Description string  `json:"description" cborgen:"description"`
 	Thumb       *string `json:"thumb,omitempty" cborgen:"thumb,omitempty"`

api/bsky/embedimages.go

···
 
 package bsky
 
+// schema: app.bsky.embed.images
+
 import (
 	"github.com/bluesky-social/indigo/lex/util"
 )
 
-// schema: app.bsky.embed.images
-
 func init() {
 	util.RegisterType("app.bsky.embed.images#main", &EmbedImages{})
-} // RECORDTYPE: EmbedImages
+} // EmbedImages is a "main" in the app.bsky.embed.images schema.
+// RECORDTYPE: EmbedImages
 type EmbedImages struct {
 	LexiconTypeID string               `json:"$type,const=app.bsky.embed.images" cborgen:"$type,const=app.bsky.embed.images"`
 	Images        []*EmbedImages_Image `json:"images" cborgen:"images"`
 }
 
+// EmbedImages_Image is a "image" in the app.bsky.embed.images schema.
 type EmbedImages_Image struct {
 	Alt   string        `json:"alt" cborgen:"alt"`
 	Image *util.LexBlob `json:"image" cborgen:"image"`
 }
 
+// EmbedImages_View is a "view" in the app.bsky.embed.images schema.
+//
 // RECORDTYPE: EmbedImages_View
 type EmbedImages_View struct {
 	LexiconTypeID string                   `json:"$type,const=app.bsky.embed.images" cborgen:"$type,const=app.bsky.embed.images"`
 	Images        []*EmbedImages_ViewImage `json:"images" cborgen:"images"`
 }
 
+// EmbedImages_ViewImage is a "viewImage" in the app.bsky.embed.images schema.
 type EmbedImages_ViewImage struct {
 	Alt      string `json:"alt" cborgen:"alt"`
 	Fullsize string `json:"fullsize" cborgen:"fullsize"`

api/bsky/embedrecord.go

···
 
 package bsky
 
+// schema: app.bsky.embed.record
+
 import (
 	"encoding/json"
 	"fmt"
···
 	"github.com/bluesky-social/indigo/lex/util"
 )
 
-// schema: app.bsky.embed.record
-
 func init() {
 	util.RegisterType("app.bsky.embed.record#main", &EmbedRecord{})
-} // RECORDTYPE: EmbedRecord
+} // EmbedRecord is a "main" in the app.bsky.embed.record schema.
+// RECORDTYPE: EmbedRecord
 type EmbedRecord struct {
 	LexiconTypeID string                         `json:"$type,const=app.bsky.embed.record" cborgen:"$type,const=app.bsky.embed.record"`
 	Record        *comatprototypes.RepoStrongRef `json:"record" cborgen:"record"`
 }
 
+// EmbedRecord_View is a "view" in the app.bsky.embed.record schema.
+//
 // RECORDTYPE: EmbedRecord_View
 type EmbedRecord_View struct {
 	LexiconTypeID string                   `json:"$type,const=app.bsky.embed.record" cborgen:"$type,const=app.bsky.embed.record"`
 	Record        *EmbedRecord_View_Record `json:"record" cborgen:"record"`
 }
 
+// EmbedRecord_ViewNotFound is a "viewNotFound" in the app.bsky.embed.record schema.
+//
 // RECORDTYPE: EmbedRecord_ViewNotFound
 type EmbedRecord_ViewNotFound struct {
 	LexiconTypeID string `json:"$type,const=app.bsky.embed.record" cborgen:"$type,const=app.bsky.embed.record"`
 	Uri           string `json:"uri" cborgen:"uri"`
 }
 
+// EmbedRecord_ViewRecord is a "viewRecord" in the app.bsky.embed.record schema.
+//
 // RECORDTYPE: EmbedRecord_ViewRecord
 type EmbedRecord_ViewRecord struct {
 	LexiconTypeID string                                `json:"$type,const=app.bsky.embed.record" cborgen:"$type,const=app.bsky.embed.record"`

api/bsky/embedrecordWithMedia.go

···
 
 package bsky
 
+// schema: app.bsky.embed.recordWithMedia
+
 import (
 	"bytes"
 	"encoding/json"
···
 	cbg "github.com/whyrusleeping/cbor-gen"
 )
 
-// schema: app.bsky.embed.recordWithMedia
-
 func init() {
 	util.RegisterType("app.bsky.embed.recordWithMedia#main", &EmbedRecordWithMedia{})
-} // RECORDTYPE: EmbedRecordWithMedia
+} // EmbedRecordWithMedia is a "main" in the app.bsky.embed.recordWithMedia schema.
+// RECORDTYPE: EmbedRecordWithMedia
 type EmbedRecordWithMedia struct {
 	LexiconTypeID string                      `json:"$type,const=app.bsky.embed.recordWithMedia" cborgen:"$type,const=app.bsky.embed.recordWithMedia"`
 	Media         *EmbedRecordWithMedia_Media `json:"media" cborgen:"media"`
···
 	}
 }
 
+// EmbedRecordWithMedia_View is a "view" in the app.bsky.embed.recordWithMedia schema.
+//
 // RECORDTYPE: EmbedRecordWithMedia_View
 type EmbedRecordWithMedia_View struct {
 	LexiconTypeID string                           `json:"$type,const=app.bsky.embed.recordWithMedia" cborgen:"$type,const=app.bsky.embed.recordWithMedia"`

api/bsky/feeddefs.go

···
 
 package bsky
 
+// schema: app.bsky.feed.defs
+
 import (
 	"encoding/json"
 	"fmt"
···
 	"github.com/bluesky-social/indigo/lex/util"
 )
 
-// schema: app.bsky.feed.defs
-
+// FeedDefs_FeedViewPost is a "feedViewPost" in the app.bsky.feed.defs schema.
 type FeedDefs_FeedViewPost struct {
 	Post   *FeedDefs_PostView            `json:"post" cborgen:"post"`
 	Reason *FeedDefs_FeedViewPost_Reason `json:"reason,omitempty" cborgen:"reason,omitempty"`
···
 	}
 }
 
+// FeedDefs_NotFoundPost is a "notFoundPost" in the app.bsky.feed.defs schema.
+//
 // RECORDTYPE: FeedDefs_NotFoundPost
 type FeedDefs_NotFoundPost struct {
 	LexiconTypeID string `json:"$type,const=app.bsky.feed.defs" cborgen:"$type,const=app.bsky.feed.defs"`
···
 	Uri           string `json:"uri" cborgen:"uri"`
 }
 
+// FeedDefs_PostView is a "postView" in the app.bsky.feed.defs schema.
 type FeedDefs_PostView struct {
 	Author      *ActorDefs_ProfileViewBasic        `json:"author" cborgen:"author"`
 	Cid         string                             `json:"cid" cborgen:"cid"`
···
 	}
 }
 
+// FeedDefs_ReasonRepost is a "reasonRepost" in the app.bsky.feed.defs schema.
+//
 // RECORDTYPE: FeedDefs_ReasonRepost
 type FeedDefs_ReasonRepost struct {
 	LexiconTypeID string                      `json:"$type,const=app.bsky.feed.defs" cborgen:"$type,const=app.bsky.feed.defs"`
···
 	IndexedAt     string                      `json:"indexedAt" cborgen:"indexedAt"`
 }
 
+// FeedDefs_ReplyRef is a "replyRef" in the app.bsky.feed.defs schema.
 type FeedDefs_ReplyRef struct {
 	Parent *FeedDefs_PostView `json:"parent" cborgen:"parent"`
 	Root   *FeedDefs_PostView `json:"root" cborgen:"root"`
 }
 
+// FeedDefs_ThreadViewPost is a "threadViewPost" in the app.bsky.feed.defs schema.
+//
 // RECORDTYPE: FeedDefs_ThreadViewPost
 type FeedDefs_ThreadViewPost struct {
 	LexiconTypeID string                                  `json:"$type,const=app.bsky.feed.defs" cborgen:"$type,const=app.bsky.feed.defs"`
···
 	}
 }
 
+// FeedDefs_ViewerState is a "viewerState" in the app.bsky.feed.defs schema.
 type FeedDefs_ViewerState struct {
 	Like   *string `json:"like,omitempty" cborgen:"like,omitempty"`
 	Repost *string `json:"repost,omitempty" cborgen:"repost,omitempty"`

api/bsky/feedgetAuthorFeed.go

···
 
 package bsky
 
+// schema: app.bsky.feed.getAuthorFeed
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: app.bsky.feed.getAuthorFeed
-
+// FeedGetAuthorFeed_Output is the output of a app.bsky.feed.getAuthorFeed call.
 type FeedGetAuthorFeed_Output struct {
 	Cursor *string                  `json:"cursor,omitempty" cborgen:"cursor,omitempty"`
 	Feed   []*FeedDefs_FeedViewPost `json:"feed" cborgen:"feed"`
 }
 
+// FeedGetAuthorFeed calls the XRPC method "app.bsky.feed.getAuthorFeed".
 func FeedGetAuthorFeed(ctx context.Context, c *xrpc.Client, actor string, cursor string, limit int64) (*FeedGetAuthorFeed_Output, error) {
 	var out FeedGetAuthorFeed_Output
 

api/bsky/feedgetLikes.go

···
 
 package bsky
 
+// schema: app.bsky.feed.getLikes
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: app.bsky.feed.getLikes
-
+// FeedGetLikes_Like is a "like" in the app.bsky.feed.getLikes schema.
 type FeedGetLikes_Like struct {
 	Actor     *ActorDefs_ProfileView `json:"actor" cborgen:"actor"`
 	CreatedAt string                 `json:"createdAt" cborgen:"createdAt"`
 	IndexedAt string                 `json:"indexedAt" cborgen:"indexedAt"`
 }
 
+// FeedGetLikes_Output is the output of a app.bsky.feed.getLikes call.
 type FeedGetLikes_Output struct {
 	Cid    *string              `json:"cid,omitempty" cborgen:"cid,omitempty"`
 	Cursor *string              `json:"cursor,omitempty" cborgen:"cursor,omitempty"`
···
 	Uri    string               `json:"uri" cborgen:"uri"`
 }
 
+// FeedGetLikes calls the XRPC method "app.bsky.feed.getLikes".
 func FeedGetLikes(ctx context.Context, c *xrpc.Client, cid string, cursor string, limit int64, uri string) (*FeedGetLikes_Output, error) {
 	var out FeedGetLikes_Output
 

api/bsky/feedgetPostThread.go

···
 
 package bsky
 
+// schema: app.bsky.feed.getPostThread
+
 import (
 	"context"
 	"encoding/json"
···
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: app.bsky.feed.getPostThread
-
+// FeedGetPostThread_Output is the output of a app.bsky.feed.getPostThread call.
 type FeedGetPostThread_Output struct {
 	Thread *FeedGetPostThread_Output_Thread `json:"thread" cborgen:"thread"`
 }
···
 	}
 }
 
+// FeedGetPostThread calls the XRPC method "app.bsky.feed.getPostThread".
 func FeedGetPostThread(ctx context.Context, c *xrpc.Client, depth int64, uri string) (*FeedGetPostThread_Output, error) {
 	var out FeedGetPostThread_Output
 

api/bsky/feedgetPosts.go

···
 
 package bsky
 
+// schema: app.bsky.feed.getPosts
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: app.bsky.feed.getPosts
-
+// FeedGetPosts_Output is the output of a app.bsky.feed.getPosts call.
 type FeedGetPosts_Output struct {
 	Posts []*FeedDefs_PostView `json:"posts" cborgen:"posts"`
 }
 
+// FeedGetPosts calls the XRPC method "app.bsky.feed.getPosts".
 func FeedGetPosts(ctx context.Context, c *xrpc.Client, uris []string) (*FeedGetPosts_Output, error) {
 	var out FeedGetPosts_Output
 

api/bsky/feedgetRepostedBy.go

···
 
 package bsky
 
+// schema: app.bsky.feed.getRepostedBy
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: app.bsky.feed.getRepostedBy
-
+// FeedGetRepostedBy_Output is the output of a app.bsky.feed.getRepostedBy call.
 type FeedGetRepostedBy_Output struct {
 	Cid        *string                  `json:"cid,omitempty" cborgen:"cid,omitempty"`
 	Cursor     *string                  `json:"cursor,omitempty" cborgen:"cursor,omitempty"`
···
 	Uri        string                   `json:"uri" cborgen:"uri"`
 }
 
+// FeedGetRepostedBy calls the XRPC method "app.bsky.feed.getRepostedBy".
 func FeedGetRepostedBy(ctx context.Context, c *xrpc.Client, cid string, cursor string, limit int64, uri string) (*FeedGetRepostedBy_Output, error) {
 	var out FeedGetRepostedBy_Output
 

api/bsky/feedgetTimeline.go

···
 
 package bsky
 
+// schema: app.bsky.feed.getTimeline
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: app.bsky.feed.getTimeline
-
+// FeedGetTimeline_Output is the output of a app.bsky.feed.getTimeline call.
 type FeedGetTimeline_Output struct {
 	Cursor *string                  `json:"cursor,omitempty" cborgen:"cursor,omitempty"`
 	Feed   []*FeedDefs_FeedViewPost `json:"feed" cborgen:"feed"`
 }
 
+// FeedGetTimeline calls the XRPC method "app.bsky.feed.getTimeline".
 func FeedGetTimeline(ctx context.Context, c *xrpc.Client, algorithm string, cursor string, limit int64) (*FeedGetTimeline_Output, error) {
 	var out FeedGetTimeline_Output
 

api/bsky/feedlike.go

···
 
 package bsky
 
+// schema: app.bsky.feed.like
+
 import (
 	comatprototypes "github.com/bluesky-social/indigo/api/atproto"
 	"github.com/bluesky-social/indigo/lex/util"
 )
-
-// schema: app.bsky.feed.like
 
 func init() {
 	util.RegisterType("app.bsky.feed.like", &FeedLike{})
-} // RECORDTYPE: FeedLike
+} //
+// RECORDTYPE: FeedLike
 type FeedLike struct {
 	LexiconTypeID string                         `json:"$type,const=app.bsky.feed.like" cborgen:"$type,const=app.bsky.feed.like"`
 	CreatedAt     string                         `json:"createdAt" cborgen:"createdAt"`

api/bsky/feedpost.go

···
 
 package bsky
 
+// schema: app.bsky.feed.post
+
 import (
 	"bytes"
 	"encoding/json"
···
 	cbg "github.com/whyrusleeping/cbor-gen"
 )
 
-// schema: app.bsky.feed.post
-
 func init() {
 	util.RegisterType("app.bsky.feed.post", &FeedPost{})
-} // RECORDTYPE: FeedPost
+} //
+// RECORDTYPE: FeedPost
 type FeedPost struct {
-	LexiconTypeID string             `json:"$type,const=app.bsky.feed.post" cborgen:"$type,const=app.bsky.feed.post"`
-	CreatedAt     string             `json:"createdAt" cborgen:"createdAt"`
-	Embed         *FeedPost_Embed    `json:"embed,omitempty" cborgen:"embed,omitempty"`
-	Entities      []*FeedPost_Entity `json:"entities,omitempty" cborgen:"entities,omitempty"`
-	Facets        []*RichtextFacet   `json:"facets,omitempty" cborgen:"facets,omitempty"`
-	Reply         *FeedPost_ReplyRef `json:"reply,omitempty" cborgen:"reply,omitempty"`
-	Text          string             `json:"text" cborgen:"text"`
+	LexiconTypeID string          `json:"$type,const=app.bsky.feed.post" cborgen:"$type,const=app.bsky.feed.post"`
+	CreatedAt     string          `json:"createdAt" cborgen:"createdAt"`
+	Embed         *FeedPost_Embed `json:"embed,omitempty" cborgen:"embed,omitempty"`
+	// entities: Deprecated: replaced by app.bsky.richtext.facet.
+	Entities []*FeedPost_Entity `json:"entities,omitempty" cborgen:"entities,omitempty"`
+	Facets   []*RichtextFacet   `json:"facets,omitempty" cborgen:"facets,omitempty"`
+	Reply    *FeedPost_ReplyRef `json:"reply,omitempty" cborgen:"reply,omitempty"`
+	Text     string             `json:"text" cborgen:"text"`
 }
 
 type FeedPost_Embed struct {
···
 	}
 }
 
+// FeedPost_Entity is a "entity" in the app.bsky.feed.post schema.
+//
+// Deprecated: use facets instead.
 type FeedPost_Entity struct {
 	Index *FeedPost_TextSlice `json:"index" cborgen:"index"`
-	Type  string              `json:"type" cborgen:"type"`
-	Value string              `json:"value" cborgen:"value"`
+	// type: Expected values are 'mention' and 'link'.
+	Type  string `json:"type" cborgen:"type"`
+	Value string `json:"value" cborgen:"value"`
 }
 
+// FeedPost_ReplyRef is a "replyRef" in the app.bsky.feed.post schema.
 type FeedPost_ReplyRef struct {
 	Parent *comatprototypes.RepoStrongRef `json:"parent" cborgen:"parent"`
 	Root   *comatprototypes.RepoStrongRef `json:"root" cborgen:"root"`
 }
 
+// FeedPost_TextSlice is a "textSlice" in the app.bsky.feed.post schema.
+//
+// Deprecated. Use app.bsky.richtext instead -- A text segment. Start is inclusive, end is exclusive. Indices are for utf16-encoded strings.
 type FeedPost_TextSlice struct {
 	End   int64 `json:"end" cborgen:"end"`
 	Start int64 `json:"start" cborgen:"start"`

api/bsky/feedrepost.go

···
 
 package bsky
 
+// schema: app.bsky.feed.repost
+
 import (
 	comatprototypes "github.com/bluesky-social/indigo/api/atproto"
 	"github.com/bluesky-social/indigo/lex/util"
 )
-
-// schema: app.bsky.feed.repost
 
 func init() {
 	util.RegisterType("app.bsky.feed.repost", &FeedRepost{})
-} // RECORDTYPE: FeedRepost
+} //
+// RECORDTYPE: FeedRepost
 type FeedRepost struct {
 	LexiconTypeID string                         `json:"$type,const=app.bsky.feed.repost" cborgen:"$type,const=app.bsky.feed.repost"`
 	CreatedAt     string                         `json:"createdAt" cborgen:"createdAt"`

api/bsky/graphfollow.go

···
 
 package bsky
 
+// schema: app.bsky.graph.follow
+
 import (
 	"github.com/bluesky-social/indigo/lex/util"
 )
-
-// schema: app.bsky.graph.follow
 
 func init() {
 	util.RegisterType("app.bsky.graph.follow", &GraphFollow{})
-} // RECORDTYPE: GraphFollow
+} //
+// RECORDTYPE: GraphFollow
 type GraphFollow struct {
 	LexiconTypeID string `json:"$type,const=app.bsky.graph.follow" cborgen:"$type,const=app.bsky.graph.follow"`
 	CreatedAt     string `json:"createdAt" cborgen:"createdAt"`

api/bsky/graphgetFollowers.go

···
 
 package bsky
 
+// schema: app.bsky.graph.getFollowers
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: app.bsky.graph.getFollowers
-
+// GraphGetFollowers_Output is the output of a app.bsky.graph.getFollowers call.
 type GraphGetFollowers_Output struct {
 	Cursor    *string                  `json:"cursor,omitempty" cborgen:"cursor,omitempty"`
 	Followers []*ActorDefs_ProfileView `json:"followers" cborgen:"followers"`
 	Subject   *ActorDefs_ProfileView   `json:"subject" cborgen:"subject"`
 }
 
+// GraphGetFollowers calls the XRPC method "app.bsky.graph.getFollowers".
 func GraphGetFollowers(ctx context.Context, c *xrpc.Client, actor string, cursor string, limit int64) (*GraphGetFollowers_Output, error) {
 	var out GraphGetFollowers_Output
 

api/bsky/graphgetFollows.go

···
 
 package bsky
 
+// schema: app.bsky.graph.getFollows
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: app.bsky.graph.getFollows
-
+// GraphGetFollows_Output is the output of a app.bsky.graph.getFollows call.
 type GraphGetFollows_Output struct {
 	Cursor  *string                  `json:"cursor,omitempty" cborgen:"cursor,omitempty"`
 	Follows []*ActorDefs_ProfileView `json:"follows" cborgen:"follows"`
 	Subject *ActorDefs_ProfileView   `json:"subject" cborgen:"subject"`
 }
 
+// GraphGetFollows calls the XRPC method "app.bsky.graph.getFollows".
 func GraphGetFollows(ctx context.Context, c *xrpc.Client, actor string, cursor string, limit int64) (*GraphGetFollows_Output, error) {
 	var out GraphGetFollows_Output
 

api/bsky/graphgetMutes.go

···
 
 package bsky
 
+// schema: app.bsky.graph.getMutes
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: app.bsky.graph.getMutes
-
+// GraphGetMutes_Output is the output of a app.bsky.graph.getMutes call.
 type GraphGetMutes_Output struct {
 	Cursor *string                  `json:"cursor,omitempty" cborgen:"cursor,omitempty"`
 	Mutes  []*ActorDefs_ProfileView `json:"mutes" cborgen:"mutes"`
 }
 
+// GraphGetMutes calls the XRPC method "app.bsky.graph.getMutes".
 func GraphGetMutes(ctx context.Context, c *xrpc.Client, cursor string, limit int64) (*GraphGetMutes_Output, error) {
 	var out GraphGetMutes_Output
 

api/bsky/graphmuteActor.go

···
 
 package bsky
 
+// schema: app.bsky.graph.muteActor
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: app.bsky.graph.muteActor
-
+// GraphMuteActor_Input is the input argument to a app.bsky.graph.muteActor call.
 type GraphMuteActor_Input struct {
 	Actor string `json:"actor" cborgen:"actor"`
 }
 
+// GraphMuteActor calls the XRPC method "app.bsky.graph.muteActor".
 func GraphMuteActor(ctx context.Context, c *xrpc.Client, input *GraphMuteActor_Input) error {
 	if err := c.Do(ctx, xrpc.Procedure, "application/json", "app.bsky.graph.muteActor", nil, input, nil); err != nil {
 		return err

api/bsky/graphunmuteActor.go

···
 
 package bsky
 
+// schema: app.bsky.graph.unmuteActor
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: app.bsky.graph.unmuteActor
-
+// GraphUnmuteActor_Input is the input argument to a app.bsky.graph.unmuteActor call.
 type GraphUnmuteActor_Input struct {
 	Actor string `json:"actor" cborgen:"actor"`
 }
 
+// GraphUnmuteActor calls the XRPC method "app.bsky.graph.unmuteActor".
 func GraphUnmuteActor(ctx context.Context, c *xrpc.Client, input *GraphUnmuteActor_Input) error {
 	if err := c.Do(ctx, xrpc.Procedure, "application/json", "app.bsky.graph.unmuteActor", nil, input, nil); err != nil {
 		return err

api/bsky/notificationgetUnreadCount.go

···
 
 package bsky
 
+// schema: app.bsky.notification.getUnreadCount
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: app.bsky.notification.getUnreadCount
-
+// NotificationGetUnreadCount_Output is the output of a app.bsky.notification.getUnreadCount call.
 type NotificationGetUnreadCount_Output struct {
 	Count int64 `json:"count" cborgen:"count"`
 }
 
+// NotificationGetUnreadCount calls the XRPC method "app.bsky.notification.getUnreadCount".
 func NotificationGetUnreadCount(ctx context.Context, c *xrpc.Client, seenAt string) (*NotificationGetUnreadCount_Output, error) {
 	var out NotificationGetUnreadCount_Output
 

api/bsky/notificationlistNotifications.go

···
 
 package bsky
 
+// schema: app.bsky.notification.listNotifications
+
 import (
 	"context"
 
···
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: app.bsky.notification.listNotifications
-
+// NotificationListNotifications_Notification is a "notification" in the app.bsky.notification.listNotifications schema.
 type NotificationListNotifications_Notification struct {
-	Author        *ActorDefs_ProfileView             `json:"author" cborgen:"author"`
-	Cid           string                             `json:"cid" cborgen:"cid"`
-	IndexedAt     string                             `json:"indexedAt" cborgen:"indexedAt"`
-	IsRead        bool                               `json:"isRead" cborgen:"isRead"`
-	Labels        []*comatprototypes.LabelDefs_Label `json:"labels,omitempty" cborgen:"labels,omitempty"`
-	Reason        string                             `json:"reason" cborgen:"reason"`
-	ReasonSubject *string                            `json:"reasonSubject,omitempty" cborgen:"reasonSubject,omitempty"`
-	Record        *util.LexiconTypeDecoder           `json:"record" cborgen:"record"`
-	Uri           string                             `json:"uri" cborgen:"uri"`
+	Author    *ActorDefs_ProfileView             `json:"author" cborgen:"author"`
+	Cid       string                             `json:"cid" cborgen:"cid"`
+	IndexedAt string                             `json:"indexedAt" cborgen:"indexedAt"`
+	IsRead    bool                               `json:"isRead" cborgen:"isRead"`
+	Labels    []*comatprototypes.LabelDefs_Label `json:"labels,omitempty" cborgen:"labels,omitempty"`
+	// reason: Expected values are 'like', 'repost', 'follow', 'mention', 'reply', and 'quote'.
+	Reason        string                   `json:"reason" cborgen:"reason"`
+	ReasonSubject *string                  `json:"reasonSubject,omitempty" cborgen:"reasonSubject,omitempty"`
+	Record        *util.LexiconTypeDecoder `json:"record" cborgen:"record"`
+	Uri           string                   `json:"uri" cborgen:"uri"`
 }
 
+// NotificationListNotifications_Output is the output of a app.bsky.notification.listNotifications call.
 type NotificationListNotifications_Output struct {
 	Cursor        *string                                       `json:"cursor,omitempty" cborgen:"cursor,omitempty"`
 	Notifications []*NotificationListNotifications_Notification `json:"notifications" cborgen:"notifications"`
 }
 
+// NotificationListNotifications calls the XRPC method "app.bsky.notification.listNotifications".
 func NotificationListNotifications(ctx context.Context, c *xrpc.Client, cursor string, limit int64, seenAt string) (*NotificationListNotifications_Output, error) {
 	var out NotificationListNotifications_Output
 

api/bsky/notificationupdateSeen.go

···
 
 package bsky
 
+// schema: app.bsky.notification.updateSeen
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: app.bsky.notification.updateSeen
-
+// NotificationUpdateSeen_Input is the input argument to a app.bsky.notification.updateSeen call.
 type NotificationUpdateSeen_Input struct {
 	SeenAt string `json:"seenAt" cborgen:"seenAt"`
 }
 
+// NotificationUpdateSeen calls the XRPC method "app.bsky.notification.updateSeen".
 func NotificationUpdateSeen(ctx context.Context, c *xrpc.Client, input *NotificationUpdateSeen_Input) error {
 	if err := c.Do(ctx, xrpc.Procedure, "application/json", "app.bsky.notification.updateSeen", nil, input, nil); err != nil {
 		return err

api/bsky/richtextfacet.go

···
 
 package bsky
 
+// schema: app.bsky.richtext.facet
+
 import (
 	"bytes"
 	"encoding/json"
···
 	cbg "github.com/whyrusleeping/cbor-gen"
 )
 
-// schema: app.bsky.richtext.facet
-
+// RichtextFacet is a "main" in the app.bsky.richtext.facet schema.
 type RichtextFacet struct {
 	Features []*RichtextFacet_Features_Elem `json:"features" cborgen:"features"`
 	Index    *RichtextFacet_ByteSlice       `json:"index" cborgen:"index"`
 }
 
+// RichtextFacet_ByteSlice is a "byteSlice" in the app.bsky.richtext.facet schema.
+//
+// A text segment. Start is inclusive, end is exclusive. Indices are for utf8-encoded strings.
 type RichtextFacet_ByteSlice struct {
 	ByteEnd   int64 `json:"byteEnd" cborgen:"byteEnd"`
 	ByteStart int64 `json:"byteStart" cborgen:"byteStart"`
···
 	}
 }
 
+// RichtextFacet_Link is a "link" in the app.bsky.richtext.facet schema.
+//
+// A facet feature for links.
+//
 // RECORDTYPE: RichtextFacet_Link
 type RichtextFacet_Link struct {
 	LexiconTypeID string `json:"$type,const=app.bsky.richtext.facet" cborgen:"$type,const=app.bsky.richtext.facet"`
 	Uri           string `json:"uri" cborgen:"uri"`
 }
 
+// RichtextFacet_Mention is a "mention" in the app.bsky.richtext.facet schema.
+//
+// A facet feature for actor mentions.
+//
 // RECORDTYPE: RichtextFacet_Mention
 type RichtextFacet_Mention struct {
 	LexiconTypeID string `json:"$type,const=app.bsky.richtext.facet" cborgen:"$type,const=app.bsky.richtext.facet"`

api/bsky/unspeccedgetPopular.go

···
 
 package bsky
 
+// schema: app.bsky.unspecced.getPopular
+
 import (
 	"context"
 
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
-// schema: app.bsky.unspecced.getPopular
-
+// UnspeccedGetPopular_Output is the output of a app.bsky.unspecced.getPopular call.
 type UnspeccedGetPopular_Output struct {
 	Cursor *string                  `json:"cursor,omitempty" cborgen:"cursor,omitempty"`
 	Feed   []*FeedDefs_FeedViewPost `json:"feed" cborgen:"feed"`
 }
 
+// UnspeccedGetPopular calls the XRPC method "app.bsky.unspecced.getPopular".
 func UnspeccedGetPopular(ctx context.Context, c *xrpc.Client, cursor string, limit int64) (*UnspeccedGetPopular_Output, error) {
 	var out UnspeccedGetPopular_Output
 

lex/gen.go

···
 
 type outputType struct {
 	Name      string
-	DefName   string
 	Type      *TypeSchema
 	NeedsCbor bool
 	NeedsType bool
···
 	pf("// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.\n\n")
 
 	pf("package %s\n\n", pkg)
+
+	pf("// schema: %s\n\n", s.ID)
+
 	pf("import (\n")
 	pf("\t\"context\"\n")
 	pf("\t\"fmt\"\n")
···
 		}
 	}
 	pf(")\n\n")
-	pf("// schema: %s\n\n", s.ID)
 
 	tps := s.AllTypes(prefix, defmap)
 
···
 	}
 
 	if s.Parameters != nil {
-		if err := orderedMapIter[*TypeSchema](s.Parameters.Properties, func(name string, t *TypeSchema) error {
+		if err := orderedMapIter(s.Parameters.Properties, func(name string, t *TypeSchema) error {
 			tn, err := s.typeNameForField(name, "", *t)
 			if err != nil {
 				return err
···
 		}
 	}
 
+	pf("// %s calls the XRPC method %q.\n", fname, s.id)
+	if s.Parameters != nil && len(s.Parameters.Properties) > 0 {
+		pf("//\n")
+		if err := orderedMapIter(s.Parameters.Properties, func(name string, t *TypeSchema) error {
+			if t.Description != "" {
+				pf("// %s: %s\n", name, t.Description)
+			}
+			return nil
+		}); err != nil {
+			return err
+		}
+	}
 	pf("func %s(%s) %s {\n", fname, params, out)
 
 	outvar := "nil"
···
 		pf(`
 	params := map[string]interface{}{
 `)
-		if err := orderedMapIter[*TypeSchema](s.Parameters.Properties, func(name string, t *TypeSchema) error {
+		if err := orderedMapIter(s.Parameters.Properties, func(name string, t *TypeSchema) error {
 			pf(`"%s": %s,
 `, name, name)
 			return nil
···
 					required[k] = true
 				}
 			}
-			if err := orderedMapIter[*TypeSchema](s.Parameters.Properties, func(k string, t *TypeSchema) error {
+			if err := orderedMapIter(s.Parameters.Properties, func(k string, t *TypeSchema) error {
 				switch t.Type {
 				case "string":
 					params = append(params, k)
···
 
 func (ts *TypeSchema) writeTypeDefinition(name string, w io.Writer) error {
 	pf := printerf(w)
+
+	switch {
+	case strings.HasSuffix(name, "_Output"):
+		pf("// %s is the output of a %s call.\n", name, ts.id)
+	case strings.HasSuffix(name, "Input"):
+		pf("// %s is the input argument to a %s call.\n", name, ts.id)
+	case ts.defName != "":
+		pf("// %s is a %q in the %s schema.\n", name, ts.defName, ts.id)
+	}
+	if ts.Description != "" {
+		pf("//\n// %s\n", ts.Description)
+	}
+
 	switch ts.Type {
 	case "string":
 		// TODO: deal with max length
···
 		}
 
 		if ts.needsType {
-			pf("// RECORDTYPE: %s\n", name)
+			pf("//\n// RECORDTYPE: %s\n", name)
 		}
 
 		pf("type %s struct {\n", name)
···
 			nullable[req] = true
 		}
 
-		if err := orderedMapIter[*TypeSchema](ts.Properties, func(k string, v *TypeSchema) error {
+		if err := orderedMapIter(ts.Properties, func(k string, v *TypeSchema) error {
 			goname := strings.Title(k)
 
 			tname, err := ts.typeNameForField(name, k, *v)
···
 				jsonOmit = ",omitempty"
 			}
 
+			if v.Description != "" {
+				pf("\t// %s: %s\n", k, v.Description)
+			}
 			pf("\t%s %s%s `json:\"%s%s\" cborgen:\"%s%s\"`\n", goname, ptr, tname, k, jsonOmit, k, cborOmit)
 			return nil
 		}); err != nil {