api/tangled: lexgen

Signed-off-by: Seongmin Lee <[e-mail]>

api/tangled/actorprofile.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.actor.profile
 
-// schema: sh.tangled.actor.profile
+package tangled
 
 import (
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 )
 
 func init() {
-	util.RegisterType("sh.tangled.actor.profile", &ActorProfile{})
-} //
-// RECORDTYPE: ActorProfile
+	lexutil.RegisterType("sh.tangled.actor.profile", &ActorProfile{})
+}
+
 type ActorProfile struct {
-	LexiconTypeID string `json:"$type,const=sh.tangled.actor.profile" cborgen:"$type,const=sh.tangled.actor.profile"`
+	LexiconTypeID string `json:"$type" cborgen:"$type,const=sh.tangled.actor.profile"`
 	// bluesky: Include link to this account on Bluesky.
 	Bluesky bool `json:"bluesky" cborgen:"bluesky"`
 	// description: Free-form profile description text.

api/tangled/feedreaction.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.feed.reaction
 
-// schema: sh.tangled.feed.reaction
+package tangled
 
 import (
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 )
 
 func init() {
-	util.RegisterType("sh.tangled.feed.reaction", &FeedReaction{})
-} //
-// RECORDTYPE: FeedReaction
+	lexutil.RegisterType("sh.tangled.feed.reaction", &FeedReaction{})
+}
+
 type FeedReaction struct {
-	LexiconTypeID string `json:"$type,const=sh.tangled.feed.reaction" cborgen:"$type,const=sh.tangled.feed.reaction"`
+	LexiconTypeID string `json:"$type" cborgen:"$type,const=sh.tangled.feed.reaction"`
 	CreatedAt     string `json:"createdAt" cborgen:"createdAt"`
 	Reaction      string `json:"reaction" cborgen:"reaction"`
 	Subject       string `json:"subject" cborgen:"subject"`

api/tangled/feedstar.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.feed.star
 
-// schema: sh.tangled.feed.star
+package tangled
 
 import (
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 )
 
 func init() {
-	util.RegisterType("sh.tangled.feed.star", &FeedStar{})
-} //
-// RECORDTYPE: FeedStar
+	lexutil.RegisterType("sh.tangled.feed.star", &FeedStar{})
+}
+
 type FeedStar struct {
-	LexiconTypeID string `json:"$type,const=sh.tangled.feed.star" cborgen:"$type,const=sh.tangled.feed.star"`
+	LexiconTypeID string `json:"$type" cborgen:"$type,const=sh.tangled.feed.star"`
 	CreatedAt     string `json:"createdAt" cborgen:"createdAt"`
 	Subject       string `json:"subject" cborgen:"subject"`
 }

api/tangled/gitrefUpdate.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.git.refUpdate
 
-// schema: sh.tangled.git.refUpdate
+package tangled
 
 import (
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 )
 
 func init() {
-	util.RegisterType("sh.tangled.git.refUpdate", &GitRefUpdate{})
-} //
-// RECORDTYPE: GitRefUpdate
+	lexutil.RegisterType("sh.tangled.git.refUpdate", &GitRefUpdate{})
+}
+
 type GitRefUpdate struct {
-	LexiconTypeID string `json:"$type,const=sh.tangled.git.refUpdate" cborgen:"$type,const=sh.tangled.git.refUpdate"`
+	LexiconTypeID string `json:"$type" cborgen:"$type,const=sh.tangled.git.refUpdate"`
 	// committerDid: did of the user that pushed this ref
 	CommitterDid string             `json:"committerDid" cborgen:"committerDid"`
 	Meta         *GitRefUpdate_Meta `json:"meta" cborgen:"meta"`

api/tangled/graphfollow.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.graph.follow
 
-// schema: sh.tangled.graph.follow
+package tangled
 
 import (
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 )
 
 func init() {
-	util.RegisterType("sh.tangled.graph.follow", &GraphFollow{})
-} //
-// RECORDTYPE: GraphFollow
+	lexutil.RegisterType("sh.tangled.graph.follow", &GraphFollow{})
+}
+
 type GraphFollow struct {
-	LexiconTypeID string `json:"$type,const=sh.tangled.graph.follow" cborgen:"$type,const=sh.tangled.graph.follow"`
+	LexiconTypeID string `json:"$type" cborgen:"$type,const=sh.tangled.graph.follow"`
 	CreatedAt     string `json:"createdAt" cborgen:"createdAt"`
 	Subject       string `json:"subject" cborgen:"subject"`
 }

api/tangled/issuecomment.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo.issue.comment
 
-// schema: sh.tangled.repo.issue.comment
+package tangled
 
 import (
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 )
 
 func init() {
-	util.RegisterType("sh.tangled.repo.issue.comment", &RepoIssueComment{})
-} //
-// RECORDTYPE: RepoIssueComment
+	lexutil.RegisterType("sh.tangled.repo.issue.comment", &RepoIssueComment{})
+}
+
 type RepoIssueComment struct {
-	LexiconTypeID string   `json:"$type,const=sh.tangled.repo.issue.comment" cborgen:"$type,const=sh.tangled.repo.issue.comment"`
+	LexiconTypeID string   `json:"$type" cborgen:"$type,const=sh.tangled.repo.issue.comment"`
 	Body          string   `json:"body" cborgen:"body"`
 	CreatedAt     string   `json:"createdAt" cborgen:"createdAt"`
 	Issue         string   `json:"issue" cborgen:"issue"`

api/tangled/issuestate.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo.issue.state
 
-// schema: sh.tangled.repo.issue.state
+package tangled
 
 import (
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 )
 
 func init() {
-	util.RegisterType("sh.tangled.repo.issue.state", &RepoIssueState{})
-} //
-// RECORDTYPE: RepoIssueState
+	lexutil.RegisterType("sh.tangled.repo.issue.state", &RepoIssueState{})
+}
+
 type RepoIssueState struct {
-	LexiconTypeID string `json:"$type,const=sh.tangled.repo.issue.state" cborgen:"$type,const=sh.tangled.repo.issue.state"`
+	LexiconTypeID string `json:"$type" cborgen:"$type,const=sh.tangled.repo.issue.state"`
 	Issue         string `json:"issue" cborgen:"issue"`
 	// state: state of the issue
 	State string `json:"state" cborgen:"state"`

api/tangled/knotlistKeys.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.knot.listKeys
 
-// schema: sh.tangled.knot.listKeys
+package tangled
 
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 //
 // cursor: Pagination cursor
 // limit: Maximum number of keys to return
-func KnotListKeys(ctx context.Context, c util.LexClient, cursor string, limit int64) (*KnotListKeys_Output, error) {
+func KnotListKeys(ctx context.Context, c lexutil.LexClient, cursor string, limit int64) (*KnotListKeys_Output, error) {
 	var out KnotListKeys_Output
 
 	params := map[string]interface{}{}
···
 	if limit != 0 {
 		params["limit"] = limit
 	}
-	if err := c.LexDo(ctx, util.Query, "", "sh.tangled.knot.listKeys", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, lexutil.Query, "", "sh.tangled.knot.listKeys", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/tangled/knotmember.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.knot.member
 
-// schema: sh.tangled.knot.member
+package tangled
 
 import (
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 )
 
 func init() {
-	util.RegisterType("sh.tangled.knot.member", &KnotMember{})
-} //
-// RECORDTYPE: KnotMember
+	lexutil.RegisterType("sh.tangled.knot.member", &KnotMember{})
+}
+
 type KnotMember struct {
-	LexiconTypeID string `json:"$type,const=sh.tangled.knot.member" cborgen:"$type,const=sh.tangled.knot.member"`
+	LexiconTypeID string `json:"$type" cborgen:"$type,const=sh.tangled.knot.member"`
 	CreatedAt     string `json:"createdAt" cborgen:"createdAt"`
 	// domain: domain that this member now belongs to
 	Domain  string `json:"domain" cborgen:"domain"`

api/tangled/knotversion.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.knot.version
 
-// schema: sh.tangled.knot.version
+package tangled
 
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 }
 
 // KnotVersion calls the XRPC method "sh.tangled.knot.version".
-func KnotVersion(ctx context.Context, c util.LexClient) (*KnotVersion_Output, error) {
+func KnotVersion(ctx context.Context, c lexutil.LexClient) (*KnotVersion_Output, error) {
 	var out KnotVersion_Output
-	if err := c.LexDo(ctx, util.Query, "", "sh.tangled.knot.version", nil, nil, &out); err != nil {
+	if err := c.LexDo(ctx, lexutil.Query, "", "sh.tangled.knot.version", nil, nil, &out); err != nil {
 		return nil, err
 	}
 

api/tangled/labeldefinition.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.label.definition
 
-// schema: sh.tangled.label.definition
+package tangled
 
 import (
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 )
 
 func init() {
-	util.RegisterType("sh.tangled.label.definition", &LabelDefinition{})
-} //
-// RECORDTYPE: LabelDefinition
+	lexutil.RegisterType("sh.tangled.label.definition", &LabelDefinition{})
+}
+
 type LabelDefinition struct {
-	LexiconTypeID string `json:"$type,const=sh.tangled.label.definition" cborgen:"$type,const=sh.tangled.label.definition"`
+	LexiconTypeID string `json:"$type" cborgen:"$type,const=sh.tangled.label.definition"`
 	// color: The hex value for the background color for the label. Appviews may choose to respect this.
 	Color     *string `json:"color,omitempty" cborgen:"color,omitempty"`
 	CreatedAt string  `json:"createdAt" cborgen:"createdAt"`

api/tangled/labelop.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.label.op
 
-// schema: sh.tangled.label.op
+package tangled
 
 import (
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 )
 
 func init() {
-	util.RegisterType("sh.tangled.label.op", &LabelOp{})
-} //
-// RECORDTYPE: LabelOp
+	lexutil.RegisterType("sh.tangled.label.op", &LabelOp{})
+}
+
 type LabelOp struct {
-	LexiconTypeID string             `json:"$type,const=sh.tangled.label.op" cborgen:"$type,const=sh.tangled.label.op"`
+	LexiconTypeID string             `json:"$type" cborgen:"$type,const=sh.tangled.label.op"`
 	Add           []*LabelOp_Operand `json:"add" cborgen:"add"`
 	Delete        []*LabelOp_Operand `json:"delete" cborgen:"delete"`
 	PerformedAt   string             `json:"performedAt" cborgen:"performedAt"`

api/tangled/pipelinecancelPipeline.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.pipeline.cancelPipeline
 
-// schema: sh.tangled.pipeline.cancelPipeline
+package tangled
 
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 }
 
 // PipelineCancelPipeline calls the XRPC method "sh.tangled.pipeline.cancelPipeline".
-func PipelineCancelPipeline(ctx context.Context, c util.LexClient, input *PipelineCancelPipeline_Input) error {
-	if err := c.LexDo(ctx, util.Procedure, "application/json", "sh.tangled.pipeline.cancelPipeline", nil, input, nil); err != nil {
+func PipelineCancelPipeline(ctx context.Context, c lexutil.LexClient, input *PipelineCancelPipeline_Input) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "sh.tangled.pipeline.cancelPipeline", nil, input, nil); err != nil {
 		return err
 	}
 

api/tangled/pipelinestatus.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.pipeline.status
 
-// schema: sh.tangled.pipeline.status
+package tangled
 
 import (
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 )
 
 func init() {
-	util.RegisterType("sh.tangled.pipeline.status", &PipelineStatus{})
-} //
-// RECORDTYPE: PipelineStatus
+	lexutil.RegisterType("sh.tangled.pipeline.status", &PipelineStatus{})
+}
+
 type PipelineStatus struct {
-	LexiconTypeID string `json:"$type,const=sh.tangled.pipeline.status" cborgen:"$type,const=sh.tangled.pipeline.status"`
+	LexiconTypeID string `json:"$type" cborgen:"$type,const=sh.tangled.pipeline.status"`
 	// createdAt: time of creation of this status update
 	CreatedAt string `json:"createdAt" cborgen:"createdAt"`
 	// error: error message if failed

api/tangled/pullcomment.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo.pull.comment
 
-// schema: sh.tangled.repo.pull.comment
+package tangled
 
 import (
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 )
 
 func init() {
-	util.RegisterType("sh.tangled.repo.pull.comment", &RepoPullComment{})
-} //
-// RECORDTYPE: RepoPullComment
+	lexutil.RegisterType("sh.tangled.repo.pull.comment", &RepoPullComment{})
+}
+
 type RepoPullComment struct {
-	LexiconTypeID string   `json:"$type,const=sh.tangled.repo.pull.comment" cborgen:"$type,const=sh.tangled.repo.pull.comment"`
+	LexiconTypeID string   `json:"$type" cborgen:"$type,const=sh.tangled.repo.pull.comment"`
 	Body          string   `json:"body" cborgen:"body"`
 	CreatedAt     string   `json:"createdAt" cborgen:"createdAt"`
 	Mentions      []string `json:"mentions,omitempty" cborgen:"mentions,omitempty"`

api/tangled/pullstatus.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo.pull.status
 
-// schema: sh.tangled.repo.pull.status
+package tangled
 
 import (
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 )
 
 func init() {
-	util.RegisterType("sh.tangled.repo.pull.status", &RepoPullStatus{})
-} //
-// RECORDTYPE: RepoPullStatus
+	lexutil.RegisterType("sh.tangled.repo.pull.status", &RepoPullStatus{})
+}
+
 type RepoPullStatus struct {
-	LexiconTypeID string `json:"$type,const=sh.tangled.repo.pull.status" cborgen:"$type,const=sh.tangled.repo.pull.status"`
+	LexiconTypeID string `json:"$type" cborgen:"$type,const=sh.tangled.repo.pull.status"`
 	Pull          string `json:"pull" cborgen:"pull"`
 	// status: status of the pull request
 	Status string `json:"status" cborgen:"status"`

api/tangled/repoaddSecret.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo.addSecret
 
-// schema: sh.tangled.repo.addSecret
+package tangled
 
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 }
 
 // RepoAddSecret calls the XRPC method "sh.tangled.repo.addSecret".
-func RepoAddSecret(ctx context.Context, c util.LexClient, input *RepoAddSecret_Input) error {
-	if err := c.LexDo(ctx, util.Procedure, "application/json", "sh.tangled.repo.addSecret", nil, input, nil); err != nil {
+func RepoAddSecret(ctx context.Context, c lexutil.LexClient, input *RepoAddSecret_Input) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "sh.tangled.repo.addSecret", nil, input, nil); err != nil {
 		return err
 	}
 

api/tangled/repoarchive.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo.archive
 
-// schema: sh.tangled.repo.archive
+package tangled
 
 import (
 	"bytes"
 	"context"
 
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 // prefix: Prefix for files in the archive
 // ref: Git reference (branch, tag, or commit SHA)
 // repo: Repository identifier in format 'did:plc:.../repoName'
-func RepoArchive(ctx context.Context, c util.LexClient, format string, prefix string, ref string, repo string) ([]byte, error) {
+func RepoArchive(ctx context.Context, c lexutil.LexClient, format string, prefix string, ref string, repo string) ([]byte, error) {
 	buf := new(bytes.Buffer)
 
 	params := map[string]interface{}{}
···
 	}
 	params["ref"] = ref
 	params["repo"] = repo
-	if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.archive", params, nil, buf); err != nil {
+	if err := c.LexDo(ctx, lexutil.Query, "", "sh.tangled.repo.archive", params, nil, buf); err != nil {
 		return nil, err
 	}
 

api/tangled/repoartifact.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
+// Lexicon schema: sh.tangled.repo.artifact
+
 package tangled
 
-// schema: sh.tangled.repo.artifact
-
 import (
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 )
 
 func init() {
-	util.RegisterType("sh.tangled.repo.artifact", &RepoArtifact{})
-} //
-// RECORDTYPE: RepoArtifact
+	lexutil.RegisterType("sh.tangled.repo.artifact", &RepoArtifact{})
+}
+
 type RepoArtifact struct {
-	LexiconTypeID string `json:"$type,const=sh.tangled.repo.artifact" cborgen:"$type,const=sh.tangled.repo.artifact"`
+	LexiconTypeID string `json:"$type" cborgen:"$type,const=sh.tangled.repo.artifact"`
 	// artifact: the artifact
-	Artifact *util.LexBlob `json:"artifact" cborgen:"artifact"`
+	Artifact *lexutil.LexBlob `json:"artifact" cborgen:"artifact"`
 	// createdAt: time of creation of this artifact
 	CreatedAt string `json:"createdAt" cborgen:"createdAt"`
 	// name: name of the artifact
···
 	// repo: repo that this artifact is being uploaded to
 	Repo string `json:"repo" cborgen:"repo"`
 	// tag: hash of the tag object that this artifact is attached to (only annotated tags are supported)
-	Tag util.LexBytes `json:"tag,omitempty" cborgen:"tag,omitempty"`
+	Tag lexutil.LexBytes `json:"tag,omitempty" cborgen:"tag,omitempty"`
 }

api/tangled/repoblob.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo.blob
 
-// schema: sh.tangled.repo.blob
+package tangled
 
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 // raw: Return raw file content instead of JSON response
 // ref: Git reference (branch, tag, or commit SHA)
 // repo: Repository identifier in format 'did:plc:.../repoName'
-func RepoBlob(ctx context.Context, c util.LexClient, path string, raw bool, ref string, repo string) (*RepoBlob_Output, error) {
+func RepoBlob(ctx context.Context, c lexutil.LexClient, path string, raw bool, ref string, repo string) (*RepoBlob_Output, error) {
 	var out RepoBlob_Output
 
 	params := map[string]interface{}{}
···
 	}
 	params["ref"] = ref
 	params["repo"] = repo
-	if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.blob", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, lexutil.Query, "", "sh.tangled.repo.blob", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/tangled/repobranch.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo.branch
 
-// schema: sh.tangled.repo.branch
+package tangled
 
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 //
 // name: Branch name to get information for
 // repo: Repository identifier in format 'did:plc:.../repoName'
-func RepoBranch(ctx context.Context, c util.LexClient, name string, repo string) (*RepoBranch_Output, error) {
+func RepoBranch(ctx context.Context, c lexutil.LexClient, name string, repo string) (*RepoBranch_Output, error) {
 	var out RepoBranch_Output
 
 	params := map[string]interface{}{}
 	params["name"] = name
 	params["repo"] = repo
-	if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.branch", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, lexutil.Query, "", "sh.tangled.repo.branch", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/tangled/repobranches.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo.branches
 
-// schema: sh.tangled.repo.branches
+package tangled
 
 import (
 	"bytes"
 	"context"
 
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 // cursor: Pagination cursor
 // limit: Maximum number of branches to return
 // repo: Repository identifier in format 'did:plc:.../repoName'
-func RepoBranches(ctx context.Context, c util.LexClient, cursor string, limit int64, repo string) ([]byte, error) {
+func RepoBranches(ctx context.Context, c lexutil.LexClient, cursor string, limit int64, repo string) ([]byte, error) {
 	buf := new(bytes.Buffer)
 
 	params := map[string]interface{}{}
···
 		params["limit"] = limit
 	}
 	params["repo"] = repo
-	if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.branches", params, nil, buf); err != nil {
+	if err := c.LexDo(ctx, lexutil.Query, "", "sh.tangled.repo.branches", params, nil, buf); err != nil {
 		return nil, err
 	}
 

api/tangled/repocollaborator.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo.collaborator
 
-// schema: sh.tangled.repo.collaborator
+package tangled
 
 import (
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 )
 
 func init() {
-	util.RegisterType("sh.tangled.repo.collaborator", &RepoCollaborator{})
-} //
-// RECORDTYPE: RepoCollaborator
+	lexutil.RegisterType("sh.tangled.repo.collaborator", &RepoCollaborator{})
+}
+
 type RepoCollaborator struct {
-	LexiconTypeID string `json:"$type,const=sh.tangled.repo.collaborator" cborgen:"$type,const=sh.tangled.repo.collaborator"`
+	LexiconTypeID string `json:"$type" cborgen:"$type,const=sh.tangled.repo.collaborator"`
 	CreatedAt     string `json:"createdAt" cborgen:"createdAt"`
 	// repo: repo to add this user to
 	Repo    string `json:"repo" cborgen:"repo"`

api/tangled/repocompare.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo.compare
 
-// schema: sh.tangled.repo.compare
+package tangled
 
 import (
 	"bytes"
 	"context"
 
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 // repo: Repository identifier in format 'did:plc:.../repoName'
 // rev1: First revision (commit, branch, or tag)
 // rev2: Second revision (commit, branch, or tag)
-func RepoCompare(ctx context.Context, c util.LexClient, repo string, rev1 string, rev2 string) ([]byte, error) {
+func RepoCompare(ctx context.Context, c lexutil.LexClient, repo string, rev1 string, rev2 string) ([]byte, error) {
 	buf := new(bytes.Buffer)
 
 	params := map[string]interface{}{}
 	params["repo"] = repo
 	params["rev1"] = rev1
 	params["rev2"] = rev2
-	if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.compare", params, nil, buf); err != nil {
+	if err := c.LexDo(ctx, lexutil.Query, "", "sh.tangled.repo.compare", params, nil, buf); err != nil {
 		return nil, err
 	}
 

api/tangled/repocreate.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo.create
 
-// schema: sh.tangled.repo.create
+package tangled
 
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 }
 
 // RepoCreate calls the XRPC method "sh.tangled.repo.create".
-func RepoCreate(ctx context.Context, c util.LexClient, input *RepoCreate_Input) error {
-	if err := c.LexDo(ctx, util.Procedure, "application/json", "sh.tangled.repo.create", nil, input, nil); err != nil {
+func RepoCreate(ctx context.Context, c lexutil.LexClient, input *RepoCreate_Input) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "sh.tangled.repo.create", nil, input, nil); err != nil {
 		return err
 	}
 

api/tangled/repodelete.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo.delete
 
-// schema: sh.tangled.repo.delete
+package tangled
 
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 }
 
 // RepoDelete calls the XRPC method "sh.tangled.repo.delete".
-func RepoDelete(ctx context.Context, c util.LexClient, input *RepoDelete_Input) error {
-	if err := c.LexDo(ctx, util.Procedure, "application/json", "sh.tangled.repo.delete", nil, input, nil); err != nil {
+func RepoDelete(ctx context.Context, c lexutil.LexClient, input *RepoDelete_Input) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "sh.tangled.repo.delete", nil, input, nil); err != nil {
 		return err
 	}
 

api/tangled/repodeleteBranch.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo.deleteBranch
 
-// schema: sh.tangled.repo.deleteBranch
+package tangled
 
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 }
 
 // RepoDeleteBranch calls the XRPC method "sh.tangled.repo.deleteBranch".
-func RepoDeleteBranch(ctx context.Context, c util.LexClient, input *RepoDeleteBranch_Input) error {
-	if err := c.LexDo(ctx, util.Procedure, "application/json", "sh.tangled.repo.deleteBranch", nil, input, nil); err != nil {
+func RepoDeleteBranch(ctx context.Context, c lexutil.LexClient, input *RepoDeleteBranch_Input) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "sh.tangled.repo.deleteBranch", nil, input, nil); err != nil {
 		return err
 	}
 

api/tangled/repodiff.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo.diff
 
-// schema: sh.tangled.repo.diff
+package tangled
 
 import (
 	"bytes"
 	"context"
 
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 //
 // ref: Git reference (branch, tag, or commit SHA)
 // repo: Repository identifier in format 'did:plc:.../repoName'
-func RepoDiff(ctx context.Context, c util.LexClient, ref string, repo string) ([]byte, error) {
+func RepoDiff(ctx context.Context, c lexutil.LexClient, ref string, repo string) ([]byte, error) {
 	buf := new(bytes.Buffer)
 
 	params := map[string]interface{}{}
 	params["ref"] = ref
 	params["repo"] = repo
-	if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.diff", params, nil, buf); err != nil {
+	if err := c.LexDo(ctx, lexutil.Query, "", "sh.tangled.repo.diff", params, nil, buf); err != nil {
 		return nil, err
 	}
 

api/tangled/repoforkStatus.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo.forkStatus
 
-// schema: sh.tangled.repo.forkStatus
+package tangled
 
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 }
 
 // RepoForkStatus calls the XRPC method "sh.tangled.repo.forkStatus".
-func RepoForkStatus(ctx context.Context, c util.LexClient, input *RepoForkStatus_Input) (*RepoForkStatus_Output, error) {
+func RepoForkStatus(ctx context.Context, c lexutil.LexClient, input *RepoForkStatus_Input) (*RepoForkStatus_Output, error) {
 	var out RepoForkStatus_Output
-	if err := c.LexDo(ctx, util.Procedure, "application/json", "sh.tangled.repo.forkStatus", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "sh.tangled.repo.forkStatus", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/tangled/repoforkSync.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo.forkSync
 
-// schema: sh.tangled.repo.forkSync
+package tangled
 
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 }
 
 // RepoForkSync calls the XRPC method "sh.tangled.repo.forkSync".
-func RepoForkSync(ctx context.Context, c util.LexClient, input *RepoForkSync_Input) error {
-	if err := c.LexDo(ctx, util.Procedure, "application/json", "sh.tangled.repo.forkSync", nil, input, nil); err != nil {
+func RepoForkSync(ctx context.Context, c lexutil.LexClient, input *RepoForkSync_Input) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "sh.tangled.repo.forkSync", nil, input, nil); err != nil {
 		return err
 	}
 

api/tangled/repogetDefaultBranch.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo.getDefaultBranch
 
-// schema: sh.tangled.repo.getDefaultBranch
+package tangled
 
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 // RepoGetDefaultBranch calls the XRPC method "sh.tangled.repo.getDefaultBranch".
 //
 // repo: Repository identifier in format 'did:plc:.../repoName'
-func RepoGetDefaultBranch(ctx context.Context, c util.LexClient, repo string) (*RepoGetDefaultBranch_Output, error) {
+func RepoGetDefaultBranch(ctx context.Context, c lexutil.LexClient, repo string) (*RepoGetDefaultBranch_Output, error) {
 	var out RepoGetDefaultBranch_Output
 
 	params := map[string]interface{}{}
 	params["repo"] = repo
-	if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.getDefaultBranch", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, lexutil.Query, "", "sh.tangled.repo.getDefaultBranch", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/tangled/repohiddenRef.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo.hiddenRef
 
-// schema: sh.tangled.repo.hiddenRef
+package tangled
 
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 }
 
 // RepoHiddenRef calls the XRPC method "sh.tangled.repo.hiddenRef".
-func RepoHiddenRef(ctx context.Context, c util.LexClient, input *RepoHiddenRef_Input) (*RepoHiddenRef_Output, error) {
+func RepoHiddenRef(ctx context.Context, c lexutil.LexClient, input *RepoHiddenRef_Input) (*RepoHiddenRef_Output, error) {
 	var out RepoHiddenRef_Output
-	if err := c.LexDo(ctx, util.Procedure, "application/json", "sh.tangled.repo.hiddenRef", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "sh.tangled.repo.hiddenRef", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/tangled/repoissue.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo.issue
 
-// schema: sh.tangled.repo.issue
+package tangled
 
 import (
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 )
 
 func init() {
-	util.RegisterType("sh.tangled.repo.issue", &RepoIssue{})
-} //
-// RECORDTYPE: RepoIssue
+	lexutil.RegisterType("sh.tangled.repo.issue", &RepoIssue{})
+}
+
 type RepoIssue struct {
-	LexiconTypeID string   `json:"$type,const=sh.tangled.repo.issue" cborgen:"$type,const=sh.tangled.repo.issue"`
+	LexiconTypeID string   `json:"$type" cborgen:"$type,const=sh.tangled.repo.issue"`
 	Body          *string  `json:"body,omitempty" cborgen:"body,omitempty"`
 	CreatedAt     string   `json:"createdAt" cborgen:"createdAt"`
 	Mentions      []string `json:"mentions,omitempty" cborgen:"mentions,omitempty"`

api/tangled/repolanguages.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo.languages
 
-// schema: sh.tangled.repo.languages
+package tangled
 
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 //
 // ref: Git reference (branch, tag, or commit SHA)
 // repo: Repository identifier in format 'did:plc:.../repoName'
-func RepoLanguages(ctx context.Context, c util.LexClient, ref string, repo string) (*RepoLanguages_Output, error) {
+func RepoLanguages(ctx context.Context, c lexutil.LexClient, ref string, repo string) (*RepoLanguages_Output, error) {
 	var out RepoLanguages_Output
 
 	params := map[string]interface{}{}
···
 		params["ref"] = ref
 	}
 	params["repo"] = repo
-	if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.languages", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, lexutil.Query, "", "sh.tangled.repo.languages", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/tangled/repolistSecrets.go

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

api/tangled/repolog.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo.log
 
-// schema: sh.tangled.repo.log
+package tangled
 
 import (
 	"bytes"
 	"context"
 
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 // path: Path to filter commits by
 // ref: Git reference (branch, tag, or commit SHA)
 // repo: Repository identifier in format 'did:plc:.../repoName'
-func RepoLog(ctx context.Context, c util.LexClient, cursor string, limit int64, path string, ref string, repo string) ([]byte, error) {
+func RepoLog(ctx context.Context, c lexutil.LexClient, cursor string, limit int64, path string, ref string, repo string) ([]byte, error) {
 	buf := new(bytes.Buffer)
 
 	params := map[string]interface{}{}
···
 	}
 	params["ref"] = ref
 	params["repo"] = repo
-	if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.log", params, nil, buf); err != nil {
+	if err := c.LexDo(ctx, lexutil.Query, "", "sh.tangled.repo.log", params, nil, buf); err != nil {
 		return nil, err
 	}
 

api/tangled/repomerge.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo.merge
 
-// schema: sh.tangled.repo.merge
+package tangled
 
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 }
 
 // RepoMerge calls the XRPC method "sh.tangled.repo.merge".
-func RepoMerge(ctx context.Context, c util.LexClient, input *RepoMerge_Input) error {
-	if err := c.LexDo(ctx, util.Procedure, "application/json", "sh.tangled.repo.merge", nil, input, nil); err != nil {
+func RepoMerge(ctx context.Context, c lexutil.LexClient, input *RepoMerge_Input) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "sh.tangled.repo.merge", nil, input, nil); err != nil {
 		return err
 	}
 

api/tangled/repomergeCheck.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo.mergeCheck
 
-// schema: sh.tangled.repo.mergeCheck
+package tangled
 
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 }
 
 // RepoMergeCheck calls the XRPC method "sh.tangled.repo.mergeCheck".
-func RepoMergeCheck(ctx context.Context, c util.LexClient, input *RepoMergeCheck_Input) (*RepoMergeCheck_Output, error) {
+func RepoMergeCheck(ctx context.Context, c lexutil.LexClient, input *RepoMergeCheck_Input) (*RepoMergeCheck_Output, error) {
 	var out RepoMergeCheck_Output
-	if err := c.LexDo(ctx, util.Procedure, "application/json", "sh.tangled.repo.mergeCheck", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "sh.tangled.repo.mergeCheck", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/tangled/repopull.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo.pull
 
-// schema: sh.tangled.repo.pull
+package tangled
 
 import (
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 )
 
 func init() {
-	util.RegisterType("sh.tangled.repo.pull", &RepoPull{})
-} //
-// RECORDTYPE: RepoPull
+	lexutil.RegisterType("sh.tangled.repo.pull", &RepoPull{})
+}
+
 type RepoPull struct {
-	LexiconTypeID string   `json:"$type,const=sh.tangled.repo.pull" cborgen:"$type,const=sh.tangled.repo.pull"`
+	LexiconTypeID string   `json:"$type" cborgen:"$type,const=sh.tangled.repo.pull"`
 	Body          *string  `json:"body,omitempty" cborgen:"body,omitempty"`
 	CreatedAt     string   `json:"createdAt" cborgen:"createdAt"`
 	Mentions      []string `json:"mentions,omitempty" cborgen:"mentions,omitempty"`
 	// patch: (deprecated) use patchBlob instead
 	Patch *string `json:"patch,omitempty" cborgen:"patch,omitempty"`
 	// patchBlob: patch content
-	PatchBlob  *util.LexBlob    `json:"patchBlob" cborgen:"patchBlob"`
+	PatchBlob  *lexutil.LexBlob `json:"patchBlob" cborgen:"patchBlob"`
 	References []string         `json:"references,omitempty" cborgen:"references,omitempty"`
 	Source     *RepoPull_Source `json:"source,omitempty" cborgen:"source,omitempty"`
 	Target     *RepoPull_Target `json:"target" cborgen:"target"`

api/tangled/reporemoveSecret.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo.removeSecret
 
-// schema: sh.tangled.repo.removeSecret
+package tangled
 
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 }
 
 // RepoRemoveSecret calls the XRPC method "sh.tangled.repo.removeSecret".
-func RepoRemoveSecret(ctx context.Context, c util.LexClient, input *RepoRemoveSecret_Input) error {
-	if err := c.LexDo(ctx, util.Procedure, "application/json", "sh.tangled.repo.removeSecret", nil, input, nil); err != nil {
+func RepoRemoveSecret(ctx context.Context, c lexutil.LexClient, input *RepoRemoveSecret_Input) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "sh.tangled.repo.removeSecret", nil, input, nil); err != nil {
 		return err
 	}
 

api/tangled/reposetDefaultBranch.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo.setDefaultBranch
 
-// schema: sh.tangled.repo.setDefaultBranch
+package tangled
 
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 }
 
 // RepoSetDefaultBranch calls the XRPC method "sh.tangled.repo.setDefaultBranch".
-func RepoSetDefaultBranch(ctx context.Context, c util.LexClient, input *RepoSetDefaultBranch_Input) error {
-	if err := c.LexDo(ctx, util.Procedure, "application/json", "sh.tangled.repo.setDefaultBranch", nil, input, nil); err != nil {
+func RepoSetDefaultBranch(ctx context.Context, c lexutil.LexClient, input *RepoSetDefaultBranch_Input) error {
+	if err := c.LexDo(ctx, lexutil.Procedure, "application/json", "sh.tangled.repo.setDefaultBranch", nil, input, nil); err != nil {
 		return err
 	}
 

api/tangled/repotags.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo.tags
 
-// schema: sh.tangled.repo.tags
+package tangled
 
 import (
 	"bytes"
 	"context"
 
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 // cursor: Pagination cursor
 // limit: Maximum number of tags to return
 // repo: Repository identifier in format 'did:plc:.../repoName'
-func RepoTags(ctx context.Context, c util.LexClient, cursor string, limit int64, repo string) ([]byte, error) {
+func RepoTags(ctx context.Context, c lexutil.LexClient, cursor string, limit int64, repo string) ([]byte, error) {
 	buf := new(bytes.Buffer)
 
 	params := map[string]interface{}{}
···
 		params["limit"] = limit
 	}
 	params["repo"] = repo
-	if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.tags", params, nil, buf); err != nil {
+	if err := c.LexDo(ctx, lexutil.Query, "", "sh.tangled.repo.tags", params, nil, buf); err != nil {
 		return nil, err
 	}
 

api/tangled/repotree.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo.tree
 
-// schema: sh.tangled.repo.tree
+package tangled
 
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 // path: Path within the repository tree
 // ref: Git reference (branch, tag, or commit SHA)
 // repo: Repository identifier in format 'did:plc:.../repoName'
-func RepoTree(ctx context.Context, c util.LexClient, path string, ref string, repo string) (*RepoTree_Output, error) {
+func RepoTree(ctx context.Context, c lexutil.LexClient, path string, ref string, repo string) (*RepoTree_Output, error) {
 	var out RepoTree_Output
 
 	params := map[string]interface{}{}
···
 	}
 	params["ref"] = ref
 	params["repo"] = repo
-	if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.tree", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, lexutil.Query, "", "sh.tangled.repo.tree", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/tangled/spindlemember.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.spindle.member
 
-// schema: sh.tangled.spindle.member
+package tangled
 
 import (
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 )
 
 func init() {
-	util.RegisterType("sh.tangled.spindle.member", &SpindleMember{})
-} //
-// RECORDTYPE: SpindleMember
+	lexutil.RegisterType("sh.tangled.spindle.member", &SpindleMember{})
+}
+
 type SpindleMember struct {
-	LexiconTypeID string `json:"$type,const=sh.tangled.spindle.member" cborgen:"$type,const=sh.tangled.spindle.member"`
+	LexiconTypeID string `json:"$type" cborgen:"$type,const=sh.tangled.spindle.member"`
 	CreatedAt     string `json:"createdAt" cborgen:"createdAt"`
 	// instance: spindle instance that the subject is now a member of
 	Instance string `json:"instance" cborgen:"instance"`

api/tangled/stateclosed.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo.issue.state.closed
 
-// schema: sh.tangled.repo.issue.state.closed
+package tangled
 
 const (
 	RepoIssueStateClosedNSID = "sh.tangled.repo.issue.state.closed"

api/tangled/stateopen.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo.issue.state.open
 
-// schema: sh.tangled.repo.issue.state.open
+package tangled
 
 const (
 	RepoIssueStateOpenNSID = "sh.tangled.repo.issue.state.open"

api/tangled/statusclosed.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo.pull.status.closed
 
-// schema: sh.tangled.repo.pull.status.closed
+package tangled
 
 const (
 	RepoPullStatusClosedNSID = "sh.tangled.repo.pull.status.closed"

api/tangled/statusmerged.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo.pull.status.merged
 
-// schema: sh.tangled.repo.pull.status.merged
+package tangled
 
 const (
 	RepoPullStatusMergedNSID = "sh.tangled.repo.pull.status.merged"

api/tangled/statusopen.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo.pull.status.open
 
-// schema: sh.tangled.repo.pull.status.open
+package tangled
 
 const (
 	RepoPullStatusOpenNSID = "sh.tangled.repo.pull.status.open"

api/tangled/tangledknot.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.knot
 
-// schema: sh.tangled.knot
+package tangled
 
 import (
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 )
 
 func init() {
-	util.RegisterType("sh.tangled.knot", &Knot{})
-} //
-// RECORDTYPE: Knot
+	lexutil.RegisterType("sh.tangled.knot", &Knot{})
+}
+
 type Knot struct {
-	LexiconTypeID string `json:"$type,const=sh.tangled.knot" cborgen:"$type,const=sh.tangled.knot"`
+	LexiconTypeID string `json:"$type" cborgen:"$type,const=sh.tangled.knot"`
 	CreatedAt     string `json:"createdAt" cborgen:"createdAt"`
 }

api/tangled/tangledowner.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.owner
 
-// schema: sh.tangled.owner
+package tangled
 
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 }
 
 // Owner calls the XRPC method "sh.tangled.owner".
-func Owner(ctx context.Context, c util.LexClient) (*Owner_Output, error) {
+func Owner(ctx context.Context, c lexutil.LexClient) (*Owner_Output, error) {
 	var out Owner_Output
-	if err := c.LexDo(ctx, util.Query, "", "sh.tangled.owner", nil, nil, &out); err != nil {
+	if err := c.LexDo(ctx, lexutil.Query, "", "sh.tangled.owner", nil, nil, &out); err != nil {
 		return nil, err
 	}
 

api/tangled/tangledpipeline.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.pipeline
 
-// schema: sh.tangled.pipeline
+package tangled
 
 import (
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 )
 
 func init() {
-	util.RegisterType("sh.tangled.pipeline", &Pipeline{})
-} //
-// RECORDTYPE: Pipeline
+	lexutil.RegisterType("sh.tangled.pipeline", &Pipeline{})
+}
+
 type Pipeline struct {
-	LexiconTypeID   string                    `json:"$type,const=sh.tangled.pipeline" cborgen:"$type,const=sh.tangled.pipeline"`
+	LexiconTypeID   string                    `json:"$type" cborgen:"$type,const=sh.tangled.pipeline"`
 	TriggerMetadata *Pipeline_TriggerMetadata `json:"triggerMetadata" cborgen:"triggerMetadata"`
 	Workflows       []*Pipeline_Workflow      `json:"workflows" cborgen:"workflows"`
 }

api/tangled/tangledpublicKey.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.publicKey
 
-// schema: sh.tangled.publicKey
+package tangled
 
 import (
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 )
 
 func init() {
-	util.RegisterType("sh.tangled.publicKey", &PublicKey{})
-} //
-// RECORDTYPE: PublicKey
+	lexutil.RegisterType("sh.tangled.publicKey", &PublicKey{})
+}
+
 type PublicKey struct {
-	LexiconTypeID string `json:"$type,const=sh.tangled.publicKey" cborgen:"$type,const=sh.tangled.publicKey"`
+	LexiconTypeID string `json:"$type" cborgen:"$type,const=sh.tangled.publicKey"`
 	// createdAt: key upload timestamp
 	CreatedAt string `json:"createdAt" cborgen:"createdAt"`
 	// key: public key contents

api/tangled/tangledrepo.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.repo
 
-// schema: sh.tangled.repo
+package tangled
 
 import (
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 )
 
 func init() {
-	util.RegisterType("sh.tangled.repo", &Repo{})
-} //
-// RECORDTYPE: Repo
+	lexutil.RegisterType("sh.tangled.repo", &Repo{})
+}
+
 type Repo struct {
-	LexiconTypeID string  `json:"$type,const=sh.tangled.repo" cborgen:"$type,const=sh.tangled.repo"`
+	LexiconTypeID string  `json:"$type" cborgen:"$type,const=sh.tangled.repo"`
 	CreatedAt     string  `json:"createdAt" cborgen:"createdAt"`
 	Description   *string `json:"description,omitempty" cborgen:"description,omitempty"`
 	// knot: knot where the repo was created

api/tangled/tangledspindle.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.spindle
 
-// schema: sh.tangled.spindle
+package tangled
 
 import (
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 )
 
 func init() {
-	util.RegisterType("sh.tangled.spindle", &Spindle{})
-} //
-// RECORDTYPE: Spindle
+	lexutil.RegisterType("sh.tangled.spindle", &Spindle{})
+}
+
 type Spindle struct {
-	LexiconTypeID string `json:"$type,const=sh.tangled.spindle" cborgen:"$type,const=sh.tangled.spindle"`
+	LexiconTypeID string `json:"$type" cborgen:"$type,const=sh.tangled.spindle"`
 	CreatedAt     string `json:"createdAt" cborgen:"createdAt"`
 }

api/tangled/tangledstring.go

···
 // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
 
-package tangled
+// Lexicon schema: sh.tangled.string
 
-// schema: sh.tangled.string
+package tangled
 
 import (
-	"github.com/bluesky-social/indigo/lex/util"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
 const (
···
 )
 
 func init() {
-	util.RegisterType("sh.tangled.string", &String{})
-} //
-// RECORDTYPE: String
+	lexutil.RegisterType("sh.tangled.string", &String{})
+}
+
 type String struct {
-	LexiconTypeID string `json:"$type,const=sh.tangled.string" cborgen:"$type,const=sh.tangled.string"`
+	LexiconTypeID string `json:"$type" cborgen:"$type,const=sh.tangled.string"`
 	Contents      string `json:"contents" cborgen:"contents"`
 	CreatedAt     string `json:"createdAt" cborgen:"createdAt"`
 	Description   string `json:"description" cborgen:"description"`