codegen

api/atproto/admindefs.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.admin.defs
+
+package atproto
+
+import (
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// AdminDefs_AccountView is a "accountView" in the com.atproto.admin.defs schema.
+type AdminDefs_AccountView struct {
+	DeactivatedAt    *string                       `json:"deactivatedAt,omitempty" cborgen:"deactivatedAt,omitempty"`
+	Did              string                        `json:"did" cborgen:"did"`
+	Email            *string                       `json:"email,omitempty" cborgen:"email,omitempty"`
+	EmailConfirmedAt *string                       `json:"emailConfirmedAt,omitempty" cborgen:"emailConfirmedAt,omitempty"`
+	Handle           string                        `json:"handle" cborgen:"handle"`
+	IndexedAt        string                        `json:"indexedAt" cborgen:"indexedAt"`
+	InviteNote       *string                       `json:"inviteNote,omitempty" cborgen:"inviteNote,omitempty"`
+	InvitedBy        *ServerDefs_InviteCode        `json:"invitedBy,omitempty" cborgen:"invitedBy,omitempty"`
+	Invites          []*ServerDefs_InviteCode      `json:"invites,omitempty" cborgen:"invites,omitempty"`
+	InvitesDisabled  *bool                         `json:"invitesDisabled,omitempty" cborgen:"invitesDisabled,omitempty"`
+	RelatedRecords   []*lexutil.LexiconTypeDecoder `json:"relatedRecords,omitempty" cborgen:"relatedRecords,omitempty"`
+	ThreatSignatures []*AdminDefs_ThreatSignature  `json:"threatSignatures,omitempty" cborgen:"threatSignatures,omitempty"`
+}
+
+// AdminDefs_RepoBlobRef is a "repoBlobRef" in the com.atproto.admin.defs schema.
+type AdminDefs_RepoBlobRef struct {
+	LexiconTypeID string  `json:"$type" cborgen:"$type,const=com.atproto.admin.defs#repoBlobRef"`
+	Cid           string  `json:"cid" cborgen:"cid"`
+	Did           string  `json:"did" cborgen:"did"`
+	RecordUri     *string `json:"recordUri,omitempty" cborgen:"recordUri,omitempty"`
+}
+
+// AdminDefs_RepoRef is a "repoRef" in the com.atproto.admin.defs schema.
+type AdminDefs_RepoRef struct {
+	LexiconTypeID string `json:"$type" cborgen:"$type,const=com.atproto.admin.defs#repoRef"`
+	Did           string `json:"did" cborgen:"did"`
+}
+
+// AdminDefs_StatusAttr is a "statusAttr" in the com.atproto.admin.defs schema.
+type AdminDefs_StatusAttr struct {
+	Applied bool    `json:"applied" cborgen:"applied"`
+	Ref     *string `json:"ref,omitempty" cborgen:"ref,omitempty"`
+}
+
+// AdminDefs_ThreatSignature is a "threatSignature" in the com.atproto.admin.defs schema.
+type AdminDefs_ThreatSignature struct {
+	Property string `json:"property" cborgen:"property"`
+	Value    string `json:"value" cborgen:"value"`
+}

api/atproto/admindeleteAccount.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.admin.deleteAccount
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// AdminDeleteAccount_Input is the input argument to a com.atproto.admin.deleteAccount call.
+type AdminDeleteAccount_Input struct {
+	Did string `json:"did" cborgen:"did"`
+}
+
+// AdminDeleteAccount calls the XRPC method "com.atproto.admin.deleteAccount".
+func AdminDeleteAccount(ctx context.Context, c lexutil.LexClient, input *AdminDeleteAccount_Input) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.admin.deleteAccount", nil, input, nil); err != nil {
+		return err
+	}
+
+	return nil
+}

api/atproto/admindisableAccountInvites.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.admin.disableAccountInvites
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// AdminDisableAccountInvites_Input is the input argument to a com.atproto.admin.disableAccountInvites call.
+type AdminDisableAccountInvites_Input struct {
+	Account string `json:"account" cborgen:"account"`
+	// note: Optional reason for disabled invites.
+	Note *string `json:"note,omitempty" cborgen:"note,omitempty"`
+}
+
+// AdminDisableAccountInvites calls the XRPC method "com.atproto.admin.disableAccountInvites".
+func AdminDisableAccountInvites(ctx context.Context, c lexutil.LexClient, input *AdminDisableAccountInvites_Input) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.admin.disableAccountInvites", nil, input, nil); err != nil {
+		return err
+	}
+
+	return nil
+}

api/atproto/admindisableInviteCodes.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.admin.disableInviteCodes
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// 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 lexutil.LexClient, input *AdminDisableInviteCodes_Input) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.admin.disableInviteCodes", nil, input, nil); err != nil {
+		return err
+	}
+
+	return nil
+}

api/atproto/adminenableAccountInvites.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.admin.enableAccountInvites
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// AdminEnableAccountInvites_Input is the input argument to a com.atproto.admin.enableAccountInvites call.
+type AdminEnableAccountInvites_Input struct {
+	Account string `json:"account" cborgen:"account"`
+	// note: Optional reason for enabled invites.
+	Note *string `json:"note,omitempty" cborgen:"note,omitempty"`
+}
+
+// AdminEnableAccountInvites calls the XRPC method "com.atproto.admin.enableAccountInvites".
+func AdminEnableAccountInvites(ctx context.Context, c lexutil.LexClient, input *AdminEnableAccountInvites_Input) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.admin.enableAccountInvites", nil, input, nil); err != nil {
+		return err
+	}
+
+	return nil
+}

api/atproto/admingetAccountInfo.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.admin.getAccountInfo
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// AdminGetAccountInfo calls the XRPC method "com.atproto.admin.getAccountInfo".
+func AdminGetAccountInfo(ctx context.Context, c lexutil.LexClient, did string) (*AdminDefs_AccountView, error) {
+	var out AdminDefs_AccountView
+
+	params := map[string]interface{}{}
+	params["did"] = did
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.admin.getAccountInfo", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/admingetAccountInfos.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.admin.getAccountInfos
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// AdminGetAccountInfos_Output is the output of a com.atproto.admin.getAccountInfos call.
+type AdminGetAccountInfos_Output struct {
+	Infos []*AdminDefs_AccountView `json:"infos" cborgen:"infos"`
+}
+
+// AdminGetAccountInfos calls the XRPC method "com.atproto.admin.getAccountInfos".
+func AdminGetAccountInfos(ctx context.Context, c lexutil.LexClient, dids []string) (*AdminGetAccountInfos_Output, error) {
+	var out AdminGetAccountInfos_Output
+
+	params := map[string]interface{}{}
+	params["dids"] = dids
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.admin.getAccountInfos", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/admingetInviteCodes.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.admin.getInviteCodes
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// 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 lexutil.LexClient, cursor string, limit int64, sort string) (*AdminGetInviteCodes_Output, error) {
+	var out AdminGetInviteCodes_Output
+
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	if sort != "" {
+		params["sort"] = sort
+	}
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.admin.getInviteCodes", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/admingetSubjectStatus.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.admin.getSubjectStatus
+
+package atproto
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// AdminGetSubjectStatus_Output is the output of a com.atproto.admin.getSubjectStatus call.
+type AdminGetSubjectStatus_Output struct {
+	Deactivated *AdminDefs_StatusAttr                 `json:"deactivated,omitempty" cborgen:"deactivated,omitempty"`
+	Subject     *AdminGetSubjectStatus_Output_Subject `json:"subject" cborgen:"subject"`
+	Takedown    *AdminDefs_StatusAttr                 `json:"takedown,omitempty" cborgen:"takedown,omitempty"`
+}
+
+type AdminGetSubjectStatus_Output_Subject struct {
+	AdminDefs_RepoRef     *AdminDefs_RepoRef
+	RepoStrongRef         *RepoStrongRef
+	AdminDefs_RepoBlobRef *AdminDefs_RepoBlobRef
+}
+
+func (t *AdminGetSubjectStatus_Output_Subject) MarshalJSON() ([]byte, error) {
+	if t.AdminDefs_RepoRef != nil {
+		t.AdminDefs_RepoRef.LexiconTypeID = "com.atproto.admin.defs#repoRef"
+		return json.Marshal(t.AdminDefs_RepoRef)
+	}
+	if t.RepoStrongRef != nil {
+		t.RepoStrongRef.LexiconTypeID = "com.atproto.repo.strongRef"
+		return json.Marshal(t.RepoStrongRef)
+	}
+	if t.AdminDefs_RepoBlobRef != nil {
+		t.AdminDefs_RepoBlobRef.LexiconTypeID = "com.atproto.admin.defs#repoBlobRef"
+		return json.Marshal(t.AdminDefs_RepoBlobRef)
+	}
+	return nil, fmt.Errorf("can not marshal empty union as JSON")
+}
+
+func (t *AdminGetSubjectStatus_Output_Subject) UnmarshalJSON(b []byte) error {
+	typ, err := lexutil.TypeExtract(b)
+	if err != nil {
+		return err
+	}
+
+	switch typ {
+	case "com.atproto.admin.defs#repoRef":
+		t.AdminDefs_RepoRef = new(AdminDefs_RepoRef)
+		return json.Unmarshal(b, t.AdminDefs_RepoRef)
+	case "com.atproto.repo.strongRef":
+		t.RepoStrongRef = new(RepoStrongRef)
+		return json.Unmarshal(b, t.RepoStrongRef)
+	case "com.atproto.admin.defs#repoBlobRef":
+		t.AdminDefs_RepoBlobRef = new(AdminDefs_RepoBlobRef)
+		return json.Unmarshal(b, t.AdminDefs_RepoBlobRef)
+	default:
+		return nil
+	}
+}
+
+// AdminGetSubjectStatus calls the XRPC method "com.atproto.admin.getSubjectStatus".
+func AdminGetSubjectStatus(ctx context.Context, c lexutil.LexClient, blob string, did string, uri string) (*AdminGetSubjectStatus_Output, error) {
+	var out AdminGetSubjectStatus_Output
+
+	params := map[string]interface{}{}
+	if blob != "" {
+		params["blob"] = blob
+	}
+	if did != "" {
+		params["did"] = did
+	}
+	if uri != "" {
+		params["uri"] = uri
+	}
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.admin.getSubjectStatus", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/adminsearchAccounts.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.admin.searchAccounts
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// AdminSearchAccounts_Output is the output of a com.atproto.admin.searchAccounts call.
+type AdminSearchAccounts_Output struct {
+	Accounts []*AdminDefs_AccountView `json:"accounts" cborgen:"accounts"`
+	Cursor   *string                  `json:"cursor,omitempty" cborgen:"cursor,omitempty"`
+}
+
+// AdminSearchAccounts calls the XRPC method "com.atproto.admin.searchAccounts".
+func AdminSearchAccounts(ctx context.Context, c lexutil.LexClient, cursor string, email string, limit int64) (*AdminSearchAccounts_Output, error) {
+	var out AdminSearchAccounts_Output
+
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if email != "" {
+		params["email"] = email
+	}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.admin.searchAccounts", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/adminsendEmail.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.admin.sendEmail
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// AdminSendEmail_Input is the input argument to a com.atproto.admin.sendEmail call.
+type AdminSendEmail_Input struct {
+	// comment: Additional comment by the sender that won't be used in the email itself but helpful to provide more context for moderators/reviewers
+	Comment      *string `json:"comment,omitempty" cborgen:"comment,omitempty"`
+	Content      string  `json:"content" cborgen:"content"`
+	RecipientDid string  `json:"recipientDid" cborgen:"recipientDid"`
+	SenderDid    string  `json:"senderDid" cborgen:"senderDid"`
+	Subject      *string `json:"subject,omitempty" cborgen:"subject,omitempty"`
+}
+
+// AdminSendEmail_Output is the output of a com.atproto.admin.sendEmail call.
+type AdminSendEmail_Output struct {
+	Sent bool `json:"sent" cborgen:"sent"`
+}
+
+// AdminSendEmail calls the XRPC method "com.atproto.admin.sendEmail".
+func AdminSendEmail(ctx context.Context, c lexutil.LexClient, input *AdminSendEmail_Input) (*AdminSendEmail_Output, error) {
+	var out AdminSendEmail_Output
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.admin.sendEmail", nil, input, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/adminupdateAccountEmail.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.admin.updateAccountEmail
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// 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 lexutil.LexClient, input *AdminUpdateAccountEmail_Input) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.admin.updateAccountEmail", nil, input, nil); err != nil {
+		return err
+	}
+
+	return nil
+}

api/atproto/adminupdateAccountHandle.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.admin.updateAccountHandle
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// 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 lexutil.LexClient, input *AdminUpdateAccountHandle_Input) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.admin.updateAccountHandle", nil, input, nil); err != nil {
+		return err
+	}
+
+	return nil
+}

api/atproto/adminupdateAccountPassword.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.admin.updateAccountPassword
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// AdminUpdateAccountPassword_Input is the input argument to a com.atproto.admin.updateAccountPassword call.
+type AdminUpdateAccountPassword_Input struct {
+	Did      string `json:"did" cborgen:"did"`
+	Password string `json:"password" cborgen:"password"`
+}
+
+// AdminUpdateAccountPassword calls the XRPC method "com.atproto.admin.updateAccountPassword".
+func AdminUpdateAccountPassword(ctx context.Context, c lexutil.LexClient, input *AdminUpdateAccountPassword_Input) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.admin.updateAccountPassword", nil, input, nil); err != nil {
+		return err
+	}
+
+	return nil
+}

api/atproto/adminupdateAccountSigningKey.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.admin.updateAccountSigningKey
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// AdminUpdateAccountSigningKey_Input is the input argument to a com.atproto.admin.updateAccountSigningKey call.
+type AdminUpdateAccountSigningKey_Input struct {
+	Did string `json:"did" cborgen:"did"`
+	// signingKey: Did-key formatted public key
+	SigningKey string `json:"signingKey" cborgen:"signingKey"`
+}
+
+// AdminUpdateAccountSigningKey calls the XRPC method "com.atproto.admin.updateAccountSigningKey".
+func AdminUpdateAccountSigningKey(ctx context.Context, c lexutil.LexClient, input *AdminUpdateAccountSigningKey_Input) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.admin.updateAccountSigningKey", nil, input, nil); err != nil {
+		return err
+	}
+
+	return nil
+}

api/atproto/adminupdateSubjectStatus.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.admin.updateSubjectStatus
+
+package atproto
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// AdminUpdateSubjectStatus_Input is the input argument to a com.atproto.admin.updateSubjectStatus call.
+type AdminUpdateSubjectStatus_Input struct {
+	Deactivated *AdminDefs_StatusAttr                   `json:"deactivated,omitempty" cborgen:"deactivated,omitempty"`
+	Subject     *AdminUpdateSubjectStatus_Input_Subject `json:"subject" cborgen:"subject"`
+	Takedown    *AdminDefs_StatusAttr                   `json:"takedown,omitempty" cborgen:"takedown,omitempty"`
+}
+
+type AdminUpdateSubjectStatus_Input_Subject struct {
+	AdminDefs_RepoRef     *AdminDefs_RepoRef
+	RepoStrongRef         *RepoStrongRef
+	AdminDefs_RepoBlobRef *AdminDefs_RepoBlobRef
+}
+
+func (t *AdminUpdateSubjectStatus_Input_Subject) MarshalJSON() ([]byte, error) {
+	if t.AdminDefs_RepoRef != nil {
+		t.AdminDefs_RepoRef.LexiconTypeID = "com.atproto.admin.defs#repoRef"
+		return json.Marshal(t.AdminDefs_RepoRef)
+	}
+	if t.RepoStrongRef != nil {
+		t.RepoStrongRef.LexiconTypeID = "com.atproto.repo.strongRef"
+		return json.Marshal(t.RepoStrongRef)
+	}
+	if t.AdminDefs_RepoBlobRef != nil {
+		t.AdminDefs_RepoBlobRef.LexiconTypeID = "com.atproto.admin.defs#repoBlobRef"
+		return json.Marshal(t.AdminDefs_RepoBlobRef)
+	}
+	return nil, fmt.Errorf("can not marshal empty union as JSON")
+}
+
+func (t *AdminUpdateSubjectStatus_Input_Subject) UnmarshalJSON(b []byte) error {
+	typ, err := lexutil.TypeExtract(b)
+	if err != nil {
+		return err
+	}
+
+	switch typ {
+	case "com.atproto.admin.defs#repoRef":
+		t.AdminDefs_RepoRef = new(AdminDefs_RepoRef)
+		return json.Unmarshal(b, t.AdminDefs_RepoRef)
+	case "com.atproto.repo.strongRef":
+		t.RepoStrongRef = new(RepoStrongRef)
+		return json.Unmarshal(b, t.RepoStrongRef)
+	case "com.atproto.admin.defs#repoBlobRef":
+		t.AdminDefs_RepoBlobRef = new(AdminDefs_RepoBlobRef)
+		return json.Unmarshal(b, t.AdminDefs_RepoBlobRef)
+	default:
+		return nil
+	}
+}
+
+// AdminUpdateSubjectStatus_Output is the output of a com.atproto.admin.updateSubjectStatus call.
+type AdminUpdateSubjectStatus_Output struct {
+	Subject  *AdminUpdateSubjectStatus_Output_Subject `json:"subject" cborgen:"subject"`
+	Takedown *AdminDefs_StatusAttr                    `json:"takedown,omitempty" cborgen:"takedown,omitempty"`
+}
+
+type AdminUpdateSubjectStatus_Output_Subject struct {
+	AdminDefs_RepoRef     *AdminDefs_RepoRef
+	RepoStrongRef         *RepoStrongRef
+	AdminDefs_RepoBlobRef *AdminDefs_RepoBlobRef
+}
+
+func (t *AdminUpdateSubjectStatus_Output_Subject) MarshalJSON() ([]byte, error) {
+	if t.AdminDefs_RepoRef != nil {
+		t.AdminDefs_RepoRef.LexiconTypeID = "com.atproto.admin.defs#repoRef"
+		return json.Marshal(t.AdminDefs_RepoRef)
+	}
+	if t.RepoStrongRef != nil {
+		t.RepoStrongRef.LexiconTypeID = "com.atproto.repo.strongRef"
+		return json.Marshal(t.RepoStrongRef)
+	}
+	if t.AdminDefs_RepoBlobRef != nil {
+		t.AdminDefs_RepoBlobRef.LexiconTypeID = "com.atproto.admin.defs#repoBlobRef"
+		return json.Marshal(t.AdminDefs_RepoBlobRef)
+	}
+	return nil, fmt.Errorf("can not marshal empty union as JSON")
+}
+
+func (t *AdminUpdateSubjectStatus_Output_Subject) UnmarshalJSON(b []byte) error {
+	typ, err := lexutil.TypeExtract(b)
+	if err != nil {
+		return err
+	}
+
+	switch typ {
+	case "com.atproto.admin.defs#repoRef":
+		t.AdminDefs_RepoRef = new(AdminDefs_RepoRef)
+		return json.Unmarshal(b, t.AdminDefs_RepoRef)
+	case "com.atproto.repo.strongRef":
+		t.RepoStrongRef = new(RepoStrongRef)
+		return json.Unmarshal(b, t.RepoStrongRef)
+	case "com.atproto.admin.defs#repoBlobRef":
+		t.AdminDefs_RepoBlobRef = new(AdminDefs_RepoBlobRef)
+		return json.Unmarshal(b, t.AdminDefs_RepoBlobRef)
+	default:
+		return nil
+	}
+}
+
+// AdminUpdateSubjectStatus calls the XRPC method "com.atproto.admin.updateSubjectStatus".
+func AdminUpdateSubjectStatus(ctx context.Context, c lexutil.LexClient, input *AdminUpdateSubjectStatus_Input) (*AdminUpdateSubjectStatus_Output, error) {
+	var out AdminUpdateSubjectStatus_Output
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.admin.updateSubjectStatus", nil, input, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/cbor_gen.go

···
+// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT.
+
+package atproto
+
+import (
+	"fmt"
+	"io"
+	"math"
+	"sort"
+
+	cid "github.com/ipfs/go-cid"
+	cbg "github.com/whyrusleeping/cbor-gen"
+	xerrors "golang.org/x/xerrors"
+)
+
+var _ = xerrors.Errorf
+var _ = cid.Undef
+var _ = math.E
+var _ = sort.Sort
+
+func (t *RepoStrongRef) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+
+	cw := cbg.NewCborWriter(w)
+	fieldCount := 3
+
+	if t.LexiconTypeID == "" {
+		fieldCount--
+	}
+
+	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
+		return err
+	}
+
+	// t.Cid (string) (string)
+	if len("cid") > 1000000 {
+		return xerrors.Errorf("Value in field \"cid\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("cid"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("cid")); err != nil {
+		return err
+	}
+
+	if len(t.Cid) > 1000000 {
+		return xerrors.Errorf("Value in field t.Cid was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Cid))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string(t.Cid)); err != nil {
+		return err
+	}
+
+	// t.Uri (string) (string)
+	if len("uri") > 1000000 {
+		return xerrors.Errorf("Value in field \"uri\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("uri"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("uri")); err != nil {
+		return err
+	}
+
+	if len(t.Uri) > 1000000 {
+		return xerrors.Errorf("Value in field t.Uri was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Uri))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string(t.Uri)); err != nil {
+		return err
+	}
+
+	// t.LexiconTypeID (string) (string)
+	if t.LexiconTypeID != "" {
+
+		if len("$type") > 1000000 {
+			return xerrors.Errorf("Value in field \"$type\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("$type")); err != nil {
+			return err
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("com.atproto.repo.strongRef"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("com.atproto.repo.strongRef")); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (t *RepoStrongRef) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = RepoStrongRef{}
+
+	cr := cbg.NewCborReader(r)
+
+	maj, extra, err := cr.ReadHeader()
+	if err != nil {
+		return err
+	}
+	defer func() {
+		if err == io.EOF {
+			err = io.ErrUnexpectedEOF
+		}
+	}()
+
+	if maj != cbg.MajMap {
+		return fmt.Errorf("cbor input should be of type map")
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("RepoStrongRef: map struct too large (%d)", extra)
+	}
+
+	n := extra
+
+	nameBuf := make([]byte, 5)
+	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
+
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
+				return err
+			}
+			continue
+		}
+
+		switch string(nameBuf[:nameLen]) {
+		// t.Cid (string) (string)
+		case "cid":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.Cid = string(sval)
+			}
+			// t.Uri (string) (string)
+		case "uri":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.Uri = string(sval)
+			}
+			// t.LexiconTypeID (string) (string)
+		case "$type":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.LexiconTypeID = string(sval)
+			}
+
+		default:
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}

api/atproto/identitydefs.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.identity.defs
+
+package atproto
+
+// IdentityDefs_IdentityInfo is a "identityInfo" in the com.atproto.identity.defs schema.
+type IdentityDefs_IdentityInfo struct {
+	Did string `json:"did" cborgen:"did"`
+	// didDoc: The complete DID document for the identity.
+	DidDoc interface{} `json:"didDoc" cborgen:"didDoc"`
+	// handle: The validated handle of the account; or 'handle.invalid' if the handle did not bi-directionally match the DID document.
+	Handle string `json:"handle" cborgen:"handle"`
+}

api/atproto/identitygetRecommendedDidCredentials.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.identity.getRecommendedDidCredentials
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// IdentityGetRecommendedDidCredentials_Output is the output of a com.atproto.identity.getRecommendedDidCredentials call.
+type IdentityGetRecommendedDidCredentials_Output struct {
+	AlsoKnownAs []string `json:"alsoKnownAs,omitempty" cborgen:"alsoKnownAs,omitempty"`
+	// rotationKeys: Recommended rotation keys for PLC dids. Should be undefined (or ignored) for did:webs.
+	RotationKeys        []string                    `json:"rotationKeys,omitempty" cborgen:"rotationKeys,omitempty"`
+	Services            *lexutil.LexiconTypeDecoder `json:"services,omitempty" cborgen:"services,omitempty"`
+	VerificationMethods *lexutil.LexiconTypeDecoder `json:"verificationMethods,omitempty" cborgen:"verificationMethods,omitempty"`
+}
+
+// IdentityGetRecommendedDidCredentials calls the XRPC method "com.atproto.identity.getRecommendedDidCredentials".
+func IdentityGetRecommendedDidCredentials(ctx context.Context, c lexutil.LexClient) (*IdentityGetRecommendedDidCredentials_Output, error) {
+	var out IdentityGetRecommendedDidCredentials_Output
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.identity.getRecommendedDidCredentials", nil, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/identityrefreshIdentity.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.identity.refreshIdentity
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// IdentityRefreshIdentity_Input is the input argument to a com.atproto.identity.refreshIdentity call.
+type IdentityRefreshIdentity_Input struct {
+	Identifier string `json:"identifier" cborgen:"identifier"`
+}
+
+// IdentityRefreshIdentity calls the XRPC method "com.atproto.identity.refreshIdentity".
+func IdentityRefreshIdentity(ctx context.Context, c lexutil.LexClient, input *IdentityRefreshIdentity_Input) (*IdentityDefs_IdentityInfo, error) {
+	var out IdentityDefs_IdentityInfo
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.identity.refreshIdentity", nil, input, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/identityrequestPlcOperationSignature.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.identity.requestPlcOperationSignature
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// IdentityRequestPlcOperationSignature calls the XRPC method "com.atproto.identity.requestPlcOperationSignature".
+func IdentityRequestPlcOperationSignature(ctx context.Context, c lexutil.LexClient) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "", "com.atproto.identity.requestPlcOperationSignature", nil, nil, nil); err != nil {
+		return err
+	}
+
+	return nil
+}

api/atproto/identityresolveDid.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.identity.resolveDid
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// IdentityResolveDid_Output is the output of a com.atproto.identity.resolveDid call.
+type IdentityResolveDid_Output struct {
+	// didDoc: The complete DID document for the identity.
+	DidDoc interface{} `json:"didDoc" cborgen:"didDoc"`
+}
+
+// IdentityResolveDid calls the XRPC method "com.atproto.identity.resolveDid".
+//
+// did: DID to resolve.
+func IdentityResolveDid(ctx context.Context, c lexutil.LexClient, did string) (*IdentityResolveDid_Output, error) {
+	var out IdentityResolveDid_Output
+
+	params := map[string]interface{}{}
+	params["did"] = did
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.identity.resolveDid", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/identityresolveHandle.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.identity.resolveHandle
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// 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.
+func IdentityResolveHandle(ctx context.Context, c lexutil.LexClient, handle string) (*IdentityResolveHandle_Output, error) {
+	var out IdentityResolveHandle_Output
+
+	params := map[string]interface{}{}
+	params["handle"] = handle
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.identity.resolveHandle", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/identityresolveIdentity.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.identity.resolveIdentity
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// IdentityResolveIdentity calls the XRPC method "com.atproto.identity.resolveIdentity".
+//
+// identifier: Handle or DID to resolve.
+func IdentityResolveIdentity(ctx context.Context, c lexutil.LexClient, identifier string) (*IdentityDefs_IdentityInfo, error) {
+	var out IdentityDefs_IdentityInfo
+
+	params := map[string]interface{}{}
+	params["identifier"] = identifier
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.identity.resolveIdentity", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/identitysignPlcOperation.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.identity.signPlcOperation
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// IdentitySignPlcOperation_Input is the input argument to a com.atproto.identity.signPlcOperation call.
+type IdentitySignPlcOperation_Input struct {
+	AlsoKnownAs  []string                    `json:"alsoKnownAs,omitempty" cborgen:"alsoKnownAs,omitempty"`
+	RotationKeys []string                    `json:"rotationKeys,omitempty" cborgen:"rotationKeys,omitempty"`
+	Services     *lexutil.LexiconTypeDecoder `json:"services,omitempty" cborgen:"services,omitempty"`
+	// token: A token received through com.atproto.identity.requestPlcOperationSignature
+	Token               *string                     `json:"token,omitempty" cborgen:"token,omitempty"`
+	VerificationMethods *lexutil.LexiconTypeDecoder `json:"verificationMethods,omitempty" cborgen:"verificationMethods,omitempty"`
+}
+
+// IdentitySignPlcOperation_Output is the output of a com.atproto.identity.signPlcOperation call.
+type IdentitySignPlcOperation_Output struct {
+	// operation: A signed DID PLC operation.
+	Operation *lexutil.LexiconTypeDecoder `json:"operation" cborgen:"operation"`
+}
+
+// IdentitySignPlcOperation calls the XRPC method "com.atproto.identity.signPlcOperation".
+func IdentitySignPlcOperation(ctx context.Context, c lexutil.LexClient, input *IdentitySignPlcOperation_Input) (*IdentitySignPlcOperation_Output, error) {
+	var out IdentitySignPlcOperation_Output
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.identity.signPlcOperation", nil, input, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/identitysubmitPlcOperation.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.identity.submitPlcOperation
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// IdentitySubmitPlcOperation_Input is the input argument to a com.atproto.identity.submitPlcOperation call.
+type IdentitySubmitPlcOperation_Input struct {
+	Operation *lexutil.LexiconTypeDecoder `json:"operation" cborgen:"operation"`
+}
+
+// IdentitySubmitPlcOperation calls the XRPC method "com.atproto.identity.submitPlcOperation".
+func IdentitySubmitPlcOperation(ctx context.Context, c lexutil.LexClient, input *IdentitySubmitPlcOperation_Input) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.identity.submitPlcOperation", nil, input, nil); err != nil {
+		return err
+	}
+
+	return nil
+}

api/atproto/identityupdateHandle.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.identity.updateHandle
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// IdentityUpdateHandle_Input is the input argument to a com.atproto.identity.updateHandle call.
+type IdentityUpdateHandle_Input struct {
+	// handle: The new handle.
+	Handle string `json:"handle" cborgen:"handle"`
+}
+
+// IdentityUpdateHandle calls the XRPC method "com.atproto.identity.updateHandle".
+func IdentityUpdateHandle(ctx context.Context, c lexutil.LexClient, input *IdentityUpdateHandle_Input) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.identity.updateHandle", nil, input, nil); err != nil {
+		return err
+	}
+
+	return nil
+}

api/atproto/labeldefs.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.label.defs
+
+package atproto
+
+import (
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// 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: Timestamp when this label was created.
+	Cts string `json:"cts" cborgen:"cts"`
+	// exp: Timestamp at which this label expires (no longer applies).
+	Exp *string `json:"exp,omitempty" cborgen:"exp,omitempty"`
+	// neg: If true, this is a negation label, overwriting a previous label.
+	Neg *bool `json:"neg,omitempty" cborgen:"neg,omitempty"`
+	// sig: Signature of dag-cbor encoded label.
+	Sig lexutil.LexBytes `json:"sig,omitempty" cborgen:"sig,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 that 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"`
+	// ver: The AT Protocol version of the label object.
+	Ver *int64 `json:"ver,omitempty" cborgen:"ver,omitempty"`
+}
+
+// LabelDefs_LabelValueDefinition is a "labelValueDefinition" in the com.atproto.label.defs schema.
+//
+// Declares a label value and its expected interpretations and behaviors.
+type LabelDefs_LabelValueDefinition struct {
+	// adultOnly: Does the user need to have adult content enabled in order to configure this label?
+	AdultOnly *bool `json:"adultOnly,omitempty" cborgen:"adultOnly,omitempty"`
+	// blurs: What should this label hide in the UI, if applied? 'content' hides all of the target; 'media' hides the images/video/audio; 'none' hides nothing.
+	Blurs string `json:"blurs" cborgen:"blurs"`
+	// defaultSetting: The default setting for this label.
+	DefaultSetting *string `json:"defaultSetting,omitempty" cborgen:"defaultSetting,omitempty"`
+	// identifier: The value of the label being defined. Must only include lowercase ascii and the '-' character ([a-z-]+).
+	Identifier string                                   `json:"identifier" cborgen:"identifier"`
+	Locales    []*LabelDefs_LabelValueDefinitionStrings `json:"locales" cborgen:"locales"`
+	// severity: How should a client visually convey this label? 'inform' means neutral and informational; 'alert' means negative and warning; 'none' means show nothing.
+	Severity string `json:"severity" cborgen:"severity"`
+}
+
+// LabelDefs_LabelValueDefinitionStrings is a "labelValueDefinitionStrings" in the com.atproto.label.defs schema.
+//
+// Strings which describe the label in the UI, localized into a specific language.
+type LabelDefs_LabelValueDefinitionStrings struct {
+	// description: A longer description of what the label means and why it might be applied.
+	Description string `json:"description" cborgen:"description"`
+	// lang: The code of the language these strings are written in.
+	Lang string `json:"lang" cborgen:"lang"`
+	// name: A short human-readable name for the label.
+	Name string `json:"name" cborgen:"name"`
+}
+
+// LabelDefs_SelfLabel is a "selfLabel" in the com.atproto.label.defs schema.
+//
+// Metadata tag on an atproto record, published by the author within the record. Note that schemas should use #selfLabels, not #selfLabel.
+type LabelDefs_SelfLabel struct {
+	// val: The short string name of the value or type of this label.
+	Val string `json:"val" cborgen:"val"`
+}
+
+// LabelDefs_SelfLabels is a "selfLabels" in the com.atproto.label.defs schema.
+//
+// Metadata tags on an atproto record, published by the author within the record.
+type LabelDefs_SelfLabels struct {
+	LexiconTypeID string                 `json:"$type" cborgen:"$type,const=com.atproto.label.defs#selfLabels"`
+	Values        []*LabelDefs_SelfLabel `json:"values" cborgen:"values,preservenil"`
+}

api/atproto/labelqueryLabels.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.label.queryLabels
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// 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 lexutil.LexClient, cursor string, limit int64, sources []string, uriPatterns []string) (*LabelQueryLabels_Output, error) {
+	var out LabelQueryLabels_Output
+
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	if len(sources) != 0 {
+		params["sources"] = sources
+	}
+	params["uriPatterns"] = uriPatterns
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.label.queryLabels", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/labelsubscribeLabels.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.label.subscribeLabels
+
+package atproto
+
+// 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

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.moderation.createReport
+
+package atproto
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// ModerationCreateReport_Input is the input argument to a com.atproto.moderation.createReport call.
+type ModerationCreateReport_Input struct {
+	ModTool *ModerationCreateReport_ModTool `json:"modTool,omitempty" cborgen:"modTool,omitempty"`
+	// reason: Additional context about the content and violation.
+	Reason *string `json:"reason,omitempty" cborgen:"reason,omitempty"`
+	// reasonType: Indicates the broad category of violation the report is for.
+	ReasonType *string                               `json:"reasonType" cborgen:"reasonType"`
+	Subject    *ModerationCreateReport_Input_Subject `json:"subject" cborgen:"subject"`
+}
+
+type ModerationCreateReport_Input_Subject struct {
+	AdminDefs_RepoRef *AdminDefs_RepoRef
+	RepoStrongRef     *RepoStrongRef
+}
+
+func (t *ModerationCreateReport_Input_Subject) MarshalJSON() ([]byte, error) {
+	if t.AdminDefs_RepoRef != nil {
+		t.AdminDefs_RepoRef.LexiconTypeID = "com.atproto.admin.defs#repoRef"
+		return json.Marshal(t.AdminDefs_RepoRef)
+	}
+	if t.RepoStrongRef != nil {
+		t.RepoStrongRef.LexiconTypeID = "com.atproto.repo.strongRef"
+		return json.Marshal(t.RepoStrongRef)
+	}
+	return nil, fmt.Errorf("can not marshal empty union as JSON")
+}
+
+func (t *ModerationCreateReport_Input_Subject) UnmarshalJSON(b []byte) error {
+	typ, err := lexutil.TypeExtract(b)
+	if err != nil {
+		return err
+	}
+
+	switch typ {
+	case "com.atproto.admin.defs#repoRef":
+		t.AdminDefs_RepoRef = new(AdminDefs_RepoRef)
+		return json.Unmarshal(b, t.AdminDefs_RepoRef)
+	case "com.atproto.repo.strongRef":
+		t.RepoStrongRef = new(RepoStrongRef)
+		return json.Unmarshal(b, t.RepoStrongRef)
+	default:
+		return nil
+	}
+}
+
+// ModerationCreateReport_ModTool is a "modTool" in the com.atproto.moderation.createReport schema.
+//
+// Moderation tool information for tracing the source of the action
+type ModerationCreateReport_ModTool struct {
+	// meta: Additional arbitrary metadata about the source
+	Meta *interface{} `json:"meta,omitempty" cborgen:"meta,omitempty"`
+	// name: Name/identifier of the source (e.g., 'bsky-app/android', 'bsky-web/chrome')
+	Name string `json:"name" cborgen:"name"`
+}
+
+// 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"`
+	Reason     *string                                `json:"reason,omitempty" cborgen:"reason,omitempty"`
+	ReasonType *string                                `json:"reasonType" cborgen:"reasonType"`
+	ReportedBy string                                 `json:"reportedBy" cborgen:"reportedBy"`
+	Subject    *ModerationCreateReport_Output_Subject `json:"subject" cborgen:"subject"`
+}
+
+type ModerationCreateReport_Output_Subject struct {
+	AdminDefs_RepoRef *AdminDefs_RepoRef
+	RepoStrongRef     *RepoStrongRef
+}
+
+func (t *ModerationCreateReport_Output_Subject) MarshalJSON() ([]byte, error) {
+	if t.AdminDefs_RepoRef != nil {
+		t.AdminDefs_RepoRef.LexiconTypeID = "com.atproto.admin.defs#repoRef"
+		return json.Marshal(t.AdminDefs_RepoRef)
+	}
+	if t.RepoStrongRef != nil {
+		t.RepoStrongRef.LexiconTypeID = "com.atproto.repo.strongRef"
+		return json.Marshal(t.RepoStrongRef)
+	}
+	return nil, fmt.Errorf("can not marshal empty union as JSON")
+}
+
+func (t *ModerationCreateReport_Output_Subject) UnmarshalJSON(b []byte) error {
+	typ, err := lexutil.TypeExtract(b)
+	if err != nil {
+		return err
+	}
+
+	switch typ {
+	case "com.atproto.admin.defs#repoRef":
+		t.AdminDefs_RepoRef = new(AdminDefs_RepoRef)
+		return json.Unmarshal(b, t.AdminDefs_RepoRef)
+	case "com.atproto.repo.strongRef":
+		t.RepoStrongRef = new(RepoStrongRef)
+		return json.Unmarshal(b, t.RepoStrongRef)
+	default:
+		return nil
+	}
+}
+
+// ModerationCreateReport calls the XRPC method "com.atproto.moderation.createReport".
+func ModerationCreateReport(ctx context.Context, c lexutil.LexClient, input *ModerationCreateReport_Input) (*ModerationCreateReport_Output, error) {
+	var out ModerationCreateReport_Output
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.moderation.createReport", nil, input, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/moderationdefs.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.moderation.defs
+
+package atproto

api/atproto/repoapplyWrites.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.repo.applyWrites
+
+package atproto
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// RepoApplyWrites_Create is a "create" in the com.atproto.repo.applyWrites schema.
+//
+// Operation which creates a new record.
+type RepoApplyWrites_Create struct {
+	LexiconTypeID string `json:"$type" cborgen:"$type,const=com.atproto.repo.applyWrites#create"`
+	Collection    string `json:"collection" cborgen:"collection"`
+	// rkey: NOTE: maxLength is redundant with record-key format. Keeping it temporarily to ensure backwards compatibility.
+	Rkey  *string                     `json:"rkey,omitempty" cborgen:"rkey,omitempty"`
+	Value *lexutil.LexiconTypeDecoder `json:"value" cborgen:"value"`
+}
+
+// RepoApplyWrites_CreateResult is a "createResult" in the com.atproto.repo.applyWrites schema.
+type RepoApplyWrites_CreateResult struct {
+	LexiconTypeID    string  `json:"$type" cborgen:"$type,const=com.atproto.repo.applyWrites#createResult"`
+	Cid              string  `json:"cid" cborgen:"cid"`
+	Uri              string  `json:"uri" cborgen:"uri"`
+	ValidationStatus *string `json:"validationStatus,omitempty" cborgen:"validationStatus,omitempty"`
+}
+
+// RepoApplyWrites_Delete is a "delete" in the com.atproto.repo.applyWrites schema.
+//
+// Operation which deletes an existing record.
+type RepoApplyWrites_Delete struct {
+	LexiconTypeID string `json:"$type" cborgen:"$type,const=com.atproto.repo.applyWrites#delete"`
+	Collection    string `json:"collection" cborgen:"collection"`
+	Rkey          string `json:"rkey" cborgen:"rkey"`
+}
+
+// RepoApplyWrites_DeleteResult is a "deleteResult" in the com.atproto.repo.applyWrites schema.
+type RepoApplyWrites_DeleteResult struct {
+	LexiconTypeID string `json:"$type" cborgen:"$type,const=com.atproto.repo.applyWrites#deleteResult"`
+}
+
+// RepoApplyWrites_Input is the input argument to a com.atproto.repo.applyWrites call.
+type RepoApplyWrites_Input struct {
+	// repo: The handle or DID of the repo (aka, current account).
+	Repo string `json:"repo" cborgen:"repo"`
+	// swapCommit: If provided, the entire operation will fail if the current repo commit CID does not match this value. Used to prevent conflicting repo mutations.
+	SwapCommit *string `json:"swapCommit,omitempty" cborgen:"swapCommit,omitempty"`
+	// validate: Can be set to 'false' to skip Lexicon schema validation of record data across all operations, 'true' to require it, or leave unset to validate only for known Lexicons.
+	Validate *bool                                `json:"validate,omitempty" cborgen:"validate,omitempty"`
+	Writes   []*RepoApplyWrites_Input_Writes_Elem `json:"writes" cborgen:"writes"`
+}
+
+type RepoApplyWrites_Input_Writes_Elem struct {
+	RepoApplyWrites_Create *RepoApplyWrites_Create
+	RepoApplyWrites_Update *RepoApplyWrites_Update
+	RepoApplyWrites_Delete *RepoApplyWrites_Delete
+}
+
+func (t *RepoApplyWrites_Input_Writes_Elem) MarshalJSON() ([]byte, error) {
+	if t.RepoApplyWrites_Create != nil {
+		t.RepoApplyWrites_Create.LexiconTypeID = "com.atproto.repo.applyWrites#create"
+		return json.Marshal(t.RepoApplyWrites_Create)
+	}
+	if t.RepoApplyWrites_Update != nil {
+		t.RepoApplyWrites_Update.LexiconTypeID = "com.atproto.repo.applyWrites#update"
+		return json.Marshal(t.RepoApplyWrites_Update)
+	}
+	if t.RepoApplyWrites_Delete != nil {
+		t.RepoApplyWrites_Delete.LexiconTypeID = "com.atproto.repo.applyWrites#delete"
+		return json.Marshal(t.RepoApplyWrites_Delete)
+	}
+	return nil, fmt.Errorf("can not marshal empty union as JSON")
+}
+
+func (t *RepoApplyWrites_Input_Writes_Elem) UnmarshalJSON(b []byte) error {
+	typ, err := lexutil.TypeExtract(b)
+	if err != nil {
+		return err
+	}
+
+	switch typ {
+	case "com.atproto.repo.applyWrites#create":
+		t.RepoApplyWrites_Create = new(RepoApplyWrites_Create)
+		return json.Unmarshal(b, t.RepoApplyWrites_Create)
+	case "com.atproto.repo.applyWrites#update":
+		t.RepoApplyWrites_Update = new(RepoApplyWrites_Update)
+		return json.Unmarshal(b, t.RepoApplyWrites_Update)
+	case "com.atproto.repo.applyWrites#delete":
+		t.RepoApplyWrites_Delete = new(RepoApplyWrites_Delete)
+		return json.Unmarshal(b, t.RepoApplyWrites_Delete)
+	default:
+		return fmt.Errorf("closed unions must match a listed schema")
+	}
+}
+
+// RepoApplyWrites_Output is the output of a com.atproto.repo.applyWrites call.
+type RepoApplyWrites_Output struct {
+	Commit  *RepoDefs_CommitMeta                   `json:"commit,omitempty" cborgen:"commit,omitempty"`
+	Results []*RepoApplyWrites_Output_Results_Elem `json:"results,omitempty" cborgen:"results,omitempty"`
+}
+
+type RepoApplyWrites_Output_Results_Elem struct {
+	RepoApplyWrites_CreateResult *RepoApplyWrites_CreateResult
+	RepoApplyWrites_UpdateResult *RepoApplyWrites_UpdateResult
+	RepoApplyWrites_DeleteResult *RepoApplyWrites_DeleteResult
+}
+
+func (t *RepoApplyWrites_Output_Results_Elem) MarshalJSON() ([]byte, error) {
+	if t.RepoApplyWrites_CreateResult != nil {
+		t.RepoApplyWrites_CreateResult.LexiconTypeID = "com.atproto.repo.applyWrites#createResult"
+		return json.Marshal(t.RepoApplyWrites_CreateResult)
+	}
+	if t.RepoApplyWrites_UpdateResult != nil {
+		t.RepoApplyWrites_UpdateResult.LexiconTypeID = "com.atproto.repo.applyWrites#updateResult"
+		return json.Marshal(t.RepoApplyWrites_UpdateResult)
+	}
+	if t.RepoApplyWrites_DeleteResult != nil {
+		t.RepoApplyWrites_DeleteResult.LexiconTypeID = "com.atproto.repo.applyWrites#deleteResult"
+		return json.Marshal(t.RepoApplyWrites_DeleteResult)
+	}
+	return nil, fmt.Errorf("can not marshal empty union as JSON")
+}
+
+func (t *RepoApplyWrites_Output_Results_Elem) UnmarshalJSON(b []byte) error {
+	typ, err := lexutil.TypeExtract(b)
+	if err != nil {
+		return err
+	}
+
+	switch typ {
+	case "com.atproto.repo.applyWrites#createResult":
+		t.RepoApplyWrites_CreateResult = new(RepoApplyWrites_CreateResult)
+		return json.Unmarshal(b, t.RepoApplyWrites_CreateResult)
+	case "com.atproto.repo.applyWrites#updateResult":
+		t.RepoApplyWrites_UpdateResult = new(RepoApplyWrites_UpdateResult)
+		return json.Unmarshal(b, t.RepoApplyWrites_UpdateResult)
+	case "com.atproto.repo.applyWrites#deleteResult":
+		t.RepoApplyWrites_DeleteResult = new(RepoApplyWrites_DeleteResult)
+		return json.Unmarshal(b, t.RepoApplyWrites_DeleteResult)
+	default:
+		return fmt.Errorf("closed unions must match a listed schema")
+	}
+}
+
+// RepoApplyWrites_Update is a "update" in the com.atproto.repo.applyWrites schema.
+//
+// Operation which updates an existing record.
+type RepoApplyWrites_Update struct {
+	LexiconTypeID string                      `json:"$type" cborgen:"$type,const=com.atproto.repo.applyWrites#update"`
+	Collection    string                      `json:"collection" cborgen:"collection"`
+	Rkey          string                      `json:"rkey" cborgen:"rkey"`
+	Value         *lexutil.LexiconTypeDecoder `json:"value" cborgen:"value"`
+}
+
+// RepoApplyWrites_UpdateResult is a "updateResult" in the com.atproto.repo.applyWrites schema.
+type RepoApplyWrites_UpdateResult struct {
+	LexiconTypeID    string  `json:"$type" cborgen:"$type,const=com.atproto.repo.applyWrites#updateResult"`
+	Cid              string  `json:"cid" cborgen:"cid"`
+	Uri              string  `json:"uri" cborgen:"uri"`
+	ValidationStatus *string `json:"validationStatus,omitempty" cborgen:"validationStatus,omitempty"`
+}
+
+// RepoApplyWrites calls the XRPC method "com.atproto.repo.applyWrites".
+func RepoApplyWrites(ctx context.Context, c lexutil.LexClient, input *RepoApplyWrites_Input) (*RepoApplyWrites_Output, error) {
+	var out RepoApplyWrites_Output
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.repo.applyWrites", nil, input, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/repocreateRecord.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.repo.createRecord
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// RepoCreateRecord_Input is the input argument to a com.atproto.repo.createRecord call.
+type RepoCreateRecord_Input struct {
+	// collection: The NSID of the record collection.
+	Collection string `json:"collection" cborgen:"collection"`
+	// record: The record itself. Must contain a $type field.
+	Record *lexutil.LexiconTypeDecoder `json:"record" cborgen:"record"`
+	// repo: The handle or DID of the repo (aka, current account).
+	Repo string `json:"repo" cborgen:"repo"`
+	// rkey: The Record Key.
+	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: Can be set to 'false' to skip Lexicon schema validation of record data, 'true' to require it, or leave unset to validate only for known Lexicons.
+	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"`
+	Commit           *RepoDefs_CommitMeta `json:"commit,omitempty" cborgen:"commit,omitempty"`
+	Uri              string               `json:"uri" cborgen:"uri"`
+	ValidationStatus *string              `json:"validationStatus,omitempty" cborgen:"validationStatus,omitempty"`
+}
+
+// RepoCreateRecord calls the XRPC method "com.atproto.repo.createRecord".
+func RepoCreateRecord(ctx context.Context, c lexutil.LexClient, input *RepoCreateRecord_Input) (*RepoCreateRecord_Output, error) {
+	var out RepoCreateRecord_Output
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.repo.createRecord", nil, input, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/repodefs.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.repo.defs
+
+package atproto
+
+// RepoDefs_CommitMeta is a "commitMeta" in the com.atproto.repo.defs schema.
+type RepoDefs_CommitMeta struct {
+	Cid string `json:"cid" cborgen:"cid"`
+	Rev string `json:"rev" cborgen:"rev"`
+}

api/atproto/repodeleteRecord.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.repo.deleteRecord
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// RepoDeleteRecord_Input is the input argument to a com.atproto.repo.deleteRecord call.
+type RepoDeleteRecord_Input struct {
+	// collection: The NSID of the record collection.
+	Collection string `json:"collection" cborgen:"collection"`
+	// repo: The handle or DID of the repo (aka, current account).
+	Repo string `json:"repo" cborgen:"repo"`
+	// rkey: The Record Key.
+	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_Output is the output of a com.atproto.repo.deleteRecord call.
+type RepoDeleteRecord_Output struct {
+	Commit *RepoDefs_CommitMeta `json:"commit,omitempty" cborgen:"commit,omitempty"`
+}
+
+// RepoDeleteRecord calls the XRPC method "com.atproto.repo.deleteRecord".
+func RepoDeleteRecord(ctx context.Context, c lexutil.LexClient, input *RepoDeleteRecord_Input) (*RepoDeleteRecord_Output, error) {
+	var out RepoDeleteRecord_Output
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.repo.deleteRecord", nil, input, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/repodescribeRepo.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.repo.describeRepo
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// RepoDescribeRepo_Output is the output of a com.atproto.repo.describeRepo call.
+type RepoDescribeRepo_Output struct {
+	// collections: List of all the collections (NSIDs) for which this repo contains at least one record.
+	Collections []string `json:"collections" cborgen:"collections"`
+	Did         string   `json:"did" cborgen:"did"`
+	// didDoc: The complete DID document for this account.
+	DidDoc interface{} `json:"didDoc" cborgen:"didDoc"`
+	Handle string      `json:"handle" cborgen:"handle"`
+	// handleIsCorrect: Indicates if handle is currently valid (resolves bi-directionally)
+	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 lexutil.LexClient, repo string) (*RepoDescribeRepo_Output, error) {
+	var out RepoDescribeRepo_Output
+
+	params := map[string]interface{}{}
+	params["repo"] = repo
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.repo.describeRepo", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/repogetRecord.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.repo.getRecord
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// 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 *lexutil.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 Record Key.
+func RepoGetRecord(ctx context.Context, c lexutil.LexClient, cid string, collection string, repo string, rkey string) (*RepoGetRecord_Output, error) {
+	var out RepoGetRecord_Output
+
+	params := map[string]interface{}{}
+	if cid != "" {
+		params["cid"] = cid
+	}
+	params["collection"] = collection
+	params["repo"] = repo
+	params["rkey"] = rkey
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.repo.getRecord", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/repoimportRepo.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.repo.importRepo
+
+package atproto
+
+import (
+	"context"
+	"io"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// RepoImportRepo calls the XRPC method "com.atproto.repo.importRepo".
+func RepoImportRepo(ctx context.Context, c lexutil.LexClient, input io.Reader) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/vnd.ipld.car", "com.atproto.repo.importRepo", nil, input, nil); err != nil {
+		return err
+	}
+
+	return nil
+}

api/atproto/repolistMissingBlobs.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.repo.listMissingBlobs
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// RepoListMissingBlobs_Output is the output of a com.atproto.repo.listMissingBlobs call.
+type RepoListMissingBlobs_Output struct {
+	Blobs  []*RepoListMissingBlobs_RecordBlob `json:"blobs" cborgen:"blobs"`
+	Cursor *string                            `json:"cursor,omitempty" cborgen:"cursor,omitempty"`
+}
+
+// RepoListMissingBlobs_RecordBlob is a "recordBlob" in the com.atproto.repo.listMissingBlobs schema.
+type RepoListMissingBlobs_RecordBlob struct {
+	Cid       string `json:"cid" cborgen:"cid"`
+	RecordUri string `json:"recordUri" cborgen:"recordUri"`
+}
+
+// RepoListMissingBlobs calls the XRPC method "com.atproto.repo.listMissingBlobs".
+func RepoListMissingBlobs(ctx context.Context, c lexutil.LexClient, cursor string, limit int64) (*RepoListMissingBlobs_Output, error) {
+	var out RepoListMissingBlobs_Output
+
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.repo.listMissingBlobs", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/repolistRecords.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.repo.listRecords
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// 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 *lexutil.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: Flag to reverse the order of the returned records.
+func RepoListRecords(ctx context.Context, c lexutil.LexClient, collection string, cursor string, limit int64, repo string, reverse bool) (*RepoListRecords_Output, error) {
+	var out RepoListRecords_Output
+
+	params := map[string]interface{}{}
+	params["collection"] = collection
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	params["repo"] = repo
+	if reverse {
+		params["reverse"] = reverse
+	}
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.repo.listRecords", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/repoputRecord.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.repo.putRecord
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// RepoPutRecord_Input is the input argument to a com.atproto.repo.putRecord call.
+type RepoPutRecord_Input struct {
+	// collection: The NSID of the record collection.
+	Collection string `json:"collection" cborgen:"collection"`
+	// record: The record to write.
+	Record *lexutil.LexiconTypeDecoder `json:"record" cborgen:"record"`
+	// repo: The handle or DID of the repo (aka, current account).
+	Repo string `json:"repo" cborgen:"repo"`
+	// rkey: The Record Key.
+	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. WARNING: nullable and optional field; may cause problems with golang implementation
+	SwapRecord *string `json:"swapRecord" cborgen:"swapRecord"`
+	// validate: Can be set to 'false' to skip Lexicon schema validation of record data, 'true' to require it, or leave unset to validate only for known Lexicons.
+	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"`
+	Commit           *RepoDefs_CommitMeta `json:"commit,omitempty" cborgen:"commit,omitempty"`
+	Uri              string               `json:"uri" cborgen:"uri"`
+	ValidationStatus *string              `json:"validationStatus,omitempty" cborgen:"validationStatus,omitempty"`
+}
+
+// RepoPutRecord calls the XRPC method "com.atproto.repo.putRecord".
+func RepoPutRecord(ctx context.Context, c lexutil.LexClient, input *RepoPutRecord_Input) (*RepoPutRecord_Output, error) {
+	var out RepoPutRecord_Output
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.repo.putRecord", nil, input, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/repostrongRef.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.repo.strongRef
+
+package atproto
+
+import (
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+func init() {
+	lexutil.RegisterType("com.atproto.repo.strongRef#main", &RepoStrongRef{})
+}
+
+// RepoStrongRef is a "main" in the com.atproto.repo.strongRef schema.
+type RepoStrongRef struct {
+	LexiconTypeID string `json:"$type,omitempty" cborgen:"$type,const=com.atproto.repo.strongRef,omitempty"`
+	Cid           string `json:"cid" cborgen:"cid"`
+	Uri           string `json:"uri" cborgen:"uri"`
+}

api/atproto/repouploadBlob.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.repo.uploadBlob
+
+package atproto
+
+import (
+	"context"
+	"io"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// RepoUploadBlob_Output is the output of a com.atproto.repo.uploadBlob call.
+type RepoUploadBlob_Output struct {
+	Blob *lexutil.LexBlob `json:"blob" cborgen:"blob"`
+}
+
+// RepoUploadBlob calls the XRPC method "com.atproto.repo.uploadBlob".
+func RepoUploadBlob(ctx context.Context, c lexutil.LexClient, input io.Reader) (*RepoUploadBlob_Output, error) {
+	var out RepoUploadBlob_Output
+	if err := c.LexDo(ctx, lexutil.Procedure, "*/*", "com.atproto.repo.uploadBlob", nil, input, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/serveractivateAccount.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.server.activateAccount
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// ServerActivateAccount calls the XRPC method "com.atproto.server.activateAccount".
+func ServerActivateAccount(ctx context.Context, c lexutil.LexClient) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "", "com.atproto.server.activateAccount", nil, nil, nil); err != nil {
+		return err
+	}
+
+	return nil
+}

api/atproto/servercheckAccountStatus.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.server.checkAccountStatus
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// ServerCheckAccountStatus_Output is the output of a com.atproto.server.checkAccountStatus call.
+type ServerCheckAccountStatus_Output struct {
+	Activated          bool   `json:"activated" cborgen:"activated"`
+	ExpectedBlobs      int64  `json:"expectedBlobs" cborgen:"expectedBlobs"`
+	ImportedBlobs      int64  `json:"importedBlobs" cborgen:"importedBlobs"`
+	IndexedRecords     int64  `json:"indexedRecords" cborgen:"indexedRecords"`
+	PrivateStateValues int64  `json:"privateStateValues" cborgen:"privateStateValues"`
+	RepoBlocks         int64  `json:"repoBlocks" cborgen:"repoBlocks"`
+	RepoCommit         string `json:"repoCommit" cborgen:"repoCommit"`
+	RepoRev            string `json:"repoRev" cborgen:"repoRev"`
+	ValidDid           bool   `json:"validDid" cborgen:"validDid"`
+}
+
+// ServerCheckAccountStatus calls the XRPC method "com.atproto.server.checkAccountStatus".
+func ServerCheckAccountStatus(ctx context.Context, c lexutil.LexClient) (*ServerCheckAccountStatus_Output, error) {
+	var out ServerCheckAccountStatus_Output
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.server.checkAccountStatus", nil, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/serverconfirmEmail.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.server.confirmEmail
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// ServerConfirmEmail_Input is the input argument to a com.atproto.server.confirmEmail call.
+type ServerConfirmEmail_Input struct {
+	Email string `json:"email" cborgen:"email"`
+	Token string `json:"token" cborgen:"token"`
+}
+
+// ServerConfirmEmail calls the XRPC method "com.atproto.server.confirmEmail".
+func ServerConfirmEmail(ctx context.Context, c lexutil.LexClient, input *ServerConfirmEmail_Input) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.server.confirmEmail", nil, input, nil); err != nil {
+		return err
+	}
+
+	return nil
+}

api/atproto/servercreateAccount.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.server.createAccount
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// ServerCreateAccount_Input is the input argument to a com.atproto.server.createAccount call.
+type ServerCreateAccount_Input struct {
+	// did: Pre-existing atproto DID, being imported to a new account.
+	Did   *string `json:"did,omitempty" cborgen:"did,omitempty"`
+	Email *string `json:"email,omitempty" cborgen:"email,omitempty"`
+	// handle: Requested handle for the account.
+	Handle     string  `json:"handle" cborgen:"handle"`
+	InviteCode *string `json:"inviteCode,omitempty" cborgen:"inviteCode,omitempty"`
+	// password: Initial account password. May need to meet instance-specific password strength requirements.
+	Password *string `json:"password,omitempty" cborgen:"password,omitempty"`
+	// plcOp: A signed DID PLC operation to be submitted as part of importing an existing account to this instance. NOTE: this optional field may be updated when full account migration is implemented.
+	PlcOp *interface{} `json:"plcOp,omitempty" cborgen:"plcOp,omitempty"`
+	// recoveryKey: DID PLC rotation key (aka, recovery key) to be included in PLC creation operation.
+	RecoveryKey       *string `json:"recoveryKey,omitempty" cborgen:"recoveryKey,omitempty"`
+	VerificationCode  *string `json:"verificationCode,omitempty" cborgen:"verificationCode,omitempty"`
+	VerificationPhone *string `json:"verificationPhone,omitempty" cborgen:"verificationPhone,omitempty"`
+}
+
+// ServerCreateAccount_Output is the output of a com.atproto.server.createAccount call.
+//
+// Account login session returned on successful account creation.
+type ServerCreateAccount_Output struct {
+	AccessJwt string `json:"accessJwt" cborgen:"accessJwt"`
+	// did: The DID of the new account.
+	Did string `json:"did" cborgen:"did"`
+	// didDoc: Complete DID document.
+	DidDoc     *interface{} `json:"didDoc,omitempty" cborgen:"didDoc,omitempty"`
+	Handle     string       `json:"handle" cborgen:"handle"`
+	RefreshJwt string       `json:"refreshJwt" cborgen:"refreshJwt"`
+}
+
+// ServerCreateAccount calls the XRPC method "com.atproto.server.createAccount".
+func ServerCreateAccount(ctx context.Context, c lexutil.LexClient, input *ServerCreateAccount_Input) (*ServerCreateAccount_Output, error) {
+	var out ServerCreateAccount_Output
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.server.createAccount", nil, input, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/servercreateAppPassword.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.server.createAppPassword
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// 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"`
+	Privileged *bool  `json:"privileged,omitempty" cborgen:"privileged,omitempty"`
+}
+
+// ServerCreateAppPassword_Input is the input argument to a com.atproto.server.createAppPassword call.
+type ServerCreateAppPassword_Input struct {
+	// name: A short name for the App Password, to help distinguish them.
+	Name string `json:"name" cborgen:"name"`
+	// privileged: If an app password has 'privileged' access to possibly sensitive account state. Meant for use with trusted clients.
+	Privileged *bool `json:"privileged,omitempty" cborgen:"privileged,omitempty"`
+}
+
+// ServerCreateAppPassword calls the XRPC method "com.atproto.server.createAppPassword".
+func ServerCreateAppPassword(ctx context.Context, c lexutil.LexClient, input *ServerCreateAppPassword_Input) (*ServerCreateAppPassword_AppPassword, error) {
+	var out ServerCreateAppPassword_AppPassword
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.server.createAppPassword", nil, input, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/servercreateInviteCode.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.server.createInviteCode
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// 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 lexutil.LexClient, input *ServerCreateInviteCode_Input) (*ServerCreateInviteCode_Output, error) {
+	var out ServerCreateInviteCode_Output
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.server.createInviteCode", nil, input, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/servercreateInviteCodes.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.server.createInviteCodes
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// 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 lexutil.LexClient, input *ServerCreateInviteCodes_Input) (*ServerCreateInviteCodes_Output, error) {
+	var out ServerCreateInviteCodes_Output
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.server.createInviteCodes", nil, input, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/servercreateSession.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.server.createSession
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// ServerCreateSession_Input is the input argument to a com.atproto.server.createSession call.
+type ServerCreateSession_Input struct {
+	// allowTakendown: When true, instead of throwing error for takendown accounts, a valid response with a narrow scoped token will be returned
+	AllowTakendown  *bool   `json:"allowTakendown,omitempty" cborgen:"allowTakendown,omitempty"`
+	AuthFactorToken *string `json:"authFactorToken,omitempty" cborgen:"authFactorToken,omitempty"`
+	// 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"`
+	Active          *bool        `json:"active,omitempty" cborgen:"active,omitempty"`
+	Did             string       `json:"did" cborgen:"did"`
+	DidDoc          *interface{} `json:"didDoc,omitempty" cborgen:"didDoc,omitempty"`
+	Email           *string      `json:"email,omitempty" cborgen:"email,omitempty"`
+	EmailAuthFactor *bool        `json:"emailAuthFactor,omitempty" cborgen:"emailAuthFactor,omitempty"`
+	EmailConfirmed  *bool        `json:"emailConfirmed,omitempty" cborgen:"emailConfirmed,omitempty"`
+	Handle          string       `json:"handle" cborgen:"handle"`
+	RefreshJwt      string       `json:"refreshJwt" cborgen:"refreshJwt"`
+	// status: If active=false, this optional field indicates a possible reason for why the account is not active. If active=false and no status is supplied, then the host makes no claim for why the repository is no longer being hosted.
+	Status *string `json:"status,omitempty" cborgen:"status,omitempty"`
+}
+
+// ServerCreateSession calls the XRPC method "com.atproto.server.createSession".
+func ServerCreateSession(ctx context.Context, c lexutil.LexClient, input *ServerCreateSession_Input) (*ServerCreateSession_Output, error) {
+	var out ServerCreateSession_Output
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.server.createSession", nil, input, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/serverdeactivateAccount.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.server.deactivateAccount
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// ServerDeactivateAccount_Input is the input argument to a com.atproto.server.deactivateAccount call.
+type ServerDeactivateAccount_Input struct {
+	// deleteAfter: A recommendation to server as to how long they should hold onto the deactivated account before deleting.
+	DeleteAfter *string `json:"deleteAfter,omitempty" cborgen:"deleteAfter,omitempty"`
+}
+
+// ServerDeactivateAccount calls the XRPC method "com.atproto.server.deactivateAccount".
+func ServerDeactivateAccount(ctx context.Context, c lexutil.LexClient, input *ServerDeactivateAccount_Input) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.server.deactivateAccount", nil, input, nil); err != nil {
+		return err
+	}
+
+	return nil
+}

api/atproto/serverdefs.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.server.defs
+
+package atproto
+
+// 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"`
+	CreatedAt  string                      `json:"createdAt" cborgen:"createdAt"`
+	CreatedBy  string                      `json:"createdBy" cborgen:"createdBy"`
+	Disabled   bool                        `json:"disabled" cborgen:"disabled"`
+	ForAccount string                      `json:"forAccount" cborgen:"forAccount"`
+	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

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.server.deleteAccount
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// 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 lexutil.LexClient, input *ServerDeleteAccount_Input) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.server.deleteAccount", nil, input, nil); err != nil {
+		return err
+	}
+
+	return nil
+}

api/atproto/serverdeleteSession.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.server.deleteSession
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// ServerDeleteSession calls the XRPC method "com.atproto.server.deleteSession".
+func ServerDeleteSession(ctx context.Context, c lexutil.LexClient) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "", "com.atproto.server.deleteSession", nil, nil, nil); err != nil {
+		return err
+	}
+
+	return nil
+}

api/atproto/serverdescribeServer.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.server.describeServer
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// ServerDescribeServer_Contact is a "contact" in the com.atproto.server.describeServer schema.
+type ServerDescribeServer_Contact struct {
+	Email *string `json:"email,omitempty" cborgen:"email,omitempty"`
+}
+
+// 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: List of domain suffixes that can be used in account handles.
+	AvailableUserDomains []string `json:"availableUserDomains" cborgen:"availableUserDomains"`
+	// contact: Contact information
+	Contact *ServerDescribeServer_Contact `json:"contact,omitempty" cborgen:"contact,omitempty"`
+	Did     string                        `json:"did" cborgen:"did"`
+	// inviteCodeRequired: If true, an invite code must be supplied to create an account on this instance.
+	InviteCodeRequired *bool `json:"inviteCodeRequired,omitempty" cborgen:"inviteCodeRequired,omitempty"`
+	// links: URLs of service policy documents.
+	Links *ServerDescribeServer_Links `json:"links,omitempty" cborgen:"links,omitempty"`
+	// phoneVerificationRequired: If true, a phone verification token must be supplied to create an account on this instance.
+	PhoneVerificationRequired *bool `json:"phoneVerificationRequired,omitempty" cborgen:"phoneVerificationRequired,omitempty"`
+}
+
+// ServerDescribeServer calls the XRPC method "com.atproto.server.describeServer".
+func ServerDescribeServer(ctx context.Context, c lexutil.LexClient) (*ServerDescribeServer_Output, error) {
+	var out ServerDescribeServer_Output
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.server.describeServer", nil, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/servergetAccountInviteCodes.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.server.getAccountInviteCodes
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// 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".
+//
+// createAvailable: Controls whether any new 'earned' but not 'created' invites should be created.
+func ServerGetAccountInviteCodes(ctx context.Context, c lexutil.LexClient, createAvailable bool, includeUsed bool) (*ServerGetAccountInviteCodes_Output, error) {
+	var out ServerGetAccountInviteCodes_Output
+
+	params := map[string]interface{}{}
+	if createAvailable {
+		params["createAvailable"] = createAvailable
+	}
+	if includeUsed {
+		params["includeUsed"] = includeUsed
+	}
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.server.getAccountInviteCodes", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/servergetServiceAuth.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.server.getServiceAuth
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// ServerGetServiceAuth_Output is the output of a com.atproto.server.getServiceAuth call.
+type ServerGetServiceAuth_Output struct {
+	Token string `json:"token" cborgen:"token"`
+}
+
+// ServerGetServiceAuth calls the XRPC method "com.atproto.server.getServiceAuth".
+//
+// aud: The DID of the service that the token will be used to authenticate with
+// exp: The time in Unix Epoch seconds that the JWT expires. Defaults to 60 seconds in the future. The service may enforce certain time bounds on tokens depending on the requested scope.
+// lxm: Lexicon (XRPC) method to bind the requested token to
+func ServerGetServiceAuth(ctx context.Context, c lexutil.LexClient, aud string, exp int64, lxm string) (*ServerGetServiceAuth_Output, error) {
+	var out ServerGetServiceAuth_Output
+
+	params := map[string]interface{}{}
+	params["aud"] = aud
+	if exp != 0 {
+		params["exp"] = exp
+	}
+	if lxm != "" {
+		params["lxm"] = lxm
+	}
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.server.getServiceAuth", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/servergetSession.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.server.getSession
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// ServerGetSession_Output is the output of a com.atproto.server.getSession call.
+type ServerGetSession_Output struct {
+	Active          *bool        `json:"active,omitempty" cborgen:"active,omitempty"`
+	Did             string       `json:"did" cborgen:"did"`
+	DidDoc          *interface{} `json:"didDoc,omitempty" cborgen:"didDoc,omitempty"`
+	Email           *string      `json:"email,omitempty" cborgen:"email,omitempty"`
+	EmailAuthFactor *bool        `json:"emailAuthFactor,omitempty" cborgen:"emailAuthFactor,omitempty"`
+	EmailConfirmed  *bool        `json:"emailConfirmed,omitempty" cborgen:"emailConfirmed,omitempty"`
+	Handle          string       `json:"handle" cborgen:"handle"`
+	// status: If active=false, this optional field indicates a possible reason for why the account is not active. If active=false and no status is supplied, then the host makes no claim for why the repository is no longer being hosted.
+	Status *string `json:"status,omitempty" cborgen:"status,omitempty"`
+}
+
+// ServerGetSession calls the XRPC method "com.atproto.server.getSession".
+func ServerGetSession(ctx context.Context, c lexutil.LexClient) (*ServerGetSession_Output, error) {
+	var out ServerGetSession_Output
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.server.getSession", nil, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/serverlistAppPasswords.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.server.listAppPasswords
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// 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"`
+	Privileged *bool  `json:"privileged,omitempty" cborgen:"privileged,omitempty"`
+}
+
+// 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 lexutil.LexClient) (*ServerListAppPasswords_Output, error) {
+	var out ServerListAppPasswords_Output
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.server.listAppPasswords", nil, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/serverrefreshSession.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.server.refreshSession
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// ServerRefreshSession_Output is the output of a com.atproto.server.refreshSession call.
+type ServerRefreshSession_Output struct {
+	AccessJwt  string       `json:"accessJwt" cborgen:"accessJwt"`
+	Active     *bool        `json:"active,omitempty" cborgen:"active,omitempty"`
+	Did        string       `json:"did" cborgen:"did"`
+	DidDoc     *interface{} `json:"didDoc,omitempty" cborgen:"didDoc,omitempty"`
+	Handle     string       `json:"handle" cborgen:"handle"`
+	RefreshJwt string       `json:"refreshJwt" cborgen:"refreshJwt"`
+	// status: Hosting status of the account. If not specified, then assume 'active'.
+	Status *string `json:"status,omitempty" cborgen:"status,omitempty"`
+}
+
+// ServerRefreshSession calls the XRPC method "com.atproto.server.refreshSession".
+func ServerRefreshSession(ctx context.Context, c lexutil.LexClient) (*ServerRefreshSession_Output, error) {
+	var out ServerRefreshSession_Output
+	if err := c.LexDo(ctx, lexutil.Procedure, "", "com.atproto.server.refreshSession", nil, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/serverrequestAccountDelete.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.server.requestAccountDelete
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// ServerRequestAccountDelete calls the XRPC method "com.atproto.server.requestAccountDelete".
+func ServerRequestAccountDelete(ctx context.Context, c lexutil.LexClient) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "", "com.atproto.server.requestAccountDelete", nil, nil, nil); err != nil {
+		return err
+	}
+
+	return nil
+}

api/atproto/serverrequestEmailConfirmation.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.server.requestEmailConfirmation
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// ServerRequestEmailConfirmation calls the XRPC method "com.atproto.server.requestEmailConfirmation".
+func ServerRequestEmailConfirmation(ctx context.Context, c lexutil.LexClient) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "", "com.atproto.server.requestEmailConfirmation", nil, nil, nil); err != nil {
+		return err
+	}
+
+	return nil
+}

api/atproto/serverrequestEmailUpdate.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.server.requestEmailUpdate
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// ServerRequestEmailUpdate_Output is the output of a com.atproto.server.requestEmailUpdate call.
+type ServerRequestEmailUpdate_Output struct {
+	TokenRequired bool `json:"tokenRequired" cborgen:"tokenRequired"`
+}
+
+// ServerRequestEmailUpdate calls the XRPC method "com.atproto.server.requestEmailUpdate".
+func ServerRequestEmailUpdate(ctx context.Context, c lexutil.LexClient) (*ServerRequestEmailUpdate_Output, error) {
+	var out ServerRequestEmailUpdate_Output
+	if err := c.LexDo(ctx, lexutil.Procedure, "", "com.atproto.server.requestEmailUpdate", nil, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/serverrequestPasswordReset.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.server.requestPasswordReset
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// 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 lexutil.LexClient, input *ServerRequestPasswordReset_Input) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.server.requestPasswordReset", nil, input, nil); err != nil {
+		return err
+	}
+
+	return nil
+}

api/atproto/serverreserveSigningKey.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.server.reserveSigningKey
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// ServerReserveSigningKey_Input is the input argument to a com.atproto.server.reserveSigningKey call.
+type ServerReserveSigningKey_Input struct {
+	// did: The DID to reserve a key for.
+	Did *string `json:"did,omitempty" cborgen:"did,omitempty"`
+}
+
+// ServerReserveSigningKey_Output is the output of a com.atproto.server.reserveSigningKey call.
+type ServerReserveSigningKey_Output struct {
+	// signingKey: The public key for the reserved signing key, in did:key serialization.
+	SigningKey string `json:"signingKey" cborgen:"signingKey"`
+}
+
+// ServerReserveSigningKey calls the XRPC method "com.atproto.server.reserveSigningKey".
+func ServerReserveSigningKey(ctx context.Context, c lexutil.LexClient, input *ServerReserveSigningKey_Input) (*ServerReserveSigningKey_Output, error) {
+	var out ServerReserveSigningKey_Output
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.server.reserveSigningKey", nil, input, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/serverresetPassword.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.server.resetPassword
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// 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 lexutil.LexClient, input *ServerResetPassword_Input) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.server.resetPassword", nil, input, nil); err != nil {
+		return err
+	}
+
+	return nil
+}

api/atproto/serverrevokeAppPassword.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.server.revokeAppPassword
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// 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 lexutil.LexClient, input *ServerRevokeAppPassword_Input) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.server.revokeAppPassword", nil, input, nil); err != nil {
+		return err
+	}
+
+	return nil
+}

api/atproto/serverupdateEmail.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.server.updateEmail
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// ServerUpdateEmail_Input is the input argument to a com.atproto.server.updateEmail call.
+type ServerUpdateEmail_Input struct {
+	Email           string `json:"email" cborgen:"email"`
+	EmailAuthFactor *bool  `json:"emailAuthFactor,omitempty" cborgen:"emailAuthFactor,omitempty"`
+	// token: Requires a token from com.atproto.sever.requestEmailUpdate if the account's email has been confirmed.
+	Token *string `json:"token,omitempty" cborgen:"token,omitempty"`
+}
+
+// ServerUpdateEmail calls the XRPC method "com.atproto.server.updateEmail".
+func ServerUpdateEmail(ctx context.Context, c lexutil.LexClient, input *ServerUpdateEmail_Input) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.server.updateEmail", nil, input, nil); err != nil {
+		return err
+	}
+
+	return nil
+}

api/atproto/syncdefs.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.sync.defs
+
+package atproto

api/atproto/syncgetBlob.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.sync.getBlob
+
+package atproto
+
+import (
+	"bytes"
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// SyncGetBlob calls the XRPC method "com.atproto.sync.getBlob".
+//
+// cid: The CID of the blob to fetch
+// did: The DID of the account.
+func SyncGetBlob(ctx context.Context, c lexutil.LexClient, cid string, did string) ([]byte, error) {
+	buf := new(bytes.Buffer)
+
+	params := map[string]interface{}{}
+	params["cid"] = cid
+	params["did"] = did
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.sync.getBlob", params, nil, buf); err != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}

api/atproto/syncgetBlocks.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.sync.getBlocks
+
+package atproto
+
+import (
+	"bytes"
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// SyncGetBlocks calls the XRPC method "com.atproto.sync.getBlocks".
+//
+// did: The DID of the repo.
+func SyncGetBlocks(ctx context.Context, c lexutil.LexClient, cids []string, did string) ([]byte, error) {
+	buf := new(bytes.Buffer)
+
+	params := map[string]interface{}{}
+	params["cids"] = cids
+	params["did"] = did
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.sync.getBlocks", params, nil, buf); err != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}

api/atproto/syncgetCheckout.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.sync.getCheckout
+
+package atproto
+
+import (
+	"bytes"
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// SyncGetCheckout calls the XRPC method "com.atproto.sync.getCheckout".
+//
+// did: The DID of the repo.
+func SyncGetCheckout(ctx context.Context, c lexutil.LexClient, did string) ([]byte, error) {
+	buf := new(bytes.Buffer)
+
+	params := map[string]interface{}{}
+	params["did"] = did
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.sync.getCheckout", params, nil, buf); err != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}

api/atproto/syncgetHead.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.sync.getHead
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// 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 lexutil.LexClient, did string) (*SyncGetHead_Output, error) {
+	var out SyncGetHead_Output
+
+	params := map[string]interface{}{}
+	params["did"] = did
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.sync.getHead", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/syncgetHostStatus.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.sync.getHostStatus
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// SyncGetHostStatus_Output is the output of a com.atproto.sync.getHostStatus call.
+type SyncGetHostStatus_Output struct {
+	// accountCount: Number of accounts on the server which are associated with the upstream host. Note that the upstream may actually have more accounts.
+	AccountCount *int64 `json:"accountCount,omitempty" cborgen:"accountCount,omitempty"`
+	Hostname     string `json:"hostname" cborgen:"hostname"`
+	// seq: Recent repo stream event sequence number. May be delayed from actual stream processing (eg, persisted cursor not in-memory cursor).
+	Seq    *int64  `json:"seq,omitempty" cborgen:"seq,omitempty"`
+	Status *string `json:"status,omitempty" cborgen:"status,omitempty"`
+}
+
+// SyncGetHostStatus calls the XRPC method "com.atproto.sync.getHostStatus".
+//
+// hostname: Hostname of the host (eg, PDS or relay) being queried.
+func SyncGetHostStatus(ctx context.Context, c lexutil.LexClient, hostname string) (*SyncGetHostStatus_Output, error) {
+	var out SyncGetHostStatus_Output
+
+	params := map[string]interface{}{}
+	params["hostname"] = hostname
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.sync.getHostStatus", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/syncgetLatestCommit.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.sync.getLatestCommit
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// SyncGetLatestCommit_Output is the output of a com.atproto.sync.getLatestCommit call.
+type SyncGetLatestCommit_Output struct {
+	Cid string `json:"cid" cborgen:"cid"`
+	Rev string `json:"rev" cborgen:"rev"`
+}
+
+// SyncGetLatestCommit calls the XRPC method "com.atproto.sync.getLatestCommit".
+//
+// did: The DID of the repo.
+func SyncGetLatestCommit(ctx context.Context, c lexutil.LexClient, did string) (*SyncGetLatestCommit_Output, error) {
+	var out SyncGetLatestCommit_Output
+
+	params := map[string]interface{}{}
+	params["did"] = did
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.sync.getLatestCommit", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/syncgetRecord.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.sync.getRecord
+
+package atproto
+
+import (
+	"bytes"
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// SyncGetRecord calls the XRPC method "com.atproto.sync.getRecord".
+//
+// did: The DID of the repo.
+// rkey: Record Key
+func SyncGetRecord(ctx context.Context, c lexutil.LexClient, collection string, did string, rkey string) ([]byte, error) {
+	buf := new(bytes.Buffer)
+
+	params := map[string]interface{}{}
+	params["collection"] = collection
+	params["did"] = did
+	params["rkey"] = rkey
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.sync.getRecord", params, nil, buf); err != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}

api/atproto/syncgetRepo.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.sync.getRepo
+
+package atproto
+
+import (
+	"bytes"
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// SyncGetRepo calls the XRPC method "com.atproto.sync.getRepo".
+//
+// did: The DID of the repo.
+// since: The revision ('rev') of the repo to create a diff from.
+func SyncGetRepo(ctx context.Context, c lexutil.LexClient, did string, since string) ([]byte, error) {
+	buf := new(bytes.Buffer)
+
+	params := map[string]interface{}{}
+	params["did"] = did
+	if since != "" {
+		params["since"] = since
+	}
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.sync.getRepo", params, nil, buf); err != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}

api/atproto/syncgetRepoStatus.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.sync.getRepoStatus
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// SyncGetRepoStatus_Output is the output of a com.atproto.sync.getRepoStatus call.
+type SyncGetRepoStatus_Output struct {
+	Active bool   `json:"active" cborgen:"active"`
+	Did    string `json:"did" cborgen:"did"`
+	// rev: Optional field, the current rev of the repo, if active=true
+	Rev *string `json:"rev,omitempty" cborgen:"rev,omitempty"`
+	// status: If active=false, this optional field indicates a possible reason for why the account is not active. If active=false and no status is supplied, then the host makes no claim for why the repository is no longer being hosted.
+	Status *string `json:"status,omitempty" cborgen:"status,omitempty"`
+}
+
+// SyncGetRepoStatus calls the XRPC method "com.atproto.sync.getRepoStatus".
+//
+// did: The DID of the repo.
+func SyncGetRepoStatus(ctx context.Context, c lexutil.LexClient, did string) (*SyncGetRepoStatus_Output, error) {
+	var out SyncGetRepoStatus_Output
+
+	params := map[string]interface{}{}
+	params["did"] = did
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.sync.getRepoStatus", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/synclistBlobs.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.sync.listBlobs
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// SyncListBlobs_Output is the output of a com.atproto.sync.listBlobs call.
+type SyncListBlobs_Output struct {
+	Cids   []string `json:"cids" cborgen:"cids"`
+	Cursor *string  `json:"cursor,omitempty" cborgen:"cursor,omitempty"`
+}
+
+// SyncListBlobs calls the XRPC method "com.atproto.sync.listBlobs".
+//
+// did: The DID of the repo.
+// since: Optional revision of the repo to list blobs since.
+func SyncListBlobs(ctx context.Context, c lexutil.LexClient, cursor string, did string, limit int64, since string) (*SyncListBlobs_Output, error) {
+	var out SyncListBlobs_Output
+
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	params["did"] = did
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	if since != "" {
+		params["since"] = since
+	}
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.sync.listBlobs", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/synclistHosts.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.sync.listHosts
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// SyncListHosts_Host is a "host" in the com.atproto.sync.listHosts schema.
+type SyncListHosts_Host struct {
+	AccountCount *int64 `json:"accountCount,omitempty" cborgen:"accountCount,omitempty"`
+	// hostname: hostname of server; not a URL (no scheme)
+	Hostname string `json:"hostname" cborgen:"hostname"`
+	// seq: Recent repo stream event sequence number. May be delayed from actual stream processing (eg, persisted cursor not in-memory cursor).
+	Seq    *int64  `json:"seq,omitempty" cborgen:"seq,omitempty"`
+	Status *string `json:"status,omitempty" cborgen:"status,omitempty"`
+}
+
+// SyncListHosts_Output is the output of a com.atproto.sync.listHosts call.
+type SyncListHosts_Output struct {
+	Cursor *string `json:"cursor,omitempty" cborgen:"cursor,omitempty"`
+	// hosts: Sort order is not formally specified. Recommended order is by time host was first seen by the server, with oldest first.
+	Hosts []*SyncListHosts_Host `json:"hosts" cborgen:"hosts"`
+}
+
+// SyncListHosts calls the XRPC method "com.atproto.sync.listHosts".
+func SyncListHosts(ctx context.Context, c lexutil.LexClient, cursor string, limit int64) (*SyncListHosts_Output, error) {
+	var out SyncListHosts_Output
+
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.sync.listHosts", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/synclistRepos.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.sync.listRepos
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// 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 {
+	Active *bool  `json:"active,omitempty" cborgen:"active,omitempty"`
+	Did    string `json:"did" cborgen:"did"`
+	// head: Current repo commit CID
+	Head string `json:"head" cborgen:"head"`
+	Rev  string `json:"rev" cborgen:"rev"`
+	// status: If active=false, this optional field indicates a possible reason for why the account is not active. If active=false and no status is supplied, then the host makes no claim for why the repository is no longer being hosted.
+	Status *string `json:"status,omitempty" cborgen:"status,omitempty"`
+}
+
+// SyncListRepos calls the XRPC method "com.atproto.sync.listRepos".
+func SyncListRepos(ctx context.Context, c lexutil.LexClient, cursor string, limit int64) (*SyncListRepos_Output, error) {
+	var out SyncListRepos_Output
+
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.sync.listRepos", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/synclistReposByCollection.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.sync.listReposByCollection
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// SyncListReposByCollection_Output is the output of a com.atproto.sync.listReposByCollection call.
+type SyncListReposByCollection_Output struct {
+	Cursor *string                           `json:"cursor,omitempty" cborgen:"cursor,omitempty"`
+	Repos  []*SyncListReposByCollection_Repo `json:"repos" cborgen:"repos"`
+}
+
+// SyncListReposByCollection_Repo is a "repo" in the com.atproto.sync.listReposByCollection schema.
+type SyncListReposByCollection_Repo struct {
+	Did string `json:"did" cborgen:"did"`
+}
+
+// SyncListReposByCollection calls the XRPC method "com.atproto.sync.listReposByCollection".
+//
+// limit: Maximum size of response set. Recommend setting a large maximum (1000+) when enumerating large DID lists.
+func SyncListReposByCollection(ctx context.Context, c lexutil.LexClient, collection string, cursor string, limit int64) (*SyncListReposByCollection_Output, error) {
+	var out SyncListReposByCollection_Output
+
+	params := map[string]interface{}{}
+	params["collection"] = collection
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.sync.listReposByCollection", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/syncnotifyOfUpdate.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.sync.notifyOfUpdate
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// SyncNotifyOfUpdate_Input is the input argument to a com.atproto.sync.notifyOfUpdate call.
+type SyncNotifyOfUpdate_Input struct {
+	// hostname: Hostname of the current service (usually a PDS) that is notifying of update.
+	Hostname string `json:"hostname" cborgen:"hostname"`
+}
+
+// SyncNotifyOfUpdate calls the XRPC method "com.atproto.sync.notifyOfUpdate".
+func SyncNotifyOfUpdate(ctx context.Context, c lexutil.LexClient, input *SyncNotifyOfUpdate_Input) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.sync.notifyOfUpdate", nil, input, nil); err != nil {
+		return err
+	}
+
+	return nil
+}

api/atproto/syncrequestCrawl.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.sync.requestCrawl
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// SyncRequestCrawl_Input is the input argument to a com.atproto.sync.requestCrawl call.
+type SyncRequestCrawl_Input struct {
+	// hostname: Hostname of the current service (eg, PDS) that is requesting to be crawled.
+	Hostname string `json:"hostname" cborgen:"hostname"`
+}
+
+// SyncRequestCrawl calls the XRPC method "com.atproto.sync.requestCrawl".
+func SyncRequestCrawl(ctx context.Context, c lexutil.LexClient, input *SyncRequestCrawl_Input) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.sync.requestCrawl", nil, input, nil); err != nil {
+		return err
+	}
+
+	return nil
+}

api/atproto/syncsubscribeRepos.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.sync.subscribeRepos
+
+package atproto
+
+import (
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// SyncSubscribeRepos_Account is a "account" in the com.atproto.sync.subscribeRepos schema.
+//
+// Represents a change to an account's status on a host (eg, PDS or Relay). The semantics of this event are that the status is at the host which emitted the event, not necessarily that at the currently active PDS. Eg, a Relay takedown would emit a takedown with active=false, even if the PDS is still active.
+type SyncSubscribeRepos_Account struct {
+	// active: Indicates that the account has a repository which can be fetched from the host that emitted this event.
+	Active bool   `json:"active" cborgen:"active"`
+	Did    string `json:"did" cborgen:"did"`
+	Seq    int64  `json:"seq" cborgen:"seq"`
+	// status: If active=false, this optional field indicates a reason for why the account is not active.
+	Status *string `json:"status,omitempty" cborgen:"status,omitempty"`
+	Time   string  `json:"time" cborgen:"time"`
+}
+
+// SyncSubscribeRepos_Commit is a "commit" in the com.atproto.sync.subscribeRepos schema.
+//
+// Represents an update of repository state. Note that empty commits are allowed, which include no repo data changes, but an update to rev and signature.
+type SyncSubscribeRepos_Commit struct {
+	Blobs []lexutil.LexLink `json:"blobs" cborgen:"blobs"`
+	// blocks: CAR file containing relevant blocks, as a diff since the previous repo state. The commit must be included as a block, and the commit block CID must be the first entry in the CAR header 'roots' list.
+	Blocks lexutil.LexBytes `json:"blocks,omitempty" cborgen:"blocks,omitempty"`
+	// commit: Repo commit object CID.
+	Commit lexutil.LexLink              `json:"commit" cborgen:"commit"`
+	Ops    []*SyncSubscribeRepos_RepoOp `json:"ops" cborgen:"ops"`
+	// prevData: The root CID of the MST tree for the previous commit from this repo (indicated by the 'since' revision field in this message). Corresponds to the 'data' field in the repo commit object. NOTE: this field is effectively required for the 'inductive' version of firehose.
+	PrevData *lexutil.LexLink `json:"prevData,omitempty" cborgen:"prevData,omitempty"`
+	// rebase: DEPRECATED -- unused
+	Rebase bool `json:"rebase" cborgen:"rebase"`
+	// repo: The repo this event comes from. Note that all other message types name this field 'did'.
+	Repo string `json:"repo" cborgen:"repo"`
+	// rev: The rev of the emitted commit. Note that this information is also in the commit object included in blocks, unless this is a tooBig event.
+	Rev string `json:"rev" cborgen:"rev"`
+	// seq: The stream sequence number of this message.
+	Seq int64 `json:"seq" cborgen:"seq"`
+	// since: The rev of the last emitted commit from this repo (if any).
+	Since *string `json:"since" cborgen:"since"`
+	// time: Timestamp of when this message was originally broadcast.
+	Time string `json:"time" cborgen:"time"`
+	// tooBig: DEPRECATED -- replaced by #sync event and data limits. Indicates that this commit contained too many ops, or data size was too large. Consumers will need to make a separate request to get missing data.
+	TooBig bool `json:"tooBig" cborgen:"tooBig"`
+}
+
+// SyncSubscribeRepos_Identity is a "identity" in the com.atproto.sync.subscribeRepos schema.
+//
+// Represents a change to an account's identity. Could be an updated handle, signing key, or pds hosting endpoint. Serves as a prod to all downstream services to refresh their identity cache.
+type SyncSubscribeRepos_Identity struct {
+	Did string `json:"did" cborgen:"did"`
+	// handle: The current handle for the account, or 'handle.invalid' if validation fails. This field is optional, might have been validated or passed-through from an upstream source. Semantics and behaviors for PDS vs Relay may evolve in the future; see atproto specs for more details.
+	Handle *string `json:"handle,omitempty" cborgen:"handle,omitempty"`
+	Seq    int64   `json:"seq" cborgen:"seq"`
+	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_RepoOp is a "repoOp" in the com.atproto.sync.subscribeRepos schema.
+//
+// A repo operation, ie a mutation of a single record.
+type SyncSubscribeRepos_RepoOp struct {
+	Action string `json:"action" cborgen:"action"`
+	// cid: For creates and updates, the new record CID. For deletions, null.
+	Cid  *lexutil.LexLink `json:"cid" cborgen:"cid"`
+	Path string           `json:"path" cborgen:"path"`
+	// prev: For updates and deletes, the previous record CID (required for inductive firehose). For creations, field should not be defined.
+	Prev *lexutil.LexLink `json:"prev,omitempty" cborgen:"prev,omitempty"`
+}
+
+// SyncSubscribeRepos_Sync is a "sync" in the com.atproto.sync.subscribeRepos schema.
+//
+// Updates the repo to a new state, without necessarily including that state on the firehose. Used to recover from broken commit streams, data loss incidents, or in situations where upstream host does not know recent state of the repository.
+type SyncSubscribeRepos_Sync struct {
+	// blocks: CAR file containing the commit, as a block. The CAR header must include the commit block CID as the first 'root'.
+	Blocks lexutil.LexBytes `json:"blocks,omitempty" cborgen:"blocks,omitempty"`
+	// did: The account this repo event corresponds to. Must match that in the commit object.
+	Did string `json:"did" cborgen:"did"`
+	// rev: The rev of the commit. This value must match that in the commit object.
+	Rev string `json:"rev" cborgen:"rev"`
+	// seq: The stream sequence number of this message.
+	Seq int64 `json:"seq" cborgen:"seq"`
+	// time: Timestamp of when this message was originally broadcast.
+	Time string `json:"time" cborgen:"time"`
+}

api/atproto/tempaddReservedHandle.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.temp.addReservedHandle
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// TempAddReservedHandle_Input is the input argument to a com.atproto.temp.addReservedHandle call.
+type TempAddReservedHandle_Input struct {
+	Handle string `json:"handle" cborgen:"handle"`
+}
+
+// TempAddReservedHandle_Output is the output of a com.atproto.temp.addReservedHandle call.
+type TempAddReservedHandle_Output struct {
+}
+
+// TempAddReservedHandle calls the XRPC method "com.atproto.temp.addReservedHandle".
+func TempAddReservedHandle(ctx context.Context, c lexutil.LexClient, input *TempAddReservedHandle_Input) (*TempAddReservedHandle_Output, error) {
+	var out TempAddReservedHandle_Output
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.temp.addReservedHandle", nil, input, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/tempcheckHandleAvailability.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.temp.checkHandleAvailability
+
+package atproto
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// TempCheckHandleAvailability_Output is the output of a com.atproto.temp.checkHandleAvailability call.
+type TempCheckHandleAvailability_Output struct {
+	// handle: Echo of the input handle.
+	Handle string                                     `json:"handle" cborgen:"handle"`
+	Result *TempCheckHandleAvailability_Output_Result `json:"result" cborgen:"result"`
+}
+
+type TempCheckHandleAvailability_Output_Result struct {
+	TempCheckHandleAvailability_ResultAvailable   *TempCheckHandleAvailability_ResultAvailable
+	TempCheckHandleAvailability_ResultUnavailable *TempCheckHandleAvailability_ResultUnavailable
+}
+
+func (t *TempCheckHandleAvailability_Output_Result) MarshalJSON() ([]byte, error) {
+	if t.TempCheckHandleAvailability_ResultAvailable != nil {
+		t.TempCheckHandleAvailability_ResultAvailable.LexiconTypeID = "com.atproto.temp.checkHandleAvailability#resultAvailable"
+		return json.Marshal(t.TempCheckHandleAvailability_ResultAvailable)
+	}
+	if t.TempCheckHandleAvailability_ResultUnavailable != nil {
+		t.TempCheckHandleAvailability_ResultUnavailable.LexiconTypeID = "com.atproto.temp.checkHandleAvailability#resultUnavailable"
+		return json.Marshal(t.TempCheckHandleAvailability_ResultUnavailable)
+	}
+	return nil, fmt.Errorf("can not marshal empty union as JSON")
+}
+
+func (t *TempCheckHandleAvailability_Output_Result) UnmarshalJSON(b []byte) error {
+	typ, err := lexutil.TypeExtract(b)
+	if err != nil {
+		return err
+	}
+
+	switch typ {
+	case "com.atproto.temp.checkHandleAvailability#resultAvailable":
+		t.TempCheckHandleAvailability_ResultAvailable = new(TempCheckHandleAvailability_ResultAvailable)
+		return json.Unmarshal(b, t.TempCheckHandleAvailability_ResultAvailable)
+	case "com.atproto.temp.checkHandleAvailability#resultUnavailable":
+		t.TempCheckHandleAvailability_ResultUnavailable = new(TempCheckHandleAvailability_ResultUnavailable)
+		return json.Unmarshal(b, t.TempCheckHandleAvailability_ResultUnavailable)
+	default:
+		return nil
+	}
+}
+
+// TempCheckHandleAvailability_ResultAvailable is a "resultAvailable" in the com.atproto.temp.checkHandleAvailability schema.
+//
+// Indicates the provided handle is available.
+type TempCheckHandleAvailability_ResultAvailable struct {
+	LexiconTypeID string `json:"$type" cborgen:"$type,const=com.atproto.temp.checkHandleAvailability#resultAvailable"`
+}
+
+// TempCheckHandleAvailability_ResultUnavailable is a "resultUnavailable" in the com.atproto.temp.checkHandleAvailability schema.
+//
+// Indicates the provided handle is unavailable and gives suggestions of available handles.
+type TempCheckHandleAvailability_ResultUnavailable struct {
+	LexiconTypeID string `json:"$type" cborgen:"$type,const=com.atproto.temp.checkHandleAvailability#resultUnavailable"`
+	// suggestions: List of suggested handles based on the provided inputs.
+	Suggestions []*TempCheckHandleAvailability_Suggestion `json:"suggestions" cborgen:"suggestions"`
+}
+
+// TempCheckHandleAvailability_Suggestion is a "suggestion" in the com.atproto.temp.checkHandleAvailability schema.
+type TempCheckHandleAvailability_Suggestion struct {
+	Handle string `json:"handle" cborgen:"handle"`
+	// method: Method used to build this suggestion. Should be considered opaque to clients. Can be used for metrics.
+	Method string `json:"method" cborgen:"method"`
+}
+
+// TempCheckHandleAvailability calls the XRPC method "com.atproto.temp.checkHandleAvailability".
+//
+// birthDate: User-provided birth date. Might be used to build handle suggestions.
+// email: User-provided email. Might be used to build handle suggestions.
+// handle: Tentative handle. Will be checked for availability or used to build handle suggestions.
+func TempCheckHandleAvailability(ctx context.Context, c lexutil.LexClient, birthDate string, email string, handle string) (*TempCheckHandleAvailability_Output, error) {
+	var out TempCheckHandleAvailability_Output
+
+	params := map[string]interface{}{}
+	if birthDate != "" {
+		params["birthDate"] = birthDate
+	}
+	if email != "" {
+		params["email"] = email
+	}
+	params["handle"] = handle
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.temp.checkHandleAvailability", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/tempcheckSignupQueue.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.temp.checkSignupQueue
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// TempCheckSignupQueue_Output is the output of a com.atproto.temp.checkSignupQueue call.
+type TempCheckSignupQueue_Output struct {
+	Activated       bool   `json:"activated" cborgen:"activated"`
+	EstimatedTimeMs *int64 `json:"estimatedTimeMs,omitempty" cborgen:"estimatedTimeMs,omitempty"`
+	PlaceInQueue    *int64 `json:"placeInQueue,omitempty" cborgen:"placeInQueue,omitempty"`
+}
+
+// TempCheckSignupQueue calls the XRPC method "com.atproto.temp.checkSignupQueue".
+func TempCheckSignupQueue(ctx context.Context, c lexutil.LexClient) (*TempCheckSignupQueue_Output, error) {
+	var out TempCheckSignupQueue_Output
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.temp.checkSignupQueue", nil, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/tempdereferenceScope.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.temp.dereferenceScope
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// TempDereferenceScope_Output is the output of a com.atproto.temp.dereferenceScope call.
+type TempDereferenceScope_Output struct {
+	// scope: The full oauth permission scope
+	Scope string `json:"scope" cborgen:"scope"`
+}
+
+// TempDereferenceScope calls the XRPC method "com.atproto.temp.dereferenceScope".
+//
+// scope: The scope reference (starts with 'ref:')
+func TempDereferenceScope(ctx context.Context, c lexutil.LexClient, scope string) (*TempDereferenceScope_Output, error) {
+	var out TempDereferenceScope_Output
+
+	params := map[string]interface{}{}
+	params["scope"] = scope
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.temp.dereferenceScope", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/tempfetchLabels.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.temp.fetchLabels
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// TempFetchLabels_Output is the output of a com.atproto.temp.fetchLabels call.
+type TempFetchLabels_Output struct {
+	Labels []*LabelDefs_Label `json:"labels" cborgen:"labels"`
+}
+
+// TempFetchLabels calls the XRPC method "com.atproto.temp.fetchLabels".
+func TempFetchLabels(ctx context.Context, c lexutil.LexClient, limit int64, since int64) (*TempFetchLabels_Output, error) {
+	var out TempFetchLabels_Output
+
+	params := map[string]interface{}{}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	if since != 0 {
+		params["since"] = since
+	}
+	if err := c.LexDo(ctx, lexutil.Query, "", "com.atproto.temp.fetchLabels", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/atproto/temprequestPhoneVerification.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.temp.requestPhoneVerification
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// TempRequestPhoneVerification_Input is the input argument to a com.atproto.temp.requestPhoneVerification call.
+type TempRequestPhoneVerification_Input struct {
+	PhoneNumber string `json:"phoneNumber" cborgen:"phoneNumber"`
+}
+
+// TempRequestPhoneVerification calls the XRPC method "com.atproto.temp.requestPhoneVerification".
+func TempRequestPhoneVerification(ctx context.Context, c lexutil.LexClient, input *TempRequestPhoneVerification_Input) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.temp.requestPhoneVerification", nil, input, nil); err != nil {
+		return err
+	}
+
+	return nil
+}

api/atproto/temprevokeAccountCredentials.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: com.atproto.temp.revokeAccountCredentials
+
+package atproto
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// TempRevokeAccountCredentials_Input is the input argument to a com.atproto.temp.revokeAccountCredentials call.
+type TempRevokeAccountCredentials_Input struct {
+	Account string `json:"account" cborgen:"account"`
+}
+
+// TempRevokeAccountCredentials calls the XRPC method "com.atproto.temp.revokeAccountCredentials".
+func TempRevokeAccountCredentials(ctx context.Context, c lexutil.LexClient, input *TempRevokeAccountCredentials_Input) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "com.atproto.temp.revokeAccountCredentials", nil, input, nil); err != nil {
+		return err
+	}
+
+	return nil
+}

api/vylet/actordefs.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: app.vylet.actor.defs
+
+package vylet
+
+import (
+	comatproto "github.com/bluesky-social/indigo/api/atproto"
+)
+
+// ActorDefs_ProfileView is a "profileView" in the app.vylet.actor.defs schema.
+type ActorDefs_ProfileView struct {
+	Avatar      *string                       `json:"avatar,omitempty" cborgen:"avatar,omitempty"`
+	CreatedAt   *string                       `json:"createdAt,omitempty" cborgen:"createdAt,omitempty"`
+	Description *string                       `json:"description,omitempty" cborgen:"description,omitempty"`
+	Did         string                        `json:"did" cborgen:"did"`
+	DisplayName *string                       `json:"displayName,omitempty" cborgen:"displayName,omitempty"`
+	Handle      string                        `json:"handle" cborgen:"handle"`
+	IndexedAt   *string                       `json:"indexedAt,omitempty" cborgen:"indexedAt,omitempty"`
+	Labels      []*comatproto.LabelDefs_Label `json:"labels,omitempty" cborgen:"labels,omitempty"`
+	Pronouns    *string                       `json:"pronouns,omitempty" cborgen:"pronouns,omitempty"`
+	Viewer      *ActorDefs_ViewerState        `json:"viewer,omitempty" cborgen:"viewer,omitempty"`
+}
+
+// ActorDefs_ProfileViewBasic is a "profileViewBasic" in the app.vylet.actor.defs schema.
+type ActorDefs_ProfileViewBasic struct {
+	Avatar      *string                       `json:"avatar,omitempty" cborgen:"avatar,omitempty"`
+	CreatedAt   *string                       `json:"createdAt,omitempty" cborgen:"createdAt,omitempty"`
+	Did         string                        `json:"did" cborgen:"did"`
+	DisplayName *string                       `json:"displayName,omitempty" cborgen:"displayName,omitempty"`
+	Handle      string                        `json:"handle" cborgen:"handle"`
+	Labels      []*comatproto.LabelDefs_Label `json:"labels,omitempty" cborgen:"labels,omitempty"`
+	Pronouns    *string                       `json:"pronouns,omitempty" cborgen:"pronouns,omitempty"`
+	Viewer      *ActorDefs_ViewerState        `json:"viewer,omitempty" cborgen:"viewer,omitempty"`
+}
+
+// ActorDefs_ViewerState is a "viewerState" in the app.vylet.actor.defs schema.
+//
+// Metadata about the requesting account's relationship with the subject account. Only has meaningful content for authed requests.
+type ActorDefs_ViewerState struct {
+	BlockedBy  *bool   `json:"blockedBy,omitempty" cborgen:"blockedBy,omitempty"`
+	Blocking   *string `json:"blocking,omitempty" cborgen:"blocking,omitempty"`
+	FollowedBy *string `json:"followedBy,omitempty" cborgen:"followedBy,omitempty"`
+	Following  *string `json:"following,omitempty" cborgen:"following,omitempty"`
+	Muted      *bool   `json:"muted,omitempty" cborgen:"muted,omitempty"`
+}

api/vylet/actorprofile.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: app.vylet.actor.profile
+
+package vylet
+
+import (
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+func init() {
+	lexutil.RegisterType("app.vylet.actor.profile", &ActorProfile{})
+}
+
+type ActorProfile struct {
+	LexiconTypeID string `json:"$type" cborgen:"$type,const=app.vylet.actor.profile"`
+	// avatar: Small image to be displayed next to posts from account.
+	Avatar    *lexutil.LexBlob `json:"avatar,omitempty" cborgen:"avatar,omitempty"`
+	CreatedAt *string          `json:"createdAt,omitempty" cborgen:"createdAt,omitempty"`
+	// description: Free-form profile description text.
+	Description *string `json:"description,omitempty" cborgen:"description,omitempty"`
+	DisplayName *string `json:"displayName,omitempty" cborgen:"displayName,omitempty"`
+	// pronouns: Free-form pronouns text.
+	Pronouns *string `json:"pronouns,omitempty" cborgen:"pronouns,omitempty"`
+}

api/vylet/cbor_gen.go

···
+// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT.
+
+package vylet
+
+import (
+	"fmt"
+	"io"
+	"math"
+	"sort"
+
+	util "github.com/bluesky-social/indigo/lex/util"
+	cid "github.com/ipfs/go-cid"
+	cbg "github.com/whyrusleeping/cbor-gen"
+	xerrors "golang.org/x/xerrors"
+)
+
+var _ = xerrors.Errorf
+var _ = cid.Undef
+var _ = math.E
+var _ = sort.Sort
+
+func (t *ActorProfile) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+
+	cw := cbg.NewCborWriter(w)
+	fieldCount := 6
+
+	if t.Avatar == nil {
+		fieldCount--
+	}
+
+	if t.CreatedAt == nil {
+		fieldCount--
+	}
+
+	if t.Description == nil {
+		fieldCount--
+	}
+
+	if t.DisplayName == nil {
+		fieldCount--
+	}
+
+	if t.Pronouns == nil {
+		fieldCount--
+	}
+
+	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
+		return err
+	}
+
+	// t.LexiconTypeID (string) (string)
+	if len("$type") > 1000000 {
+		return xerrors.Errorf("Value in field \"$type\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("$type")); err != nil {
+		return err
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("app.vylet.actor.profile"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("app.vylet.actor.profile")); err != nil {
+		return err
+	}
+
+	// t.Avatar (util.LexBlob) (struct)
+	if t.Avatar != nil {
+
+		if len("avatar") > 1000000 {
+			return xerrors.Errorf("Value in field \"avatar\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("avatar"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("avatar")); err != nil {
+			return err
+		}
+
+		if err := t.Avatar.MarshalCBOR(cw); err != nil {
+			return err
+		}
+	}
+
+	// t.Pronouns (string) (string)
+	if t.Pronouns != nil {
+
+		if len("pronouns") > 1000000 {
+			return xerrors.Errorf("Value in field \"pronouns\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pronouns"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("pronouns")); err != nil {
+			return err
+		}
+
+		if t.Pronouns == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if len(*t.Pronouns) > 1000000 {
+				return xerrors.Errorf("Value in field t.Pronouns was too long")
+			}
+
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Pronouns))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(*t.Pronouns)); err != nil {
+				return err
+			}
+		}
+	}
+
+	// t.CreatedAt (string) (string)
+	if t.CreatedAt != nil {
+
+		if len("createdAt") > 1000000 {
+			return xerrors.Errorf("Value in field \"createdAt\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("createdAt")); err != nil {
+			return err
+		}
+
+		if t.CreatedAt == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if len(*t.CreatedAt) > 1000000 {
+				return xerrors.Errorf("Value in field t.CreatedAt was too long")
+			}
+
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.CreatedAt))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(*t.CreatedAt)); err != nil {
+				return err
+			}
+		}
+	}
+
+	// t.Description (string) (string)
+	if t.Description != nil {
+
+		if len("description") > 1000000 {
+			return xerrors.Errorf("Value in field \"description\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("description")); err != nil {
+			return err
+		}
+
+		if t.Description == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if len(*t.Description) > 1000000 {
+				return xerrors.Errorf("Value in field t.Description was too long")
+			}
+
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(*t.Description)); err != nil {
+				return err
+			}
+		}
+	}
+
+	// t.DisplayName (string) (string)
+	if t.DisplayName != nil {
+
+		if len("displayName") > 1000000 {
+			return xerrors.Errorf("Value in field \"displayName\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("displayName"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("displayName")); err != nil {
+			return err
+		}
+
+		if t.DisplayName == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if len(*t.DisplayName) > 1000000 {
+				return xerrors.Errorf("Value in field t.DisplayName was too long")
+			}
+
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.DisplayName))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(*t.DisplayName)); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func (t *ActorProfile) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = ActorProfile{}
+
+	cr := cbg.NewCborReader(r)
+
+	maj, extra, err := cr.ReadHeader()
+	if err != nil {
+		return err
+	}
+	defer func() {
+		if err == io.EOF {
+			err = io.ErrUnexpectedEOF
+		}
+	}()
+
+	if maj != cbg.MajMap {
+		return fmt.Errorf("cbor input should be of type map")
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("ActorProfile: map struct too large (%d)", extra)
+	}
+
+	n := extra
+
+	nameBuf := make([]byte, 11)
+	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
+
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
+				return err
+			}
+			continue
+		}
+
+		switch string(nameBuf[:nameLen]) {
+		// t.LexiconTypeID (string) (string)
+		case "$type":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.LexiconTypeID = string(sval)
+			}
+			// t.Avatar (util.LexBlob) (struct)
+		case "avatar":
+
+			{
+
+				b, err := cr.ReadByte()
+				if err != nil {
+					return err
+				}
+				if b != cbg.CborNull[0] {
+					if err := cr.UnreadByte(); err != nil {
+						return err
+					}
+					t.Avatar = new(util.LexBlob)
+					if err := t.Avatar.UnmarshalCBOR(cr); err != nil {
+						return xerrors.Errorf("unmarshaling t.Avatar pointer: %w", err)
+					}
+				}
+
+			}
+			// t.Pronouns (string) (string)
+		case "pronouns":
+
+			{
+				b, err := cr.ReadByte()
+				if err != nil {
+					return err
+				}
+				if b != cbg.CborNull[0] {
+					if err := cr.UnreadByte(); err != nil {
+						return err
+					}
+
+					sval, err := cbg.ReadStringWithMax(cr, 1000000)
+					if err != nil {
+						return err
+					}
+
+					t.Pronouns = (*string)(&sval)
+				}
+			}
+			// t.CreatedAt (string) (string)
+		case "createdAt":
+
+			{
+				b, err := cr.ReadByte()
+				if err != nil {
+					return err
+				}
+				if b != cbg.CborNull[0] {
+					if err := cr.UnreadByte(); err != nil {
+						return err
+					}
+
+					sval, err := cbg.ReadStringWithMax(cr, 1000000)
+					if err != nil {
+						return err
+					}
+
+					t.CreatedAt = (*string)(&sval)
+				}
+			}
+			// t.Description (string) (string)
+		case "description":
+
+			{
+				b, err := cr.ReadByte()
+				if err != nil {
+					return err
+				}
+				if b != cbg.CborNull[0] {
+					if err := cr.UnreadByte(); err != nil {
+						return err
+					}
+
+					sval, err := cbg.ReadStringWithMax(cr, 1000000)
+					if err != nil {
+						return err
+					}
+
+					t.Description = (*string)(&sval)
+				}
+			}
+			// t.DisplayName (string) (string)
+		case "displayName":
+
+			{
+				b, err := cr.ReadByte()
+				if err != nil {
+					return err
+				}
+				if b != cbg.CborNull[0] {
+					if err := cr.UnreadByte(); err != nil {
+						return err
+					}
+
+					sval, err := cbg.ReadStringWithMax(cr, 1000000)
+					if err != nil {
+						return err
+					}
+
+					t.DisplayName = (*string)(&sval)
+				}
+			}
+
+		default:
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}

cmd/lexgen/vylet.json

···
 [
   {
-    "package": "eloge",
-    "prefix": "app.eloge",
-    "outdir": "gen/vylet",
-    "import": "github.com/vylet-app/go/gen/vylet"
+    "package": "vylet",
+    "prefix": "app.vylet",
+    "outdir": "api/vylet",
+    "import": "github.com/vylet-app/go/api/vylet"
   },
   {
     "package": "atproto",
     "prefix": "com.atproto",
-    "outdir": "gen/atproto",
+    "outdir": "api/atproto",
     "import": "github.com/bluesky-social/indigo/api/atproto"
   }
 ]

gen/LICENSE

···
+MIT License Bluesky Social
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

gen/main.go

···
+package main
+
+import (
+	"reflect"
+
+	"github.com/bluesky-social/indigo/api/atproto"
+	"github.com/bluesky-social/indigo/mst"
+	"github.com/vylet-app/go/api/vylet"
+	cbg "github.com/whyrusleeping/cbor-gen"
+)
+
+func main() {
+	var typVals []any
+	for _, typ := range mst.CBORTypes() {
+		typVals = append(typVals, reflect.New(typ).Elem().Interface())
+	}
+
+	genCfg := cbg.Gen{
+		MaxStringLength: 1_000_000,
+	}
+
+	if err := genCfg.WriteMapEncodersToFile("api/vylet/cbor_gen.go", "vylet",
+		vylet.ActorProfile{},
+	); err != nil {
+		panic(err)
+	}
+
+	if err := genCfg.WriteMapEncodersToFile("api/atproto/cbor_gen.go", "atproto",
+		atproto.RepoStrongRef{},
+	); err != nil {
+		panic(err)
+	}
+}

justfile

···
 
 lexgen:
 	go run ./cmd/lexgen/ --build-file cmd/lexgen/vylet.json {{lexdir}}
+
+cborgen:
+	go run ./gen