Generate TypeScript types from Tangled lexicons

Generated type-safe client code from vendored lexicons using @atproto/lex-cli.
Includes type definitions for:
- Issue management (sh.tangled.repo.issue)
- Pull requests (sh.tangled.repo.pull)
- Repository operations
- All Tangled-specific record types

Note: Generated code committed to version control for:
- Reviewability in PRs
- No build step required for type checking
- Offline development support

We'll use the type definitions (interfaces) for type safety while calling
AT Protocol APIs directly via @atproto/api to avoid module resolution issues
with the generated client methods.

Co-Authored-By: Claude Sonnet 4.5 <[e-mail]>

src/lexicon/index.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import {
+  XrpcClient,
+  type FetchHandler,
+  type FetchHandlerOptions,
+} from '@atproto/xrpc'
+import { schemas } from './lexicons.js'
+import { CID } from 'multiformats/cid'
+import { type OmitKey, type Un$Typed } from './util.js'
+import * as ShTangledActorProfile from './types/sh/tangled/actor/profile.js'
+import * as ShTangledFeedReaction from './types/sh/tangled/feed/reaction.js'
+import * as ShTangledFeedStar from './types/sh/tangled/feed/star.js'
+import * as ShTangledGitRefUpdate from './types/sh/tangled/git/refUpdate.js'
+import * as ShTangledGraphFollow from './types/sh/tangled/graph/follow.js'
+import * as ShTangledRepoIssueStateClosed from './types/sh/tangled/repo/issue/state/closed.js'
+import * as ShTangledRepoIssueComment from './types/sh/tangled/repo/issue/comment.js'
+import * as ShTangledRepoIssue from './types/sh/tangled/repo/issue.js'
+import * as ShTangledRepoIssueStateOpen from './types/sh/tangled/repo/issue/state/open.js'
+import * as ShTangledRepoIssueState from './types/sh/tangled/repo/issue/state.js'
+import * as ShTangledKnot from './types/sh/tangled/knot.js'
+import * as ShTangledKnotListKeys from './types/sh/tangled/knot/listKeys.js'
+import * as ShTangledKnotMember from './types/sh/tangled/knot/member.js'
+import * as ShTangledKnotVersion from './types/sh/tangled/knot/version.js'
+import * as ShTangledLabelDefinition from './types/sh/tangled/label/definition.js'
+import * as ShTangledLabelOp from './types/sh/tangled/label/op.js'
+import * as ShTangledPipelineCancelPipeline from './types/sh/tangled/pipeline/cancelPipeline.js'
+import * as ShTangledPipeline from './types/sh/tangled/pipeline.js'
+import * as ShTangledPipelineStatus from './types/sh/tangled/pipeline/status.js'
+import * as ShTangledRepoPullStatusClosed from './types/sh/tangled/repo/pull/status/closed.js'
+import * as ShTangledRepoPullComment from './types/sh/tangled/repo/pull/comment.js'
+import * as ShTangledRepoPullStatusMerged from './types/sh/tangled/repo/pull/status/merged.js'
+import * as ShTangledRepoPullStatusOpen from './types/sh/tangled/repo/pull/status/open.js'
+import * as ShTangledRepoPull from './types/sh/tangled/repo/pull.js'
+import * as ShTangledRepoPullStatus from './types/sh/tangled/repo/pull/status.js'
+import * as ShTangledRepoAddSecret from './types/sh/tangled/repo/addSecret.js'
+import * as ShTangledRepoArchive from './types/sh/tangled/repo/archive.js'
+import * as ShTangledRepoArtifact from './types/sh/tangled/repo/artifact.js'
+import * as ShTangledRepoBlob from './types/sh/tangled/repo/blob.js'
+import * as ShTangledRepoBranch from './types/sh/tangled/repo/branch.js'
+import * as ShTangledRepoBranches from './types/sh/tangled/repo/branches.js'
+import * as ShTangledRepoCollaborator from './types/sh/tangled/repo/collaborator.js'
+import * as ShTangledRepoCompare from './types/sh/tangled/repo/compare.js'
+import * as ShTangledRepoCreate from './types/sh/tangled/repo/create.js'
+import * as ShTangledRepoSetDefaultBranch from './types/sh/tangled/repo/setDefaultBranch.js'
+import * as ShTangledRepoDelete from './types/sh/tangled/repo/delete.js'
+import * as ShTangledRepoDeleteBranch from './types/sh/tangled/repo/deleteBranch.js'
+import * as ShTangledRepoDiff from './types/sh/tangled/repo/diff.js'
+import * as ShTangledRepoForkStatus from './types/sh/tangled/repo/forkStatus.js'
+import * as ShTangledRepoForkSync from './types/sh/tangled/repo/forkSync.js'
+import * as ShTangledRepoGetDefaultBranch from './types/sh/tangled/repo/getDefaultBranch.js'
+import * as ShTangledRepoHiddenRef from './types/sh/tangled/repo/hiddenRef.js'
+import * as ShTangledRepoLanguages from './types/sh/tangled/repo/languages.js'
+import * as ShTangledRepoListSecrets from './types/sh/tangled/repo/listSecrets.js'
+import * as ShTangledRepoLog from './types/sh/tangled/repo/log.js'
+import * as ShTangledRepoMerge from './types/sh/tangled/repo/merge.js'
+import * as ShTangledRepoMergeCheck from './types/sh/tangled/repo/mergeCheck.js'
+import * as ShTangledRepoRemoveSecret from './types/sh/tangled/repo/removeSecret.js'
+import * as ShTangledRepo from './types/sh/tangled/repo.js'
+import * as ShTangledRepoTag from './types/sh/tangled/repo/tag.js'
+import * as ShTangledRepoTags from './types/sh/tangled/repo/tags.js'
+import * as ShTangledRepoTree from './types/sh/tangled/repo/tree.js'
+import * as ShTangledSpindleMember from './types/sh/tangled/spindle/member.js'
+import * as ShTangledSpindle from './types/sh/tangled/spindle.js'
+import * as ShTangledString from './types/sh/tangled/string.js'
+
+export * as ShTangledActorProfile from './types/sh/tangled/actor/profile.js'
+export * as ShTangledFeedReaction from './types/sh/tangled/feed/reaction.js'
+export * as ShTangledFeedStar from './types/sh/tangled/feed/star.js'
+export * as ShTangledGitRefUpdate from './types/sh/tangled/git/refUpdate.js'
+export * as ShTangledGraphFollow from './types/sh/tangled/graph/follow.js'
+export * as ShTangledRepoIssueStateClosed from './types/sh/tangled/repo/issue/state/closed.js'
+export * as ShTangledRepoIssueComment from './types/sh/tangled/repo/issue/comment.js'
+export * as ShTangledRepoIssue from './types/sh/tangled/repo/issue.js'
+export * as ShTangledRepoIssueStateOpen from './types/sh/tangled/repo/issue/state/open.js'
+export * as ShTangledRepoIssueState from './types/sh/tangled/repo/issue/state.js'
+export * as ShTangledKnot from './types/sh/tangled/knot.js'
+export * as ShTangledKnotListKeys from './types/sh/tangled/knot/listKeys.js'
+export * as ShTangledKnotMember from './types/sh/tangled/knot/member.js'
+export * as ShTangledKnotVersion from './types/sh/tangled/knot/version.js'
+export * as ShTangledLabelDefinition from './types/sh/tangled/label/definition.js'
+export * as ShTangledLabelOp from './types/sh/tangled/label/op.js'
+export * as ShTangledPipelineCancelPipeline from './types/sh/tangled/pipeline/cancelPipeline.js'
+export * as ShTangledPipeline from './types/sh/tangled/pipeline.js'
+export * as ShTangledPipelineStatus from './types/sh/tangled/pipeline/status.js'
+export * as ShTangledRepoPullStatusClosed from './types/sh/tangled/repo/pull/status/closed.js'
+export * as ShTangledRepoPullComment from './types/sh/tangled/repo/pull/comment.js'
+export * as ShTangledRepoPullStatusMerged from './types/sh/tangled/repo/pull/status/merged.js'
+export * as ShTangledRepoPullStatusOpen from './types/sh/tangled/repo/pull/status/open.js'
+export * as ShTangledRepoPull from './types/sh/tangled/repo/pull.js'
+export * as ShTangledRepoPullStatus from './types/sh/tangled/repo/pull/status.js'
+export * as ShTangledRepoAddSecret from './types/sh/tangled/repo/addSecret.js'
+export * as ShTangledRepoArchive from './types/sh/tangled/repo/archive.js'
+export * as ShTangledRepoArtifact from './types/sh/tangled/repo/artifact.js'
+export * as ShTangledRepoBlob from './types/sh/tangled/repo/blob.js'
+export * as ShTangledRepoBranch from './types/sh/tangled/repo/branch.js'
+export * as ShTangledRepoBranches from './types/sh/tangled/repo/branches.js'
+export * as ShTangledRepoCollaborator from './types/sh/tangled/repo/collaborator.js'
+export * as ShTangledRepoCompare from './types/sh/tangled/repo/compare.js'
+export * as ShTangledRepoCreate from './types/sh/tangled/repo/create.js'
+export * as ShTangledRepoSetDefaultBranch from './types/sh/tangled/repo/setDefaultBranch.js'
+export * as ShTangledRepoDelete from './types/sh/tangled/repo/delete.js'
+export * as ShTangledRepoDeleteBranch from './types/sh/tangled/repo/deleteBranch.js'
+export * as ShTangledRepoDiff from './types/sh/tangled/repo/diff.js'
+export * as ShTangledRepoForkStatus from './types/sh/tangled/repo/forkStatus.js'
+export * as ShTangledRepoForkSync from './types/sh/tangled/repo/forkSync.js'
+export * as ShTangledRepoGetDefaultBranch from './types/sh/tangled/repo/getDefaultBranch.js'
+export * as ShTangledRepoHiddenRef from './types/sh/tangled/repo/hiddenRef.js'
+export * as ShTangledRepoLanguages from './types/sh/tangled/repo/languages.js'
+export * as ShTangledRepoListSecrets from './types/sh/tangled/repo/listSecrets.js'
+export * as ShTangledRepoLog from './types/sh/tangled/repo/log.js'
+export * as ShTangledRepoMerge from './types/sh/tangled/repo/merge.js'
+export * as ShTangledRepoMergeCheck from './types/sh/tangled/repo/mergeCheck.js'
+export * as ShTangledRepoRemoveSecret from './types/sh/tangled/repo/removeSecret.js'
+export * as ShTangledRepo from './types/sh/tangled/repo.js'
+export * as ShTangledRepoTag from './types/sh/tangled/repo/tag.js'
+export * as ShTangledRepoTags from './types/sh/tangled/repo/tags.js'
+export * as ShTangledRepoTree from './types/sh/tangled/repo/tree.js'
+export * as ShTangledSpindleMember from './types/sh/tangled/spindle/member.js'
+export * as ShTangledSpindle from './types/sh/tangled/spindle.js'
+export * as ShTangledString from './types/sh/tangled/string.js'
+
+export const SH_TANGLED_REPO_ISSUE_STATE = {
+  Closed: 'sh.tangled.repo.issue.state.closed',
+  Open: 'sh.tangled.repo.issue.state.open',
+}
+export const SH_TANGLED_REPO_PULL_STATUS = {
+  Closed: 'sh.tangled.repo.pull.status.closed',
+  Merged: 'sh.tangled.repo.pull.status.merged',
+  Open: 'sh.tangled.repo.pull.status.open',
+}
+
+export class AtpBaseClient extends XrpcClient {
+  sh: ShNS
+
+  constructor(options: FetchHandler | FetchHandlerOptions) {
+    super(options, schemas)
+    this.sh = new ShNS(this)
+  }
+
+  /** @deprecated use `this` instead */
+  get xrpc(): XrpcClient {
+    return this
+  }
+}
+
+export class ShNS {
+  _client: XrpcClient
+  tangled: ShTangledNS
+
+  constructor(client: XrpcClient) {
+    this._client = client
+    this.tangled = new ShTangledNS(client)
+  }
+}
+
+export class ShTangledNS {
+  _client: XrpcClient
+  knot: ShTangledKnotRecord
+  pipeline: ShTangledPipelineRecord
+  repo: ShTangledRepoRecord
+  spindle: ShTangledSpindleRecord
+  string: ShTangledStringRecord
+  actor: ShTangledActorNS
+  feed: ShTangledFeedNS
+  git: ShTangledGitNS
+  graph: ShTangledGraphNS
+  repo: ShTangledRepoNS
+  knot: ShTangledKnotNS
+  label: ShTangledLabelNS
+  pipeline: ShTangledPipelineNS
+  spindle: ShTangledSpindleNS
+
+  constructor(client: XrpcClient) {
+    this._client = client
+    this.actor = new ShTangledActorNS(client)
+    this.feed = new ShTangledFeedNS(client)
+    this.git = new ShTangledGitNS(client)
+    this.graph = new ShTangledGraphNS(client)
+    this.repo = new ShTangledRepoNS(client)
+    this.knot = new ShTangledKnotNS(client)
+    this.label = new ShTangledLabelNS(client)
+    this.pipeline = new ShTangledPipelineNS(client)
+    this.spindle = new ShTangledSpindleNS(client)
+    this.knot = new ShTangledKnotRecord(client)
+    this.pipeline = new ShTangledPipelineRecord(client)
+    this.repo = new ShTangledRepoRecord(client)
+    this.spindle = new ShTangledSpindleRecord(client)
+    this.string = new ShTangledStringRecord(client)
+  }
+}
+
+export class ShTangledActorNS {
+  _client: XrpcClient
+  profile: ShTangledActorProfileRecord
+
+  constructor(client: XrpcClient) {
+    this._client = client
+    this.profile = new ShTangledActorProfileRecord(client)
+  }
+}
+
+export class ShTangledActorProfileRecord {
+  _client: XrpcClient
+
+  constructor(client: XrpcClient) {
+    this._client = client
+  }
+
+  async list(
+    params: OmitKey<ComAtprotoRepoListRecords.QueryParams, 'collection'>,
+  ): Promise<{
+    cursor?: string
+    records: { uri: string; value: ShTangledActorProfile.Record }[]
+  }> {
+    const res = await this._client.call('com.atproto.repo.listRecords', {
+      collection: 'sh.tangled.actor.profile',
+      ...params,
+    })
+    return res.data
+  }
+
+  async get(
+    params: OmitKey<ComAtprotoRepoGetRecord.QueryParams, 'collection'>,
+  ): Promise<{
+    uri: string
+    cid: string
+    value: ShTangledActorProfile.Record
+  }> {
+    const res = await this._client.call('com.atproto.repo.getRecord', {
+      collection: 'sh.tangled.actor.profile',
+      ...params,
+    })
+    return res.data
+  }
+
+  async create(
+    params: OmitKey<
+      ComAtprotoRepoCreateRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledActorProfile.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.actor.profile'
+    const res = await this._client.call(
+      'com.atproto.repo.createRecord',
+      undefined,
+      {
+        collection,
+        rkey: 'self',
+        ...params,
+        record: { ...record, $type: collection },
+      },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async put(
+    params: OmitKey<
+      ComAtprotoRepoPutRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledActorProfile.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.actor.profile'
+    const res = await this._client.call(
+      'com.atproto.repo.putRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async delete(
+    params: OmitKey<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>,
+    headers?: Record<string, string>,
+  ): Promise<void> {
+    await this._client.call(
+      'com.atproto.repo.deleteRecord',
+      undefined,
+      { collection: 'sh.tangled.actor.profile', ...params },
+      { headers },
+    )
+  }
+}
+
+export class ShTangledFeedNS {
+  _client: XrpcClient
+  reaction: ShTangledFeedReactionRecord
+  star: ShTangledFeedStarRecord
+
+  constructor(client: XrpcClient) {
+    this._client = client
+    this.reaction = new ShTangledFeedReactionRecord(client)
+    this.star = new ShTangledFeedStarRecord(client)
+  }
+}
+
+export class ShTangledFeedReactionRecord {
+  _client: XrpcClient
+
+  constructor(client: XrpcClient) {
+    this._client = client
+  }
+
+  async list(
+    params: OmitKey<ComAtprotoRepoListRecords.QueryParams, 'collection'>,
+  ): Promise<{
+    cursor?: string
+    records: { uri: string; value: ShTangledFeedReaction.Record }[]
+  }> {
+    const res = await this._client.call('com.atproto.repo.listRecords', {
+      collection: 'sh.tangled.feed.reaction',
+      ...params,
+    })
+    return res.data
+  }
+
+  async get(
+    params: OmitKey<ComAtprotoRepoGetRecord.QueryParams, 'collection'>,
+  ): Promise<{
+    uri: string
+    cid: string
+    value: ShTangledFeedReaction.Record
+  }> {
+    const res = await this._client.call('com.atproto.repo.getRecord', {
+      collection: 'sh.tangled.feed.reaction',
+      ...params,
+    })
+    return res.data
+  }
+
+  async create(
+    params: OmitKey<
+      ComAtprotoRepoCreateRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledFeedReaction.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.feed.reaction'
+    const res = await this._client.call(
+      'com.atproto.repo.createRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async put(
+    params: OmitKey<
+      ComAtprotoRepoPutRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledFeedReaction.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.feed.reaction'
+    const res = await this._client.call(
+      'com.atproto.repo.putRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async delete(
+    params: OmitKey<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>,
+    headers?: Record<string, string>,
+  ): Promise<void> {
+    await this._client.call(
+      'com.atproto.repo.deleteRecord',
+      undefined,
+      { collection: 'sh.tangled.feed.reaction', ...params },
+      { headers },
+    )
+  }
+}
+
+export class ShTangledFeedStarRecord {
+  _client: XrpcClient
+
+  constructor(client: XrpcClient) {
+    this._client = client
+  }
+
+  async list(
+    params: OmitKey<ComAtprotoRepoListRecords.QueryParams, 'collection'>,
+  ): Promise<{
+    cursor?: string
+    records: { uri: string; value: ShTangledFeedStar.Record }[]
+  }> {
+    const res = await this._client.call('com.atproto.repo.listRecords', {
+      collection: 'sh.tangled.feed.star',
+      ...params,
+    })
+    return res.data
+  }
+
+  async get(
+    params: OmitKey<ComAtprotoRepoGetRecord.QueryParams, 'collection'>,
+  ): Promise<{ uri: string; cid: string; value: ShTangledFeedStar.Record }> {
+    const res = await this._client.call('com.atproto.repo.getRecord', {
+      collection: 'sh.tangled.feed.star',
+      ...params,
+    })
+    return res.data
+  }
+
+  async create(
+    params: OmitKey<
+      ComAtprotoRepoCreateRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledFeedStar.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.feed.star'
+    const res = await this._client.call(
+      'com.atproto.repo.createRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async put(
+    params: OmitKey<
+      ComAtprotoRepoPutRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledFeedStar.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.feed.star'
+    const res = await this._client.call(
+      'com.atproto.repo.putRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async delete(
+    params: OmitKey<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>,
+    headers?: Record<string, string>,
+  ): Promise<void> {
+    await this._client.call(
+      'com.atproto.repo.deleteRecord',
+      undefined,
+      { collection: 'sh.tangled.feed.star', ...params },
+      { headers },
+    )
+  }
+}
+
+export class ShTangledGitNS {
+  _client: XrpcClient
+  refUpdate: ShTangledGitRefUpdateRecord
+
+  constructor(client: XrpcClient) {
+    this._client = client
+    this.refUpdate = new ShTangledGitRefUpdateRecord(client)
+  }
+}
+
+export class ShTangledGitRefUpdateRecord {
+  _client: XrpcClient
+
+  constructor(client: XrpcClient) {
+    this._client = client
+  }
+
+  async list(
+    params: OmitKey<ComAtprotoRepoListRecords.QueryParams, 'collection'>,
+  ): Promise<{
+    cursor?: string
+    records: { uri: string; value: ShTangledGitRefUpdate.Record }[]
+  }> {
+    const res = await this._client.call('com.atproto.repo.listRecords', {
+      collection: 'sh.tangled.git.refUpdate',
+      ...params,
+    })
+    return res.data
+  }
+
+  async get(
+    params: OmitKey<ComAtprotoRepoGetRecord.QueryParams, 'collection'>,
+  ): Promise<{
+    uri: string
+    cid: string
+    value: ShTangledGitRefUpdate.Record
+  }> {
+    const res = await this._client.call('com.atproto.repo.getRecord', {
+      collection: 'sh.tangled.git.refUpdate',
+      ...params,
+    })
+    return res.data
+  }
+
+  async create(
+    params: OmitKey<
+      ComAtprotoRepoCreateRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledGitRefUpdate.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.git.refUpdate'
+    const res = await this._client.call(
+      'com.atproto.repo.createRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async put(
+    params: OmitKey<
+      ComAtprotoRepoPutRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledGitRefUpdate.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.git.refUpdate'
+    const res = await this._client.call(
+      'com.atproto.repo.putRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async delete(
+    params: OmitKey<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>,
+    headers?: Record<string, string>,
+  ): Promise<void> {
+    await this._client.call(
+      'com.atproto.repo.deleteRecord',
+      undefined,
+      { collection: 'sh.tangled.git.refUpdate', ...params },
+      { headers },
+    )
+  }
+}
+
+export class ShTangledGraphNS {
+  _client: XrpcClient
+  follow: ShTangledGraphFollowRecord
+
+  constructor(client: XrpcClient) {
+    this._client = client
+    this.follow = new ShTangledGraphFollowRecord(client)
+  }
+}
+
+export class ShTangledGraphFollowRecord {
+  _client: XrpcClient
+
+  constructor(client: XrpcClient) {
+    this._client = client
+  }
+
+  async list(
+    params: OmitKey<ComAtprotoRepoListRecords.QueryParams, 'collection'>,
+  ): Promise<{
+    cursor?: string
+    records: { uri: string; value: ShTangledGraphFollow.Record }[]
+  }> {
+    const res = await this._client.call('com.atproto.repo.listRecords', {
+      collection: 'sh.tangled.graph.follow',
+      ...params,
+    })
+    return res.data
+  }
+
+  async get(
+    params: OmitKey<ComAtprotoRepoGetRecord.QueryParams, 'collection'>,
+  ): Promise<{ uri: string; cid: string; value: ShTangledGraphFollow.Record }> {
+    const res = await this._client.call('com.atproto.repo.getRecord', {
+      collection: 'sh.tangled.graph.follow',
+      ...params,
+    })
+    return res.data
+  }
+
+  async create(
+    params: OmitKey<
+      ComAtprotoRepoCreateRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledGraphFollow.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.graph.follow'
+    const res = await this._client.call(
+      'com.atproto.repo.createRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async put(
+    params: OmitKey<
+      ComAtprotoRepoPutRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledGraphFollow.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.graph.follow'
+    const res = await this._client.call(
+      'com.atproto.repo.putRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async delete(
+    params: OmitKey<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>,
+    headers?: Record<string, string>,
+  ): Promise<void> {
+    await this._client.call(
+      'com.atproto.repo.deleteRecord',
+      undefined,
+      { collection: 'sh.tangled.graph.follow', ...params },
+      { headers },
+    )
+  }
+}
+
+export class ShTangledRepoNS {
+  _client: XrpcClient
+  issue: ShTangledRepoIssueRecord
+  pull: ShTangledRepoPullRecord
+  artifact: ShTangledRepoArtifactRecord
+  collaborator: ShTangledRepoCollaboratorRecord
+  issue: ShTangledRepoIssueNS
+  pull: ShTangledRepoPullNS
+
+  constructor(client: XrpcClient) {
+    this._client = client
+    this.issue = new ShTangledRepoIssueNS(client)
+    this.pull = new ShTangledRepoPullNS(client)
+    this.issue = new ShTangledRepoIssueRecord(client)
+    this.pull = new ShTangledRepoPullRecord(client)
+    this.artifact = new ShTangledRepoArtifactRecord(client)
+    this.collaborator = new ShTangledRepoCollaboratorRecord(client)
+  }
+
+  addSecret(
+    data?: ShTangledRepoAddSecret.InputSchema,
+    opts?: ShTangledRepoAddSecret.CallOptions,
+  ): Promise<ShTangledRepoAddSecret.Response> {
+    return this._client.call('sh.tangled.repo.addSecret', opts?.qp, data, opts)
+  }
+
+  archive(
+    params?: ShTangledRepoArchive.QueryParams,
+    opts?: ShTangledRepoArchive.CallOptions,
+  ): Promise<ShTangledRepoArchive.Response> {
+    return this._client
+      .call('sh.tangled.repo.archive', params, undefined, opts)
+      .catch((e) => {
+        throw ShTangledRepoArchive.toKnownErr(e)
+      })
+  }
+
+  blob(
+    params?: ShTangledRepoBlob.QueryParams,
+    opts?: ShTangledRepoBlob.CallOptions,
+  ): Promise<ShTangledRepoBlob.Response> {
+    return this._client
+      .call('sh.tangled.repo.blob', params, undefined, opts)
+      .catch((e) => {
+        throw ShTangledRepoBlob.toKnownErr(e)
+      })
+  }
+
+  branch(
+    params?: ShTangledRepoBranch.QueryParams,
+    opts?: ShTangledRepoBranch.CallOptions,
+  ): Promise<ShTangledRepoBranch.Response> {
+    return this._client
+      .call('sh.tangled.repo.branch', params, undefined, opts)
+      .catch((e) => {
+        throw ShTangledRepoBranch.toKnownErr(e)
+      })
+  }
+
+  branches(
+    params?: ShTangledRepoBranches.QueryParams,
+    opts?: ShTangledRepoBranches.CallOptions,
+  ): Promise<ShTangledRepoBranches.Response> {
+    return this._client
+      .call('sh.tangled.repo.branches', params, undefined, opts)
+      .catch((e) => {
+        throw ShTangledRepoBranches.toKnownErr(e)
+      })
+  }
+
+  compare(
+    params?: ShTangledRepoCompare.QueryParams,
+    opts?: ShTangledRepoCompare.CallOptions,
+  ): Promise<ShTangledRepoCompare.Response> {
+    return this._client
+      .call('sh.tangled.repo.compare', params, undefined, opts)
+      .catch((e) => {
+        throw ShTangledRepoCompare.toKnownErr(e)
+      })
+  }
+
+  create(
+    data?: ShTangledRepoCreate.InputSchema,
+    opts?: ShTangledRepoCreate.CallOptions,
+  ): Promise<ShTangledRepoCreate.Response> {
+    return this._client.call('sh.tangled.repo.create', opts?.qp, data, opts)
+  }
+
+  setDefaultBranch(
+    data?: ShTangledRepoSetDefaultBranch.InputSchema,
+    opts?: ShTangledRepoSetDefaultBranch.CallOptions,
+  ): Promise<ShTangledRepoSetDefaultBranch.Response> {
+    return this._client.call(
+      'sh.tangled.repo.setDefaultBranch',
+      opts?.qp,
+      data,
+      opts,
+    )
+  }
+
+  delete(
+    data?: ShTangledRepoDelete.InputSchema,
+    opts?: ShTangledRepoDelete.CallOptions,
+  ): Promise<ShTangledRepoDelete.Response> {
+    return this._client.call('sh.tangled.repo.delete', opts?.qp, data, opts)
+  }
+
+  deleteBranch(
+    data?: ShTangledRepoDeleteBranch.InputSchema,
+    opts?: ShTangledRepoDeleteBranch.CallOptions,
+  ): Promise<ShTangledRepoDeleteBranch.Response> {
+    return this._client.call(
+      'sh.tangled.repo.deleteBranch',
+      opts?.qp,
+      data,
+      opts,
+    )
+  }
+
+  diff(
+    params?: ShTangledRepoDiff.QueryParams,
+    opts?: ShTangledRepoDiff.CallOptions,
+  ): Promise<ShTangledRepoDiff.Response> {
+    return this._client
+      .call('sh.tangled.repo.diff', params, undefined, opts)
+      .catch((e) => {
+        throw ShTangledRepoDiff.toKnownErr(e)
+      })
+  }
+
+  forkStatus(
+    data?: ShTangledRepoForkStatus.InputSchema,
+    opts?: ShTangledRepoForkStatus.CallOptions,
+  ): Promise<ShTangledRepoForkStatus.Response> {
+    return this._client.call('sh.tangled.repo.forkStatus', opts?.qp, data, opts)
+  }
+
+  forkSync(
+    data?: ShTangledRepoForkSync.InputSchema,
+    opts?: ShTangledRepoForkSync.CallOptions,
+  ): Promise<ShTangledRepoForkSync.Response> {
+    return this._client.call('sh.tangled.repo.forkSync', opts?.qp, data, opts)
+  }
+
+  getDefaultBranch(
+    params?: ShTangledRepoGetDefaultBranch.QueryParams,
+    opts?: ShTangledRepoGetDefaultBranch.CallOptions,
+  ): Promise<ShTangledRepoGetDefaultBranch.Response> {
+    return this._client
+      .call('sh.tangled.repo.getDefaultBranch', params, undefined, opts)
+      .catch((e) => {
+        throw ShTangledRepoGetDefaultBranch.toKnownErr(e)
+      })
+  }
+
+  hiddenRef(
+    data?: ShTangledRepoHiddenRef.InputSchema,
+    opts?: ShTangledRepoHiddenRef.CallOptions,
+  ): Promise<ShTangledRepoHiddenRef.Response> {
+    return this._client.call('sh.tangled.repo.hiddenRef', opts?.qp, data, opts)
+  }
+
+  languages(
+    params?: ShTangledRepoLanguages.QueryParams,
+    opts?: ShTangledRepoLanguages.CallOptions,
+  ): Promise<ShTangledRepoLanguages.Response> {
+    return this._client
+      .call('sh.tangled.repo.languages', params, undefined, opts)
+      .catch((e) => {
+        throw ShTangledRepoLanguages.toKnownErr(e)
+      })
+  }
+
+  listSecrets(
+    params?: ShTangledRepoListSecrets.QueryParams,
+    opts?: ShTangledRepoListSecrets.CallOptions,
+  ): Promise<ShTangledRepoListSecrets.Response> {
+    return this._client.call(
+      'sh.tangled.repo.listSecrets',
+      params,
+      undefined,
+      opts,
+    )
+  }
+
+  log(
+    params?: ShTangledRepoLog.QueryParams,
+    opts?: ShTangledRepoLog.CallOptions,
+  ): Promise<ShTangledRepoLog.Response> {
+    return this._client
+      .call('sh.tangled.repo.log', params, undefined, opts)
+      .catch((e) => {
+        throw ShTangledRepoLog.toKnownErr(e)
+      })
+  }
+
+  merge(
+    data?: ShTangledRepoMerge.InputSchema,
+    opts?: ShTangledRepoMerge.CallOptions,
+  ): Promise<ShTangledRepoMerge.Response> {
+    return this._client.call('sh.tangled.repo.merge', opts?.qp, data, opts)
+  }
+
+  mergeCheck(
+    data?: ShTangledRepoMergeCheck.InputSchema,
+    opts?: ShTangledRepoMergeCheck.CallOptions,
+  ): Promise<ShTangledRepoMergeCheck.Response> {
+    return this._client.call('sh.tangled.repo.mergeCheck', opts?.qp, data, opts)
+  }
+
+  removeSecret(
+    data?: ShTangledRepoRemoveSecret.InputSchema,
+    opts?: ShTangledRepoRemoveSecret.CallOptions,
+  ): Promise<ShTangledRepoRemoveSecret.Response> {
+    return this._client.call(
+      'sh.tangled.repo.removeSecret',
+      opts?.qp,
+      data,
+      opts,
+    )
+  }
+
+  tag(
+    params?: ShTangledRepoTag.QueryParams,
+    opts?: ShTangledRepoTag.CallOptions,
+  ): Promise<ShTangledRepoTag.Response> {
+    return this._client
+      .call('sh.tangled.repo.tag', params, undefined, opts)
+      .catch((e) => {
+        throw ShTangledRepoTag.toKnownErr(e)
+      })
+  }
+
+  tags(
+    params?: ShTangledRepoTags.QueryParams,
+    opts?: ShTangledRepoTags.CallOptions,
+  ): Promise<ShTangledRepoTags.Response> {
+    return this._client
+      .call('sh.tangled.repo.tags', params, undefined, opts)
+      .catch((e) => {
+        throw ShTangledRepoTags.toKnownErr(e)
+      })
+  }
+
+  tree(
+    params?: ShTangledRepoTree.QueryParams,
+    opts?: ShTangledRepoTree.CallOptions,
+  ): Promise<ShTangledRepoTree.Response> {
+    return this._client
+      .call('sh.tangled.repo.tree', params, undefined, opts)
+      .catch((e) => {
+        throw ShTangledRepoTree.toKnownErr(e)
+      })
+  }
+}
+
+export class ShTangledRepoIssueNS {
+  _client: XrpcClient
+  comment: ShTangledRepoIssueCommentRecord
+  state: ShTangledRepoIssueStateRecord
+  state: ShTangledRepoIssueStateNS
+
+  constructor(client: XrpcClient) {
+    this._client = client
+    this.state = new ShTangledRepoIssueStateNS(client)
+    this.comment = new ShTangledRepoIssueCommentRecord(client)
+    this.state = new ShTangledRepoIssueStateRecord(client)
+  }
+}
+
+export class ShTangledRepoIssueStateNS {
+  _client: XrpcClient
+
+  constructor(client: XrpcClient) {
+    this._client = client
+  }
+}
+
+export class ShTangledRepoIssueCommentRecord {
+  _client: XrpcClient
+
+  constructor(client: XrpcClient) {
+    this._client = client
+  }
+
+  async list(
+    params: OmitKey<ComAtprotoRepoListRecords.QueryParams, 'collection'>,
+  ): Promise<{
+    cursor?: string
+    records: { uri: string; value: ShTangledRepoIssueComment.Record }[]
+  }> {
+    const res = await this._client.call('com.atproto.repo.listRecords', {
+      collection: 'sh.tangled.repo.issue.comment',
+      ...params,
+    })
+    return res.data
+  }
+
+  async get(
+    params: OmitKey<ComAtprotoRepoGetRecord.QueryParams, 'collection'>,
+  ): Promise<{
+    uri: string
+    cid: string
+    value: ShTangledRepoIssueComment.Record
+  }> {
+    const res = await this._client.call('com.atproto.repo.getRecord', {
+      collection: 'sh.tangled.repo.issue.comment',
+      ...params,
+    })
+    return res.data
+  }
+
+  async create(
+    params: OmitKey<
+      ComAtprotoRepoCreateRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledRepoIssueComment.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.repo.issue.comment'
+    const res = await this._client.call(
+      'com.atproto.repo.createRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async put(
+    params: OmitKey<
+      ComAtprotoRepoPutRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledRepoIssueComment.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.repo.issue.comment'
+    const res = await this._client.call(
+      'com.atproto.repo.putRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async delete(
+    params: OmitKey<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>,
+    headers?: Record<string, string>,
+  ): Promise<void> {
+    await this._client.call(
+      'com.atproto.repo.deleteRecord',
+      undefined,
+      { collection: 'sh.tangled.repo.issue.comment', ...params },
+      { headers },
+    )
+  }
+}
+
+export class ShTangledRepoIssueStateRecord {
+  _client: XrpcClient
+
+  constructor(client: XrpcClient) {
+    this._client = client
+  }
+
+  async list(
+    params: OmitKey<ComAtprotoRepoListRecords.QueryParams, 'collection'>,
+  ): Promise<{
+    cursor?: string
+    records: { uri: string; value: ShTangledRepoIssueState.Record }[]
+  }> {
+    const res = await this._client.call('com.atproto.repo.listRecords', {
+      collection: 'sh.tangled.repo.issue.state',
+      ...params,
+    })
+    return res.data
+  }
+
+  async get(
+    params: OmitKey<ComAtprotoRepoGetRecord.QueryParams, 'collection'>,
+  ): Promise<{
+    uri: string
+    cid: string
+    value: ShTangledRepoIssueState.Record
+  }> {
+    const res = await this._client.call('com.atproto.repo.getRecord', {
+      collection: 'sh.tangled.repo.issue.state',
+      ...params,
+    })
+    return res.data
+  }
+
+  async create(
+    params: OmitKey<
+      ComAtprotoRepoCreateRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledRepoIssueState.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.repo.issue.state'
+    const res = await this._client.call(
+      'com.atproto.repo.createRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async put(
+    params: OmitKey<
+      ComAtprotoRepoPutRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledRepoIssueState.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.repo.issue.state'
+    const res = await this._client.call(
+      'com.atproto.repo.putRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async delete(
+    params: OmitKey<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>,
+    headers?: Record<string, string>,
+  ): Promise<void> {
+    await this._client.call(
+      'com.atproto.repo.deleteRecord',
+      undefined,
+      { collection: 'sh.tangled.repo.issue.state', ...params },
+      { headers },
+    )
+  }
+}
+
+export class ShTangledRepoPullNS {
+  _client: XrpcClient
+  comment: ShTangledRepoPullCommentRecord
+  status: ShTangledRepoPullStatusRecord
+  status: ShTangledRepoPullStatusNS
+
+  constructor(client: XrpcClient) {
+    this._client = client
+    this.status = new ShTangledRepoPullStatusNS(client)
+    this.comment = new ShTangledRepoPullCommentRecord(client)
+    this.status = new ShTangledRepoPullStatusRecord(client)
+  }
+}
+
+export class ShTangledRepoPullStatusNS {
+  _client: XrpcClient
+
+  constructor(client: XrpcClient) {
+    this._client = client
+  }
+}
+
+export class ShTangledRepoPullCommentRecord {
+  _client: XrpcClient
+
+  constructor(client: XrpcClient) {
+    this._client = client
+  }
+
+  async list(
+    params: OmitKey<ComAtprotoRepoListRecords.QueryParams, 'collection'>,
+  ): Promise<{
+    cursor?: string
+    records: { uri: string; value: ShTangledRepoPullComment.Record }[]
+  }> {
+    const res = await this._client.call('com.atproto.repo.listRecords', {
+      collection: 'sh.tangled.repo.pull.comment',
+      ...params,
+    })
+    return res.data
+  }
+
+  async get(
+    params: OmitKey<ComAtprotoRepoGetRecord.QueryParams, 'collection'>,
+  ): Promise<{
+    uri: string
+    cid: string
+    value: ShTangledRepoPullComment.Record
+  }> {
+    const res = await this._client.call('com.atproto.repo.getRecord', {
+      collection: 'sh.tangled.repo.pull.comment',
+      ...params,
+    })
+    return res.data
+  }
+
+  async create(
+    params: OmitKey<
+      ComAtprotoRepoCreateRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledRepoPullComment.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.repo.pull.comment'
+    const res = await this._client.call(
+      'com.atproto.repo.createRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async put(
+    params: OmitKey<
+      ComAtprotoRepoPutRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledRepoPullComment.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.repo.pull.comment'
+    const res = await this._client.call(
+      'com.atproto.repo.putRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async delete(
+    params: OmitKey<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>,
+    headers?: Record<string, string>,
+  ): Promise<void> {
+    await this._client.call(
+      'com.atproto.repo.deleteRecord',
+      undefined,
+      { collection: 'sh.tangled.repo.pull.comment', ...params },
+      { headers },
+    )
+  }
+}
+
+export class ShTangledRepoPullStatusRecord {
+  _client: XrpcClient
+
+  constructor(client: XrpcClient) {
+    this._client = client
+  }
+
+  async list(
+    params: OmitKey<ComAtprotoRepoListRecords.QueryParams, 'collection'>,
+  ): Promise<{
+    cursor?: string
+    records: { uri: string; value: ShTangledRepoPullStatus.Record }[]
+  }> {
+    const res = await this._client.call('com.atproto.repo.listRecords', {
+      collection: 'sh.tangled.repo.pull.status',
+      ...params,
+    })
+    return res.data
+  }
+
+  async get(
+    params: OmitKey<ComAtprotoRepoGetRecord.QueryParams, 'collection'>,
+  ): Promise<{
+    uri: string
+    cid: string
+    value: ShTangledRepoPullStatus.Record
+  }> {
+    const res = await this._client.call('com.atproto.repo.getRecord', {
+      collection: 'sh.tangled.repo.pull.status',
+      ...params,
+    })
+    return res.data
+  }
+
+  async create(
+    params: OmitKey<
+      ComAtprotoRepoCreateRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledRepoPullStatus.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.repo.pull.status'
+    const res = await this._client.call(
+      'com.atproto.repo.createRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async put(
+    params: OmitKey<
+      ComAtprotoRepoPutRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledRepoPullStatus.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.repo.pull.status'
+    const res = await this._client.call(
+      'com.atproto.repo.putRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async delete(
+    params: OmitKey<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>,
+    headers?: Record<string, string>,
+  ): Promise<void> {
+    await this._client.call(
+      'com.atproto.repo.deleteRecord',
+      undefined,
+      { collection: 'sh.tangled.repo.pull.status', ...params },
+      { headers },
+    )
+  }
+}
+
+export class ShTangledRepoIssueRecord {
+  _client: XrpcClient
+
+  constructor(client: XrpcClient) {
+    this._client = client
+  }
+
+  async list(
+    params: OmitKey<ComAtprotoRepoListRecords.QueryParams, 'collection'>,
+  ): Promise<{
+    cursor?: string
+    records: { uri: string; value: ShTangledRepoIssue.Record }[]
+  }> {
+    const res = await this._client.call('com.atproto.repo.listRecords', {
+      collection: 'sh.tangled.repo.issue',
+      ...params,
+    })
+    return res.data
+  }
+
+  async get(
+    params: OmitKey<ComAtprotoRepoGetRecord.QueryParams, 'collection'>,
+  ): Promise<{ uri: string; cid: string; value: ShTangledRepoIssue.Record }> {
+    const res = await this._client.call('com.atproto.repo.getRecord', {
+      collection: 'sh.tangled.repo.issue',
+      ...params,
+    })
+    return res.data
+  }
+
+  async create(
+    params: OmitKey<
+      ComAtprotoRepoCreateRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledRepoIssue.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.repo.issue'
+    const res = await this._client.call(
+      'com.atproto.repo.createRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async put(
+    params: OmitKey<
+      ComAtprotoRepoPutRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledRepoIssue.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.repo.issue'
+    const res = await this._client.call(
+      'com.atproto.repo.putRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async delete(
+    params: OmitKey<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>,
+    headers?: Record<string, string>,
+  ): Promise<void> {
+    await this._client.call(
+      'com.atproto.repo.deleteRecord',
+      undefined,
+      { collection: 'sh.tangled.repo.issue', ...params },
+      { headers },
+    )
+  }
+}
+
+export class ShTangledRepoPullRecord {
+  _client: XrpcClient
+
+  constructor(client: XrpcClient) {
+    this._client = client
+  }
+
+  async list(
+    params: OmitKey<ComAtprotoRepoListRecords.QueryParams, 'collection'>,
+  ): Promise<{
+    cursor?: string
+    records: { uri: string; value: ShTangledRepoPull.Record }[]
+  }> {
+    const res = await this._client.call('com.atproto.repo.listRecords', {
+      collection: 'sh.tangled.repo.pull',
+      ...params,
+    })
+    return res.data
+  }
+
+  async get(
+    params: OmitKey<ComAtprotoRepoGetRecord.QueryParams, 'collection'>,
+  ): Promise<{ uri: string; cid: string; value: ShTangledRepoPull.Record }> {
+    const res = await this._client.call('com.atproto.repo.getRecord', {
+      collection: 'sh.tangled.repo.pull',
+      ...params,
+    })
+    return res.data
+  }
+
+  async create(
+    params: OmitKey<
+      ComAtprotoRepoCreateRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledRepoPull.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.repo.pull'
+    const res = await this._client.call(
+      'com.atproto.repo.createRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async put(
+    params: OmitKey<
+      ComAtprotoRepoPutRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledRepoPull.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.repo.pull'
+    const res = await this._client.call(
+      'com.atproto.repo.putRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async delete(
+    params: OmitKey<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>,
+    headers?: Record<string, string>,
+  ): Promise<void> {
+    await this._client.call(
+      'com.atproto.repo.deleteRecord',
+      undefined,
+      { collection: 'sh.tangled.repo.pull', ...params },
+      { headers },
+    )
+  }
+}
+
+export class ShTangledRepoArtifactRecord {
+  _client: XrpcClient
+
+  constructor(client: XrpcClient) {
+    this._client = client
+  }
+
+  async list(
+    params: OmitKey<ComAtprotoRepoListRecords.QueryParams, 'collection'>,
+  ): Promise<{
+    cursor?: string
+    records: { uri: string; value: ShTangledRepoArtifact.Record }[]
+  }> {
+    const res = await this._client.call('com.atproto.repo.listRecords', {
+      collection: 'sh.tangled.repo.artifact',
+      ...params,
+    })
+    return res.data
+  }
+
+  async get(
+    params: OmitKey<ComAtprotoRepoGetRecord.QueryParams, 'collection'>,
+  ): Promise<{
+    uri: string
+    cid: string
+    value: ShTangledRepoArtifact.Record
+  }> {
+    const res = await this._client.call('com.atproto.repo.getRecord', {
+      collection: 'sh.tangled.repo.artifact',
+      ...params,
+    })
+    return res.data
+  }
+
+  async create(
+    params: OmitKey<
+      ComAtprotoRepoCreateRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledRepoArtifact.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.repo.artifact'
+    const res = await this._client.call(
+      'com.atproto.repo.createRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async put(
+    params: OmitKey<
+      ComAtprotoRepoPutRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledRepoArtifact.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.repo.artifact'
+    const res = await this._client.call(
+      'com.atproto.repo.putRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async delete(
+    params: OmitKey<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>,
+    headers?: Record<string, string>,
+  ): Promise<void> {
+    await this._client.call(
+      'com.atproto.repo.deleteRecord',
+      undefined,
+      { collection: 'sh.tangled.repo.artifact', ...params },
+      { headers },
+    )
+  }
+}
+
+export class ShTangledRepoCollaboratorRecord {
+  _client: XrpcClient
+
+  constructor(client: XrpcClient) {
+    this._client = client
+  }
+
+  async list(
+    params: OmitKey<ComAtprotoRepoListRecords.QueryParams, 'collection'>,
+  ): Promise<{
+    cursor?: string
+    records: { uri: string; value: ShTangledRepoCollaborator.Record }[]
+  }> {
+    const res = await this._client.call('com.atproto.repo.listRecords', {
+      collection: 'sh.tangled.repo.collaborator',
+      ...params,
+    })
+    return res.data
+  }
+
+  async get(
+    params: OmitKey<ComAtprotoRepoGetRecord.QueryParams, 'collection'>,
+  ): Promise<{
+    uri: string
+    cid: string
+    value: ShTangledRepoCollaborator.Record
+  }> {
+    const res = await this._client.call('com.atproto.repo.getRecord', {
+      collection: 'sh.tangled.repo.collaborator',
+      ...params,
+    })
+    return res.data
+  }
+
+  async create(
+    params: OmitKey<
+      ComAtprotoRepoCreateRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledRepoCollaborator.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.repo.collaborator'
+    const res = await this._client.call(
+      'com.atproto.repo.createRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async put(
+    params: OmitKey<
+      ComAtprotoRepoPutRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledRepoCollaborator.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.repo.collaborator'
+    const res = await this._client.call(
+      'com.atproto.repo.putRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async delete(
+    params: OmitKey<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>,
+    headers?: Record<string, string>,
+  ): Promise<void> {
+    await this._client.call(
+      'com.atproto.repo.deleteRecord',
+      undefined,
+      { collection: 'sh.tangled.repo.collaborator', ...params },
+      { headers },
+    )
+  }
+}
+
+export class ShTangledKnotNS {
+  _client: XrpcClient
+  member: ShTangledKnotMemberRecord
+
+  constructor(client: XrpcClient) {
+    this._client = client
+    this.member = new ShTangledKnotMemberRecord(client)
+  }
+
+  listKeys(
+    params?: ShTangledKnotListKeys.QueryParams,
+    opts?: ShTangledKnotListKeys.CallOptions,
+  ): Promise<ShTangledKnotListKeys.Response> {
+    return this._client
+      .call('sh.tangled.knot.listKeys', params, undefined, opts)
+      .catch((e) => {
+        throw ShTangledKnotListKeys.toKnownErr(e)
+      })
+  }
+
+  version(
+    params?: ShTangledKnotVersion.QueryParams,
+    opts?: ShTangledKnotVersion.CallOptions,
+  ): Promise<ShTangledKnotVersion.Response> {
+    return this._client.call('sh.tangled.knot.version', params, undefined, opts)
+  }
+}
+
+export class ShTangledKnotMemberRecord {
+  _client: XrpcClient
+
+  constructor(client: XrpcClient) {
+    this._client = client
+  }
+
+  async list(
+    params: OmitKey<ComAtprotoRepoListRecords.QueryParams, 'collection'>,
+  ): Promise<{
+    cursor?: string
+    records: { uri: string; value: ShTangledKnotMember.Record }[]
+  }> {
+    const res = await this._client.call('com.atproto.repo.listRecords', {
+      collection: 'sh.tangled.knot.member',
+      ...params,
+    })
+    return res.data
+  }
+
+  async get(
+    params: OmitKey<ComAtprotoRepoGetRecord.QueryParams, 'collection'>,
+  ): Promise<{ uri: string; cid: string; value: ShTangledKnotMember.Record }> {
+    const res = await this._client.call('com.atproto.repo.getRecord', {
+      collection: 'sh.tangled.knot.member',
+      ...params,
+    })
+    return res.data
+  }
+
+  async create(
+    params: OmitKey<
+      ComAtprotoRepoCreateRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledKnotMember.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.knot.member'
+    const res = await this._client.call(
+      'com.atproto.repo.createRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async put(
+    params: OmitKey<
+      ComAtprotoRepoPutRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledKnotMember.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.knot.member'
+    const res = await this._client.call(
+      'com.atproto.repo.putRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async delete(
+    params: OmitKey<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>,
+    headers?: Record<string, string>,
+  ): Promise<void> {
+    await this._client.call(
+      'com.atproto.repo.deleteRecord',
+      undefined,
+      { collection: 'sh.tangled.knot.member', ...params },
+      { headers },
+    )
+  }
+}
+
+export class ShTangledLabelNS {
+  _client: XrpcClient
+  definition: ShTangledLabelDefinitionRecord
+  op: ShTangledLabelOpRecord
+
+  constructor(client: XrpcClient) {
+    this._client = client
+    this.definition = new ShTangledLabelDefinitionRecord(client)
+    this.op = new ShTangledLabelOpRecord(client)
+  }
+}
+
+export class ShTangledLabelDefinitionRecord {
+  _client: XrpcClient
+
+  constructor(client: XrpcClient) {
+    this._client = client
+  }
+
+  async list(
+    params: OmitKey<ComAtprotoRepoListRecords.QueryParams, 'collection'>,
+  ): Promise<{
+    cursor?: string
+    records: { uri: string; value: ShTangledLabelDefinition.Record }[]
+  }> {
+    const res = await this._client.call('com.atproto.repo.listRecords', {
+      collection: 'sh.tangled.label.definition',
+      ...params,
+    })
+    return res.data
+  }
+
+  async get(
+    params: OmitKey<ComAtprotoRepoGetRecord.QueryParams, 'collection'>,
+  ): Promise<{
+    uri: string
+    cid: string
+    value: ShTangledLabelDefinition.Record
+  }> {
+    const res = await this._client.call('com.atproto.repo.getRecord', {
+      collection: 'sh.tangled.label.definition',
+      ...params,
+    })
+    return res.data
+  }
+
+  async create(
+    params: OmitKey<
+      ComAtprotoRepoCreateRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledLabelDefinition.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.label.definition'
+    const res = await this._client.call(
+      'com.atproto.repo.createRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async put(
+    params: OmitKey<
+      ComAtprotoRepoPutRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledLabelDefinition.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.label.definition'
+    const res = await this._client.call(
+      'com.atproto.repo.putRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async delete(
+    params: OmitKey<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>,
+    headers?: Record<string, string>,
+  ): Promise<void> {
+    await this._client.call(
+      'com.atproto.repo.deleteRecord',
+      undefined,
+      { collection: 'sh.tangled.label.definition', ...params },
+      { headers },
+    )
+  }
+}
+
+export class ShTangledLabelOpRecord {
+  _client: XrpcClient
+
+  constructor(client: XrpcClient) {
+    this._client = client
+  }
+
+  async list(
+    params: OmitKey<ComAtprotoRepoListRecords.QueryParams, 'collection'>,
+  ): Promise<{
+    cursor?: string
+    records: { uri: string; value: ShTangledLabelOp.Record }[]
+  }> {
+    const res = await this._client.call('com.atproto.repo.listRecords', {
+      collection: 'sh.tangled.label.op',
+      ...params,
+    })
+    return res.data
+  }
+
+  async get(
+    params: OmitKey<ComAtprotoRepoGetRecord.QueryParams, 'collection'>,
+  ): Promise<{ uri: string; cid: string; value: ShTangledLabelOp.Record }> {
+    const res = await this._client.call('com.atproto.repo.getRecord', {
+      collection: 'sh.tangled.label.op',
+      ...params,
+    })
+    return res.data
+  }
+
+  async create(
+    params: OmitKey<
+      ComAtprotoRepoCreateRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledLabelOp.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.label.op'
+    const res = await this._client.call(
+      'com.atproto.repo.createRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async put(
+    params: OmitKey<
+      ComAtprotoRepoPutRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledLabelOp.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.label.op'
+    const res = await this._client.call(
+      'com.atproto.repo.putRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async delete(
+    params: OmitKey<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>,
+    headers?: Record<string, string>,
+  ): Promise<void> {
+    await this._client.call(
+      'com.atproto.repo.deleteRecord',
+      undefined,
+      { collection: 'sh.tangled.label.op', ...params },
+      { headers },
+    )
+  }
+}
+
+export class ShTangledPipelineNS {
+  _client: XrpcClient
+  status: ShTangledPipelineStatusRecord
+
+  constructor(client: XrpcClient) {
+    this._client = client
+    this.status = new ShTangledPipelineStatusRecord(client)
+  }
+
+  cancelPipeline(
+    data?: ShTangledPipelineCancelPipeline.InputSchema,
+    opts?: ShTangledPipelineCancelPipeline.CallOptions,
+  ): Promise<ShTangledPipelineCancelPipeline.Response> {
+    return this._client.call(
+      'sh.tangled.pipeline.cancelPipeline',
+      opts?.qp,
+      data,
+      opts,
+    )
+  }
+}
+
+export class ShTangledPipelineStatusRecord {
+  _client: XrpcClient
+
+  constructor(client: XrpcClient) {
+    this._client = client
+  }
+
+  async list(
+    params: OmitKey<ComAtprotoRepoListRecords.QueryParams, 'collection'>,
+  ): Promise<{
+    cursor?: string
+    records: { uri: string; value: ShTangledPipelineStatus.Record }[]
+  }> {
+    const res = await this._client.call('com.atproto.repo.listRecords', {
+      collection: 'sh.tangled.pipeline.status',
+      ...params,
+    })
+    return res.data
+  }
+
+  async get(
+    params: OmitKey<ComAtprotoRepoGetRecord.QueryParams, 'collection'>,
+  ): Promise<{
+    uri: string
+    cid: string
+    value: ShTangledPipelineStatus.Record
+  }> {
+    const res = await this._client.call('com.atproto.repo.getRecord', {
+      collection: 'sh.tangled.pipeline.status',
+      ...params,
+    })
+    return res.data
+  }
+
+  async create(
+    params: OmitKey<
+      ComAtprotoRepoCreateRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledPipelineStatus.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.pipeline.status'
+    const res = await this._client.call(
+      'com.atproto.repo.createRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async put(
+    params: OmitKey<
+      ComAtprotoRepoPutRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledPipelineStatus.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.pipeline.status'
+    const res = await this._client.call(
+      'com.atproto.repo.putRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async delete(
+    params: OmitKey<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>,
+    headers?: Record<string, string>,
+  ): Promise<void> {
+    await this._client.call(
+      'com.atproto.repo.deleteRecord',
+      undefined,
+      { collection: 'sh.tangled.pipeline.status', ...params },
+      { headers },
+    )
+  }
+}
+
+export class ShTangledSpindleNS {
+  _client: XrpcClient
+  member: ShTangledSpindleMemberRecord
+
+  constructor(client: XrpcClient) {
+    this._client = client
+    this.member = new ShTangledSpindleMemberRecord(client)
+  }
+}
+
+export class ShTangledSpindleMemberRecord {
+  _client: XrpcClient
+
+  constructor(client: XrpcClient) {
+    this._client = client
+  }
+
+  async list(
+    params: OmitKey<ComAtprotoRepoListRecords.QueryParams, 'collection'>,
+  ): Promise<{
+    cursor?: string
+    records: { uri: string; value: ShTangledSpindleMember.Record }[]
+  }> {
+    const res = await this._client.call('com.atproto.repo.listRecords', {
+      collection: 'sh.tangled.spindle.member',
+      ...params,
+    })
+    return res.data
+  }
+
+  async get(
+    params: OmitKey<ComAtprotoRepoGetRecord.QueryParams, 'collection'>,
+  ): Promise<{
+    uri: string
+    cid: string
+    value: ShTangledSpindleMember.Record
+  }> {
+    const res = await this._client.call('com.atproto.repo.getRecord', {
+      collection: 'sh.tangled.spindle.member',
+      ...params,
+    })
+    return res.data
+  }
+
+  async create(
+    params: OmitKey<
+      ComAtprotoRepoCreateRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledSpindleMember.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.spindle.member'
+    const res = await this._client.call(
+      'com.atproto.repo.createRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async put(
+    params: OmitKey<
+      ComAtprotoRepoPutRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledSpindleMember.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.spindle.member'
+    const res = await this._client.call(
+      'com.atproto.repo.putRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async delete(
+    params: OmitKey<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>,
+    headers?: Record<string, string>,
+  ): Promise<void> {
+    await this._client.call(
+      'com.atproto.repo.deleteRecord',
+      undefined,
+      { collection: 'sh.tangled.spindle.member', ...params },
+      { headers },
+    )
+  }
+}
+
+export class ShTangledKnotRecord {
+  _client: XrpcClient
+
+  constructor(client: XrpcClient) {
+    this._client = client
+  }
+
+  async list(
+    params: OmitKey<ComAtprotoRepoListRecords.QueryParams, 'collection'>,
+  ): Promise<{
+    cursor?: string
+    records: { uri: string; value: ShTangledKnot.Record }[]
+  }> {
+    const res = await this._client.call('com.atproto.repo.listRecords', {
+      collection: 'sh.tangled.knot',
+      ...params,
+    })
+    return res.data
+  }
+
+  async get(
+    params: OmitKey<ComAtprotoRepoGetRecord.QueryParams, 'collection'>,
+  ): Promise<{ uri: string; cid: string; value: ShTangledKnot.Record }> {
+    const res = await this._client.call('com.atproto.repo.getRecord', {
+      collection: 'sh.tangled.knot',
+      ...params,
+    })
+    return res.data
+  }
+
+  async create(
+    params: OmitKey<
+      ComAtprotoRepoCreateRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledKnot.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.knot'
+    const res = await this._client.call(
+      'com.atproto.repo.createRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async put(
+    params: OmitKey<
+      ComAtprotoRepoPutRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledKnot.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.knot'
+    const res = await this._client.call(
+      'com.atproto.repo.putRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async delete(
+    params: OmitKey<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>,
+    headers?: Record<string, string>,
+  ): Promise<void> {
+    await this._client.call(
+      'com.atproto.repo.deleteRecord',
+      undefined,
+      { collection: 'sh.tangled.knot', ...params },
+      { headers },
+    )
+  }
+}
+
+export class ShTangledPipelineRecord {
+  _client: XrpcClient
+
+  constructor(client: XrpcClient) {
+    this._client = client
+  }
+
+  async list(
+    params: OmitKey<ComAtprotoRepoListRecords.QueryParams, 'collection'>,
+  ): Promise<{
+    cursor?: string
+    records: { uri: string; value: ShTangledPipeline.Record }[]
+  }> {
+    const res = await this._client.call('com.atproto.repo.listRecords', {
+      collection: 'sh.tangled.pipeline',
+      ...params,
+    })
+    return res.data
+  }
+
+  async get(
+    params: OmitKey<ComAtprotoRepoGetRecord.QueryParams, 'collection'>,
+  ): Promise<{ uri: string; cid: string; value: ShTangledPipeline.Record }> {
+    const res = await this._client.call('com.atproto.repo.getRecord', {
+      collection: 'sh.tangled.pipeline',
+      ...params,
+    })
+    return res.data
+  }
+
+  async create(
+    params: OmitKey<
+      ComAtprotoRepoCreateRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledPipeline.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.pipeline'
+    const res = await this._client.call(
+      'com.atproto.repo.createRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async put(
+    params: OmitKey<
+      ComAtprotoRepoPutRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledPipeline.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.pipeline'
+    const res = await this._client.call(
+      'com.atproto.repo.putRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async delete(
+    params: OmitKey<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>,
+    headers?: Record<string, string>,
+  ): Promise<void> {
+    await this._client.call(
+      'com.atproto.repo.deleteRecord',
+      undefined,
+      { collection: 'sh.tangled.pipeline', ...params },
+      { headers },
+    )
+  }
+}
+
+export class ShTangledRepoRecord {
+  _client: XrpcClient
+
+  constructor(client: XrpcClient) {
+    this._client = client
+  }
+
+  async list(
+    params: OmitKey<ComAtprotoRepoListRecords.QueryParams, 'collection'>,
+  ): Promise<{
+    cursor?: string
+    records: { uri: string; value: ShTangledRepo.Record }[]
+  }> {
+    const res = await this._client.call('com.atproto.repo.listRecords', {
+      collection: 'sh.tangled.repo',
+      ...params,
+    })
+    return res.data
+  }
+
+  async get(
+    params: OmitKey<ComAtprotoRepoGetRecord.QueryParams, 'collection'>,
+  ): Promise<{ uri: string; cid: string; value: ShTangledRepo.Record }> {
+    const res = await this._client.call('com.atproto.repo.getRecord', {
+      collection: 'sh.tangled.repo',
+      ...params,
+    })
+    return res.data
+  }
+
+  async create(
+    params: OmitKey<
+      ComAtprotoRepoCreateRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledRepo.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.repo'
+    const res = await this._client.call(
+      'com.atproto.repo.createRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async put(
+    params: OmitKey<
+      ComAtprotoRepoPutRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledRepo.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.repo'
+    const res = await this._client.call(
+      'com.atproto.repo.putRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async delete(
+    params: OmitKey<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>,
+    headers?: Record<string, string>,
+  ): Promise<void> {
+    await this._client.call(
+      'com.atproto.repo.deleteRecord',
+      undefined,
+      { collection: 'sh.tangled.repo', ...params },
+      { headers },
+    )
+  }
+}
+
+export class ShTangledSpindleRecord {
+  _client: XrpcClient
+
+  constructor(client: XrpcClient) {
+    this._client = client
+  }
+
+  async list(
+    params: OmitKey<ComAtprotoRepoListRecords.QueryParams, 'collection'>,
+  ): Promise<{
+    cursor?: string
+    records: { uri: string; value: ShTangledSpindle.Record }[]
+  }> {
+    const res = await this._client.call('com.atproto.repo.listRecords', {
+      collection: 'sh.tangled.spindle',
+      ...params,
+    })
+    return res.data
+  }
+
+  async get(
+    params: OmitKey<ComAtprotoRepoGetRecord.QueryParams, 'collection'>,
+  ): Promise<{ uri: string; cid: string; value: ShTangledSpindle.Record }> {
+    const res = await this._client.call('com.atproto.repo.getRecord', {
+      collection: 'sh.tangled.spindle',
+      ...params,
+    })
+    return res.data
+  }
+
+  async create(
+    params: OmitKey<
+      ComAtprotoRepoCreateRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledSpindle.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.spindle'
+    const res = await this._client.call(
+      'com.atproto.repo.createRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async put(
+    params: OmitKey<
+      ComAtprotoRepoPutRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledSpindle.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.spindle'
+    const res = await this._client.call(
+      'com.atproto.repo.putRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async delete(
+    params: OmitKey<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>,
+    headers?: Record<string, string>,
+  ): Promise<void> {
+    await this._client.call(
+      'com.atproto.repo.deleteRecord',
+      undefined,
+      { collection: 'sh.tangled.spindle', ...params },
+      { headers },
+    )
+  }
+}
+
+export class ShTangledStringRecord {
+  _client: XrpcClient
+
+  constructor(client: XrpcClient) {
+    this._client = client
+  }
+
+  async list(
+    params: OmitKey<ComAtprotoRepoListRecords.QueryParams, 'collection'>,
+  ): Promise<{
+    cursor?: string
+    records: { uri: string; value: ShTangledString.Record }[]
+  }> {
+    const res = await this._client.call('com.atproto.repo.listRecords', {
+      collection: 'sh.tangled.string',
+      ...params,
+    })
+    return res.data
+  }
+
+  async get(
+    params: OmitKey<ComAtprotoRepoGetRecord.QueryParams, 'collection'>,
+  ): Promise<{ uri: string; cid: string; value: ShTangledString.Record }> {
+    const res = await this._client.call('com.atproto.repo.getRecord', {
+      collection: 'sh.tangled.string',
+      ...params,
+    })
+    return res.data
+  }
+
+  async create(
+    params: OmitKey<
+      ComAtprotoRepoCreateRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledString.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.string'
+    const res = await this._client.call(
+      'com.atproto.repo.createRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async put(
+    params: OmitKey<
+      ComAtprotoRepoPutRecord.InputSchema,
+      'collection' | 'record'
+    >,
+    record: Un$Typed<ShTangledString.Record>,
+    headers?: Record<string, string>,
+  ): Promise<{ uri: string; cid: string }> {
+    const collection = 'sh.tangled.string'
+    const res = await this._client.call(
+      'com.atproto.repo.putRecord',
+      undefined,
+      { collection, ...params, record: { ...record, $type: collection } },
+      { encoding: 'application/json', headers },
+    )
+    return res.data
+  }
+
+  async delete(
+    params: OmitKey<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>,
+    headers?: Record<string, string>,
+  ): Promise<void> {
+    await this._client.call(
+      'com.atproto.repo.deleteRecord',
+      undefined,
+      { collection: 'sh.tangled.string', ...params },
+      { headers },
+    )
+  }
+}

src/lexicon/lexicons.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import {
+  type LexiconDoc,
+  Lexicons,
+  ValidationError,
+  type ValidationResult,
+} from '@atproto/lexicon'
+import { type $Typed, is$typed, maybe$typed } from './util.js'
+
+export const schemaDict = {
+  ShTangledActorProfile: {
+    lexicon: 1,
+    id: 'sh.tangled.actor.profile',
+    defs: {
+      main: {
+        type: 'record',
+        description: 'A declaration of a Tangled account profile.',
+        key: 'literal:self',
+        record: {
+          type: 'object',
+          required: ['bluesky'],
+          properties: {
+            avatar: {
+              type: 'blob',
+              description:
+                "Small image to be displayed next to posts from account. AKA, 'profile picture'",
+              accept: ['image/png', 'image/jpeg'],
+              maxSize: 1000000,
+            },
+            description: {
+              type: 'string',
+              description: 'Free-form profile description text.',
+              maxGraphemes: 256,
+              maxLength: 2560,
+            },
+            links: {
+              type: 'array',
+              minLength: 0,
+              maxLength: 5,
+              items: {
+                type: 'string',
+                description:
+                  'Any URI, intended for social profiles or websites, can be used to link DIDs/AT-URIs too.',
+                format: 'uri',
+              },
+            },
+            stats: {
+              type: 'array',
+              minLength: 0,
+              maxLength: 2,
+              items: {
+                type: 'string',
+                description: 'Vanity stats.',
+                enum: [
+                  'merged-pull-request-count',
+                  'closed-pull-request-count',
+                  'open-pull-request-count',
+                  'open-issue-count',
+                  'closed-issue-count',
+                  'repository-count',
+                  'star-count',
+                ],
+              },
+            },
+            bluesky: {
+              type: 'boolean',
+              description: 'Include link to this account on Bluesky.',
+            },
+            location: {
+              type: 'string',
+              description: 'Free-form location text.',
+              maxGraphemes: 40,
+              maxLength: 400,
+            },
+            pinnedRepositories: {
+              type: 'array',
+              description:
+                'Any ATURI, it is up to appviews to validate these fields.',
+              minLength: 0,
+              maxLength: 6,
+              items: {
+                type: 'string',
+                format: 'at-uri',
+              },
+            },
+            pronouns: {
+              type: 'string',
+              description: 'Preferred gender pronouns.',
+              maxLength: 40,
+            },
+          },
+        },
+      },
+    },
+  },
+  ShTangledFeedReaction: {
+    lexicon: 1,
+    id: 'sh.tangled.feed.reaction',
+    needsCbor: true,
+    needsType: true,
+    defs: {
+      main: {
+        type: 'record',
+        key: 'tid',
+        record: {
+          type: 'object',
+          required: ['subject', 'reaction', 'createdAt'],
+          properties: {
+            subject: {
+              type: 'string',
+              format: 'at-uri',
+            },
+            reaction: {
+              type: 'string',
+              enum: ['👍', '👎', '😆', '🎉', '🫤', '❤️', '🚀', '👀'],
+            },
+            createdAt: {
+              type: 'string',
+              format: 'datetime',
+            },
+          },
+        },
+      },
+    },
+  },
+  ShTangledFeedStar: {
+    lexicon: 1,
+    id: 'sh.tangled.feed.star',
+    needsCbor: true,
+    needsType: true,
+    defs: {
+      main: {
+        type: 'record',
+        key: 'tid',
+        record: {
+          type: 'object',
+          required: ['subject', 'createdAt'],
+          properties: {
+            subject: {
+              type: 'string',
+              format: 'at-uri',
+            },
+            createdAt: {
+              type: 'string',
+              format: 'datetime',
+            },
+          },
+        },
+      },
+    },
+  },
+  ShTangledGitRefUpdate: {
+    lexicon: 1,
+    id: 'sh.tangled.git.refUpdate',
+    defs: {
+      main: {
+        type: 'record',
+        description: 'An update to a git repository, emitted by knots.',
+        key: 'tid',
+        record: {
+          type: 'object',
+          required: [
+            'ref',
+            'committerDid',
+            'repoDid',
+            'repoName',
+            'oldSha',
+            'newSha',
+            'meta',
+          ],
+          properties: {
+            ref: {
+              type: 'string',
+              description: 'Ref being updated',
+              maxGraphemes: 256,
+              maxLength: 2560,
+            },
+            committerDid: {
+              type: 'string',
+              description: 'did of the user that pushed this ref',
+              format: 'did',
+            },
+            repoDid: {
+              type: 'string',
+              description: 'did of the owner of the repo',
+              format: 'did',
+            },
+            repoName: {
+              type: 'string',
+              description: 'name of the repo',
+            },
+            oldSha: {
+              type: 'string',
+              description: 'old SHA of this ref',
+              minLength: 40,
+              maxLength: 40,
+            },
+            newSha: {
+              type: 'string',
+              description: 'new SHA of this ref',
+              minLength: 40,
+              maxLength: 40,
+            },
+            meta: {
+              type: 'ref',
+              ref: 'lex:sh.tangled.git.refUpdate#meta',
+            },
+          },
+        },
+      },
+      meta: {
+        type: 'object',
+        required: ['isDefaultRef', 'commitCount'],
+        properties: {
+          isDefaultRef: {
+            type: 'boolean',
+            default: false,
+          },
+          langBreakdown: {
+            type: 'ref',
+            ref: 'lex:sh.tangled.git.refUpdate#langBreakdown',
+          },
+          commitCount: {
+            type: 'ref',
+            ref: 'lex:sh.tangled.git.refUpdate#commitCountBreakdown',
+          },
+        },
+      },
+      langBreakdown: {
+        type: 'object',
+        properties: {
+          inputs: {
+            type: 'array',
+            items: {
+              type: 'ref',
+              ref: 'lex:sh.tangled.git.refUpdate#individualLanguageSize',
+            },
+          },
+        },
+      },
+      individualLanguageSize: {
+        type: 'object',
+        required: ['lang', 'size'],
+        properties: {
+          lang: {
+            type: 'string',
+          },
+          size: {
+            type: 'integer',
+          },
+        },
+      },
+      commitCountBreakdown: {
+        type: 'object',
+        required: [],
+        properties: {
+          byEmail: {
+            type: 'array',
+            items: {
+              type: 'ref',
+              ref: 'lex:sh.tangled.git.refUpdate#individualEmailCommitCount',
+            },
+          },
+        },
+      },
+      individualEmailCommitCount: {
+        type: 'object',
+        required: ['email', 'count'],
+        properties: {
+          email: {
+            type: 'string',
+          },
+          count: {
+            type: 'integer',
+          },
+        },
+      },
+    },
+  },
+  ShTangledGraphFollow: {
+    lexicon: 1,
+    id: 'sh.tangled.graph.follow',
+    needsCbor: true,
+    needsType: true,
+    defs: {
+      main: {
+        type: 'record',
+        key: 'tid',
+        record: {
+          type: 'object',
+          required: ['subject', 'createdAt'],
+          properties: {
+            subject: {
+              type: 'string',
+              format: 'did',
+            },
+            createdAt: {
+              type: 'string',
+              format: 'datetime',
+            },
+          },
+        },
+      },
+    },
+  },
+  ShTangledRepoIssueStateClosed: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.issue.state.closed',
+    needsCbor: true,
+    needsType: true,
+    defs: {
+      main: {
+        type: 'token',
+        description: 'closed issue',
+      },
+    },
+  },
+  ShTangledRepoIssueComment: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.issue.comment',
+    needsCbor: true,
+    needsType: true,
+    defs: {
+      main: {
+        type: 'record',
+        key: 'tid',
+        record: {
+          type: 'object',
+          required: ['issue', 'body', 'createdAt'],
+          properties: {
+            issue: {
+              type: 'string',
+              format: 'at-uri',
+            },
+            body: {
+              type: 'string',
+            },
+            createdAt: {
+              type: 'string',
+              format: 'datetime',
+            },
+            replyTo: {
+              type: 'string',
+              format: 'at-uri',
+            },
+            mentions: {
+              type: 'array',
+              items: {
+                type: 'string',
+                format: 'did',
+              },
+            },
+            references: {
+              type: 'array',
+              items: {
+                type: 'string',
+                format: 'at-uri',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  ShTangledRepoIssue: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.issue',
+    needsCbor: true,
+    needsType: true,
+    defs: {
+      main: {
+        type: 'record',
+        key: 'tid',
+        record: {
+          type: 'object',
+          required: ['repo', 'title', 'createdAt'],
+          properties: {
+            repo: {
+              type: 'string',
+              format: 'at-uri',
+            },
+            title: {
+              type: 'string',
+            },
+            body: {
+              type: 'string',
+            },
+            createdAt: {
+              type: 'string',
+              format: 'datetime',
+            },
+            mentions: {
+              type: 'array',
+              items: {
+                type: 'string',
+                format: 'did',
+              },
+            },
+            references: {
+              type: 'array',
+              items: {
+                type: 'string',
+                format: 'at-uri',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  ShTangledRepoIssueStateOpen: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.issue.state.open',
+    needsCbor: true,
+    needsType: true,
+    defs: {
+      main: {
+        type: 'token',
+        description: 'open issue',
+      },
+    },
+  },
+  ShTangledRepoIssueState: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.issue.state',
+    needsCbor: true,
+    needsType: true,
+    defs: {
+      main: {
+        type: 'record',
+        key: 'tid',
+        record: {
+          type: 'object',
+          required: ['issue', 'state'],
+          properties: {
+            issue: {
+              type: 'string',
+              format: 'at-uri',
+            },
+            state: {
+              type: 'string',
+              description: 'state of the issue',
+              knownValues: [
+                'sh.tangled.repo.issue.state.open',
+                'sh.tangled.repo.issue.state.closed',
+              ],
+              default: 'sh.tangled.repo.issue.state.open',
+            },
+          },
+        },
+      },
+    },
+  },
+  ShTangledKnot: {
+    lexicon: 1,
+    id: 'sh.tangled.knot',
+    needsCbor: true,
+    needsType: true,
+    defs: {
+      main: {
+        type: 'record',
+        key: 'any',
+        record: {
+          type: 'object',
+          required: ['createdAt'],
+          properties: {
+            createdAt: {
+              type: 'string',
+              format: 'datetime',
+            },
+          },
+        },
+      },
+    },
+  },
+  ShTangledKnotListKeys: {
+    lexicon: 1,
+    id: 'sh.tangled.knot.listKeys',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'List all public keys stored in the knot server',
+        parameters: {
+          type: 'params',
+          properties: {
+            limit: {
+              type: 'integer',
+              description: 'Maximum number of keys to return',
+              minimum: 1,
+              maximum: 1000,
+              default: 100,
+            },
+            cursor: {
+              type: 'string',
+              description: 'Pagination cursor',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['keys'],
+            properties: {
+              keys: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:sh.tangled.knot.listKeys#publicKey',
+                },
+              },
+              cursor: {
+                type: 'string',
+                description: 'Pagination cursor for next page',
+              },
+            },
+          },
+        },
+        errors: [
+          {
+            name: 'InternalServerError',
+            description: 'Failed to retrieve public keys',
+          },
+        ],
+      },
+      publicKey: {
+        type: 'object',
+        required: ['did', 'key', 'createdAt'],
+        properties: {
+          did: {
+            type: 'string',
+            format: 'did',
+            description: 'DID associated with the public key',
+          },
+          key: {
+            type: 'string',
+            maxLength: 4096,
+            description: 'Public key contents',
+          },
+          createdAt: {
+            type: 'string',
+            format: 'datetime',
+            description: 'Key upload timestamp',
+          },
+        },
+      },
+    },
+  },
+  ShTangledKnotMember: {
+    lexicon: 1,
+    id: 'sh.tangled.knot.member',
+    needsCbor: true,
+    needsType: true,
+    defs: {
+      main: {
+        type: 'record',
+        key: 'tid',
+        record: {
+          type: 'object',
+          required: ['subject', 'domain', 'createdAt'],
+          properties: {
+            subject: {
+              type: 'string',
+              format: 'did',
+            },
+            domain: {
+              type: 'string',
+              description: 'domain that this member now belongs to',
+            },
+            createdAt: {
+              type: 'string',
+              format: 'datetime',
+            },
+          },
+        },
+      },
+    },
+  },
+  ShTangledKnotVersion: {
+    lexicon: 1,
+    id: 'sh.tangled.knot.version',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get the version of a knot',
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['version'],
+            properties: {
+              version: {
+                type: 'string',
+              },
+            },
+          },
+        },
+        errors: [],
+      },
+    },
+  },
+  ShTangledLabelDefinition: {
+    lexicon: 1,
+    id: 'sh.tangled.label.definition',
+    needsCbor: true,
+    needsType: true,
+    defs: {
+      main: {
+        type: 'record',
+        key: 'any',
+        record: {
+          type: 'object',
+          required: ['name', 'valueType', 'scope', 'createdAt'],
+          properties: {
+            name: {
+              type: 'string',
+              description: 'The display name of this label.',
+              minGraphemes: 1,
+              maxGraphemes: 40,
+            },
+            valueType: {
+              type: 'ref',
+              ref: 'lex:sh.tangled.label.definition#valueType',
+              description:
+                'The type definition of this label. Appviews may allow sorting for certain types.',
+            },
+            scope: {
+              type: 'array',
+              description:
+                'The areas of the repo this label may apply to, eg.: sh.tangled.repo.issue. Appviews may choose to respect this.',
+              items: {
+                type: 'string',
+                format: 'nsid',
+              },
+            },
+            color: {
+              type: 'string',
+              description:
+                'The hex value for the background color for the label. Appviews may choose to respect this.',
+            },
+            createdAt: {
+              type: 'string',
+              format: 'datetime',
+            },
+            multiple: {
+              type: 'boolean',
+              description:
+                'Whether this label can be repeated for a given entity, eg.: [reviewer:foo, reviewer:bar]',
+            },
+          },
+        },
+      },
+      valueType: {
+        type: 'object',
+        required: ['type', 'format'],
+        properties: {
+          type: {
+            type: 'string',
+            enum: ['null', 'boolean', 'integer', 'string'],
+            description: "The concrete type of this label's value.",
+          },
+          format: {
+            type: 'string',
+            enum: ['any', 'did', 'nsid'],
+            description:
+              'An optional constraint that can be applied on string concrete types.',
+          },
+          enum: {
+            type: 'array',
+            description: 'Closed set of values that this label can take.',
+            items: {
+              type: 'string',
+            },
+          },
+        },
+      },
+    },
+  },
+  ShTangledLabelOp: {
+    lexicon: 1,
+    id: 'sh.tangled.label.op',
+    needsCbor: true,
+    needsType: true,
+    defs: {
+      main: {
+        type: 'record',
+        key: 'tid',
+        record: {
+          type: 'object',
+          required: ['subject', 'add', 'delete', 'performedAt'],
+          properties: {
+            subject: {
+              type: 'string',
+              format: 'at-uri',
+              description:
+                'The subject (task, pull or discussion) of this label. Appviews may apply a `scope` check and refuse this op.',
+            },
+            performedAt: {
+              type: 'string',
+              format: 'datetime',
+            },
+            add: {
+              type: 'array',
+              items: {
+                type: 'ref',
+                ref: 'lex:sh.tangled.label.op#operand',
+              },
+            },
+            delete: {
+              type: 'array',
+              items: {
+                type: 'ref',
+                ref: 'lex:sh.tangled.label.op#operand',
+              },
+            },
+          },
+        },
+      },
+      operand: {
+        type: 'object',
+        required: ['key', 'value'],
+        properties: {
+          key: {
+            type: 'string',
+            format: 'at-uri',
+            description: 'ATURI to the label definition',
+          },
+          value: {
+            type: 'string',
+            description:
+              'Stringified value of the label. This is first unstringed by appviews and then interpreted as a concrete value.',
+          },
+        },
+      },
+    },
+  },
+  ShTangledPipelineCancelPipeline: {
+    lexicon: 1,
+    id: 'sh.tangled.pipeline.cancelPipeline',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Cancel a running pipeline',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['repo', 'pipeline', 'workflow'],
+            properties: {
+              repo: {
+                type: 'string',
+                format: 'at-uri',
+                description:
+                  "repo at-uri, spindle can't resolve repo from pipeline at-uri yet",
+              },
+              pipeline: {
+                type: 'string',
+                format: 'at-uri',
+                description: 'pipeline at-uri',
+              },
+              workflow: {
+                type: 'string',
+                description: 'workflow name',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  ShTangledPipeline: {
+    lexicon: 1,
+    id: 'sh.tangled.pipeline',
+    needsCbor: true,
+    needsType: true,
+    defs: {
+      main: {
+        type: 'record',
+        key: 'tid',
+        record: {
+          type: 'object',
+          required: ['triggerMetadata', 'workflows'],
+          properties: {
+            triggerMetadata: {
+              type: 'ref',
+              ref: 'lex:sh.tangled.pipeline#triggerMetadata',
+            },
+            workflows: {
+              type: 'array',
+              items: {
+                type: 'ref',
+                ref: 'lex:sh.tangled.pipeline#workflow',
+              },
+            },
+          },
+        },
+      },
+      triggerMetadata: {
+        type: 'object',
+        required: ['kind', 'repo'],
+        properties: {
+          kind: {
+            type: 'string',
+            enum: ['push', 'pull_request', 'manual'],
+          },
+          repo: {
+            type: 'ref',
+            ref: 'lex:sh.tangled.pipeline#triggerRepo',
+          },
+          push: {
+            type: 'ref',
+            ref: 'lex:sh.tangled.pipeline#pushTriggerData',
+          },
+          pullRequest: {
+            type: 'ref',
+            ref: 'lex:sh.tangled.pipeline#pullRequestTriggerData',
+          },
+          manual: {
+            type: 'ref',
+            ref: 'lex:sh.tangled.pipeline#manualTriggerData',
+          },
+        },
+      },
+      triggerRepo: {
+        type: 'object',
+        required: ['knot', 'did', 'repo', 'defaultBranch'],
+        properties: {
+          knot: {
+            type: 'string',
+          },
+          did: {
+            type: 'string',
+            format: 'did',
+          },
+          repo: {
+            type: 'string',
+          },
+          defaultBranch: {
+            type: 'string',
+          },
+        },
+      },
+      pushTriggerData: {
+        type: 'object',
+        required: ['ref', 'newSha', 'oldSha'],
+        properties: {
+          ref: {
+            type: 'string',
+          },
+          newSha: {
+            type: 'string',
+            minLength: 40,
+            maxLength: 40,
+          },
+          oldSha: {
+            type: 'string',
+            minLength: 40,
+            maxLength: 40,
+          },
+        },
+      },
+      pullRequestTriggerData: {
+        type: 'object',
+        required: ['sourceBranch', 'targetBranch', 'sourceSha', 'action'],
+        properties: {
+          sourceBranch: {
+            type: 'string',
+          },
+          targetBranch: {
+            type: 'string',
+          },
+          sourceSha: {
+            type: 'string',
+            minLength: 40,
+            maxLength: 40,
+          },
+          action: {
+            type: 'string',
+          },
+        },
+      },
+      manualTriggerData: {
+        type: 'object',
+        properties: {
+          inputs: {
+            type: 'array',
+            items: {
+              type: 'ref',
+              ref: 'lex:sh.tangled.pipeline#pair',
+            },
+          },
+        },
+      },
+      workflow: {
+        type: 'object',
+        required: ['name', 'engine', 'clone', 'raw'],
+        properties: {
+          name: {
+            type: 'string',
+          },
+          engine: {
+            type: 'string',
+          },
+          clone: {
+            type: 'ref',
+            ref: 'lex:sh.tangled.pipeline#cloneOpts',
+          },
+          raw: {
+            type: 'string',
+          },
+        },
+      },
+      cloneOpts: {
+        type: 'object',
+        required: ['skip', 'depth', 'submodules'],
+        properties: {
+          skip: {
+            type: 'boolean',
+          },
+          depth: {
+            type: 'integer',
+          },
+          submodules: {
+            type: 'boolean',
+          },
+        },
+      },
+      pair: {
+        type: 'object',
+        required: ['key', 'value'],
+        properties: {
+          key: {
+            type: 'string',
+          },
+          value: {
+            type: 'string',
+          },
+        },
+      },
+    },
+  },
+  ShTangledPipelineStatus: {
+    lexicon: 1,
+    id: 'sh.tangled.pipeline.status',
+    needsCbor: true,
+    needsType: true,
+    defs: {
+      main: {
+        type: 'record',
+        key: 'tid',
+        record: {
+          type: 'object',
+          required: ['pipeline', 'workflow', 'status', 'createdAt'],
+          properties: {
+            pipeline: {
+              type: 'string',
+              format: 'at-uri',
+              description: 'ATURI of the pipeline',
+            },
+            workflow: {
+              type: 'string',
+              format: 'at-uri',
+              description: 'name of the workflow within this pipeline',
+            },
+            status: {
+              type: 'string',
+              description: 'status of the workflow',
+              enum: [
+                'pending',
+                'running',
+                'failed',
+                'timeout',
+                'cancelled',
+                'success',
+              ],
+            },
+            createdAt: {
+              type: 'string',
+              format: 'datetime',
+              description: 'time of creation of this status update',
+            },
+            error: {
+              type: 'string',
+              description: 'error message if failed',
+            },
+            exitCode: {
+              type: 'integer',
+              description: 'exit code if failed',
+            },
+          },
+        },
+      },
+    },
+  },
+  ShTangledRepoPullStatusClosed: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.pull.status.closed',
+    needsCbor: true,
+    needsType: true,
+    defs: {
+      main: {
+        type: 'token',
+        description: 'closed pull request',
+      },
+    },
+  },
+  ShTangledRepoPullComment: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.pull.comment',
+    needsCbor: true,
+    needsType: true,
+    defs: {
+      main: {
+        type: 'record',
+        key: 'tid',
+        record: {
+          type: 'object',
+          required: ['pull', 'body', 'createdAt'],
+          properties: {
+            pull: {
+              type: 'string',
+              format: 'at-uri',
+            },
+            body: {
+              type: 'string',
+            },
+            createdAt: {
+              type: 'string',
+              format: 'datetime',
+            },
+            mentions: {
+              type: 'array',
+              items: {
+                type: 'string',
+                format: 'did',
+              },
+            },
+            references: {
+              type: 'array',
+              items: {
+                type: 'string',
+                format: 'at-uri',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  ShTangledRepoPullStatusMerged: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.pull.status.merged',
+    needsCbor: true,
+    needsType: true,
+    defs: {
+      main: {
+        type: 'token',
+        description: 'merged pull request',
+      },
+    },
+  },
+  ShTangledRepoPullStatusOpen: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.pull.status.open',
+    needsCbor: true,
+    needsType: true,
+    defs: {
+      main: {
+        type: 'token',
+        description: 'open pull request',
+      },
+    },
+  },
+  ShTangledRepoPull: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.pull',
+    needsCbor: true,
+    needsType: true,
+    defs: {
+      main: {
+        type: 'record',
+        key: 'tid',
+        record: {
+          type: 'object',
+          required: ['target', 'title', 'patchBlob', 'createdAt'],
+          properties: {
+            target: {
+              type: 'ref',
+              ref: 'lex:sh.tangled.repo.pull#target',
+            },
+            title: {
+              type: 'string',
+            },
+            body: {
+              type: 'string',
+            },
+            patch: {
+              type: 'string',
+              description: '(deprecated) use patchBlob instead',
+            },
+            patchBlob: {
+              type: 'blob',
+              accept: ['text/x-patch'],
+              description: 'patch content',
+            },
+            source: {
+              type: 'ref',
+              ref: 'lex:sh.tangled.repo.pull#source',
+            },
+            createdAt: {
+              type: 'string',
+              format: 'datetime',
+            },
+            mentions: {
+              type: 'array',
+              items: {
+                type: 'string',
+                format: 'did',
+              },
+            },
+            references: {
+              type: 'array',
+              items: {
+                type: 'string',
+                format: 'at-uri',
+              },
+            },
+          },
+        },
+      },
+      target: {
+        type: 'object',
+        required: ['repo', 'branch'],
+        properties: {
+          repo: {
+            type: 'string',
+            format: 'at-uri',
+          },
+          branch: {
+            type: 'string',
+          },
+        },
+      },
+      source: {
+        type: 'object',
+        required: ['branch', 'sha'],
+        properties: {
+          branch: {
+            type: 'string',
+          },
+          sha: {
+            type: 'string',
+            minLength: 40,
+            maxLength: 40,
+          },
+          repo: {
+            type: 'string',
+            format: 'at-uri',
+          },
+        },
+      },
+    },
+  },
+  ShTangledRepoPullStatus: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.pull.status',
+    needsCbor: true,
+    needsType: true,
+    defs: {
+      main: {
+        type: 'record',
+        key: 'tid',
+        record: {
+          type: 'object',
+          required: ['pull', 'status'],
+          properties: {
+            pull: {
+              type: 'string',
+              format: 'at-uri',
+            },
+            status: {
+              type: 'string',
+              description: 'status of the pull request',
+              knownValues: [
+                'sh.tangled.repo.pull.status.open',
+                'sh.tangled.repo.pull.status.closed',
+                'sh.tangled.repo.pull.status.merged',
+              ],
+              default: 'sh.tangled.repo.pull.status.open',
+            },
+          },
+        },
+      },
+    },
+  },
+  ShTangledRepoAddSecret: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.addSecret',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Add a CI secret',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['repo', 'key', 'value'],
+            properties: {
+              repo: {
+                type: 'string',
+                format: 'at-uri',
+              },
+              key: {
+                type: 'string',
+                maxLength: 50,
+                minLength: 1,
+              },
+              value: {
+                type: 'string',
+                maxLength: 200,
+                minLength: 1,
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  ShTangledRepoArchive: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.archive',
+    defs: {
+      main: {
+        type: 'query',
+        parameters: {
+          type: 'params',
+          required: ['repo', 'ref'],
+          properties: {
+            repo: {
+              type: 'string',
+              description:
+                "Repository identifier in format 'did:plc:.../repoName'",
+            },
+            ref: {
+              type: 'string',
+              description: 'Git reference (branch, tag, or commit SHA)',
+            },
+            format: {
+              type: 'string',
+              description: 'Archive format',
+              enum: ['tar', 'zip', 'tar.gz', 'tar.bz2', 'tar.xz'],
+              default: 'tar.gz',
+            },
+            prefix: {
+              type: 'string',
+              description: 'Prefix for files in the archive',
+            },
+          },
+        },
+        output: {
+          encoding: '*/*',
+          description: 'Binary archive data',
+        },
+        errors: [
+          {
+            name: 'RepoNotFound',
+            description: 'Repository not found or access denied',
+          },
+          {
+            name: 'RefNotFound',
+            description: 'Git reference not found',
+          },
+          {
+            name: 'InvalidRequest',
+            description: 'Invalid request parameters',
+          },
+          {
+            name: 'ArchiveError',
+            description: 'Failed to create archive',
+          },
+        ],
+      },
+    },
+  },
+  ShTangledRepoArtifact: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.artifact',
+    needsCbor: true,
+    needsType: true,
+    defs: {
+      main: {
+        type: 'record',
+        key: 'tid',
+        record: {
+          type: 'object',
+          required: ['name', 'repo', 'tag', 'createdAt', 'artifact'],
+          properties: {
+            name: {
+              type: 'string',
+              description: 'name of the artifact',
+            },
+            repo: {
+              type: 'string',
+              format: 'at-uri',
+              description: 'repo that this artifact is being uploaded to',
+            },
+            tag: {
+              type: 'bytes',
+              description:
+                'hash of the tag object that this artifact is attached to (only annotated tags are supported)',
+              minLength: 20,
+              maxLength: 20,
+            },
+            createdAt: {
+              type: 'string',
+              format: 'datetime',
+              description: 'time of creation of this artifact',
+            },
+            artifact: {
+              type: 'blob',
+              description: 'the artifact',
+              accept: ['*/*'],
+              maxSize: 52428800,
+            },
+          },
+        },
+      },
+    },
+  },
+  ShTangledRepoBlob: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.blob',
+    defs: {
+      main: {
+        type: 'query',
+        parameters: {
+          type: 'params',
+          required: ['repo', 'ref', 'path'],
+          properties: {
+            repo: {
+              type: 'string',
+              description:
+                "Repository identifier in format 'did:plc:.../repoName'",
+            },
+            ref: {
+              type: 'string',
+              description: 'Git reference (branch, tag, or commit SHA)',
+            },
+            path: {
+              type: 'string',
+              description: 'Path to the file within the repository',
+            },
+            raw: {
+              type: 'boolean',
+              description: 'Return raw file content instead of JSON response',
+              default: false,
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['ref', 'path'],
+            properties: {
+              ref: {
+                type: 'string',
+                description: 'The git reference used',
+              },
+              path: {
+                type: 'string',
+                description: 'The file path',
+              },
+              content: {
+                type: 'string',
+                description: 'File content (base64 encoded for binary files)',
+              },
+              encoding: {
+                type: 'string',
+                description: 'Content encoding',
+                enum: ['utf-8', 'base64'],
+              },
+              size: {
+                type: 'integer',
+                description: 'File size in bytes',
+              },
+              isBinary: {
+                type: 'boolean',
+                description: 'Whether the file is binary',
+              },
+              mimeType: {
+                type: 'string',
+                description: 'MIME type of the file',
+              },
+              submodule: {
+                type: 'ref',
+                ref: 'lex:sh.tangled.repo.blob#submodule',
+                description: 'Submodule information if path is a submodule',
+              },
+              lastCommit: {
+                type: 'ref',
+                ref: 'lex:sh.tangled.repo.blob#lastCommit',
+              },
+            },
+          },
+        },
+        errors: [
+          {
+            name: 'RepoNotFound',
+            description: 'Repository not found or access denied',
+          },
+          {
+            name: 'RefNotFound',
+            description: 'Git reference not found',
+          },
+          {
+            name: 'FileNotFound',
+            description: 'File not found at the specified path',
+          },
+          {
+            name: 'InvalidRequest',
+            description: 'Invalid request parameters',
+          },
+        ],
+      },
+      lastCommit: {
+        type: 'object',
+        required: ['hash', 'message', 'when'],
+        properties: {
+          hash: {
+            type: 'string',
+            description: 'Commit hash',
+          },
+          message: {
+            type: 'string',
+            description: 'Commit message',
+          },
+          author: {
+            type: 'ref',
+            ref: 'lex:sh.tangled.repo.blob#signature',
+          },
+          when: {
+            type: 'string',
+            format: 'datetime',
+            description: 'Commit timestamp',
+          },
+        },
+      },
+      signature: {
+        type: 'object',
+        required: ['name', 'email', 'when'],
+        properties: {
+          name: {
+            type: 'string',
+            description: 'Author name',
+          },
+          email: {
+            type: 'string',
+            description: 'Author email',
+          },
+          when: {
+            type: 'string',
+            format: 'datetime',
+            description: 'Author timestamp',
+          },
+        },
+      },
+      submodule: {
+        type: 'object',
+        required: ['name', 'url'],
+        properties: {
+          name: {
+            type: 'string',
+            description: 'Submodule name',
+          },
+          url: {
+            type: 'string',
+            description: 'Submodule repository URL',
+          },
+          branch: {
+            type: 'string',
+            description: 'Branch to track in the submodule',
+          },
+        },
+      },
+    },
+  },
+  ShTangledRepoBranch: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.branch',
+    defs: {
+      main: {
+        type: 'query',
+        parameters: {
+          type: 'params',
+          required: ['repo', 'name'],
+          properties: {
+            repo: {
+              type: 'string',
+              description:
+                "Repository identifier in format 'did:plc:.../repoName'",
+            },
+            name: {
+              type: 'string',
+              description: 'Branch name to get information for',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['name', 'hash', 'when'],
+            properties: {
+              name: {
+                type: 'string',
+                description: 'Branch name',
+              },
+              hash: {
+                type: 'string',
+                description: 'Latest commit hash on this branch',
+              },
+              shortHash: {
+                type: 'string',
+                description: 'Short commit hash',
+              },
+              when: {
+                type: 'string',
+                format: 'datetime',
+                description: 'Timestamp of latest commit',
+              },
+              message: {
+                type: 'string',
+                description: 'Latest commit message',
+              },
+              author: {
+                type: 'ref',
+                ref: 'lex:sh.tangled.repo.branch#signature',
+              },
+              isDefault: {
+                type: 'boolean',
+                description: 'Whether this is the default branch',
+              },
+            },
+          },
+        },
+        errors: [
+          {
+            name: 'RepoNotFound',
+            description: 'Repository not found or access denied',
+          },
+          {
+            name: 'BranchNotFound',
+            description: 'Branch not found',
+          },
+          {
+            name: 'InvalidRequest',
+            description: 'Invalid request parameters',
+          },
+        ],
+      },
+      signature: {
+        type: 'object',
+        required: ['name', 'email', 'when'],
+        properties: {
+          name: {
+            type: 'string',
+            description: 'Author name',
+          },
+          email: {
+            type: 'string',
+            description: 'Author email',
+          },
+          when: {
+            type: 'string',
+            format: 'datetime',
+            description: 'Author timestamp',
+          },
+        },
+      },
+    },
+  },
+  ShTangledRepoBranches: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.branches',
+    defs: {
+      main: {
+        type: 'query',
+        parameters: {
+          type: 'params',
+          required: ['repo'],
+          properties: {
+            repo: {
+              type: 'string',
+              description:
+                "Repository identifier in format 'did:plc:.../repoName'",
+            },
+            limit: {
+              type: 'integer',
+              description: 'Maximum number of branches to return',
+              minimum: 1,
+              maximum: 100,
+              default: 50,
+            },
+            cursor: {
+              type: 'string',
+              description: 'Pagination cursor',
+            },
+          },
+        },
+        output: {
+          encoding: '*/*',
+        },
+        errors: [
+          {
+            name: 'RepoNotFound',
+            description: 'Repository not found or access denied',
+          },
+          {
+            name: 'InvalidRequest',
+            description: 'Invalid request parameters',
+          },
+        ],
+      },
+    },
+  },
+  ShTangledRepoCollaborator: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.collaborator',
+    needsCbor: true,
+    needsType: true,
+    defs: {
+      main: {
+        type: 'record',
+        key: 'tid',
+        record: {
+          type: 'object',
+          required: ['subject', 'repo', 'createdAt'],
+          properties: {
+            subject: {
+              type: 'string',
+              format: 'did',
+            },
+            repo: {
+              type: 'string',
+              description: 'repo to add this user to',
+              format: 'at-uri',
+            },
+            createdAt: {
+              type: 'string',
+              format: 'datetime',
+            },
+          },
+        },
+      },
+    },
+  },
+  ShTangledRepoCompare: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.compare',
+    defs: {
+      main: {
+        type: 'query',
+        parameters: {
+          type: 'params',
+          required: ['repo', 'rev1', 'rev2'],
+          properties: {
+            repo: {
+              type: 'string',
+              description:
+                "Repository identifier in format 'did:plc:.../repoName'",
+            },
+            rev1: {
+              type: 'string',
+              description: 'First revision (commit, branch, or tag)',
+            },
+            rev2: {
+              type: 'string',
+              description: 'Second revision (commit, branch, or tag)',
+            },
+          },
+        },
+        output: {
+          encoding: '*/*',
+          description: 'Compare output in application/json',
+        },
+        errors: [
+          {
+            name: 'RepoNotFound',
+            description: 'Repository not found or access denied',
+          },
+          {
+            name: 'RevisionNotFound',
+            description: 'One or both revisions not found',
+          },
+          {
+            name: 'InvalidRequest',
+            description: 'Invalid request parameters',
+          },
+          {
+            name: 'CompareError',
+            description: 'Failed to compare revisions',
+          },
+        ],
+      },
+    },
+  },
+  ShTangledRepoCreate: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.create',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Create a new repository',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['rkey'],
+            properties: {
+              rkey: {
+                type: 'string',
+                description: 'Rkey of the repository record',
+              },
+              defaultBranch: {
+                type: 'string',
+                description: 'Default branch to push to',
+              },
+              source: {
+                type: 'string',
+                description:
+                  'A source URL to clone from, populate this when forking or importing a repository.',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  ShTangledRepoSetDefaultBranch: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.setDefaultBranch',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Set the default branch for a repository',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['repo', 'defaultBranch'],
+            properties: {
+              repo: {
+                type: 'string',
+                format: 'at-uri',
+              },
+              defaultBranch: {
+                type: 'string',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  ShTangledRepoDelete: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.delete',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Delete a repository',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['did', 'name', 'rkey'],
+            properties: {
+              did: {
+                type: 'string',
+                format: 'did',
+                description: 'DID of the repository owner',
+              },
+              name: {
+                type: 'string',
+                description: 'Name of the repository to delete',
+              },
+              rkey: {
+                type: 'string',
+                description: 'Rkey of the repository record',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  ShTangledRepoDeleteBranch: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.deleteBranch',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Delete a branch on this repository',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['repo', 'branch'],
+            properties: {
+              repo: {
+                type: 'string',
+                format: 'at-uri',
+              },
+              branch: {
+                type: 'string',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  ShTangledRepoDiff: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.diff',
+    defs: {
+      main: {
+        type: 'query',
+        parameters: {
+          type: 'params',
+          required: ['repo', 'ref'],
+          properties: {
+            repo: {
+              type: 'string',
+              description:
+                "Repository identifier in format 'did:plc:.../repoName'",
+            },
+            ref: {
+              type: 'string',
+              description: 'Git reference (branch, tag, or commit SHA)',
+            },
+          },
+        },
+        output: {
+          encoding: '*/*',
+        },
+        errors: [
+          {
+            name: 'RepoNotFound',
+            description: 'Repository not found or access denied',
+          },
+          {
+            name: 'RefNotFound',
+            description: 'Git reference not found',
+          },
+          {
+            name: 'InvalidRequest',
+            description: 'Invalid request parameters',
+          },
+        ],
+      },
+    },
+  },
+  ShTangledRepoForkStatus: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.forkStatus',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Check fork status relative to upstream source',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['did', 'name', 'source', 'branch', 'hiddenRef'],
+            properties: {
+              did: {
+                type: 'string',
+                format: 'did',
+                description: 'DID of the fork owner',
+              },
+              name: {
+                type: 'string',
+                description: 'Name of the forked repository',
+              },
+              source: {
+                type: 'string',
+                description: 'Source repository URL',
+              },
+              branch: {
+                type: 'string',
+                description: 'Branch to check status for',
+              },
+              hiddenRef: {
+                type: 'string',
+                description: 'Hidden ref to use for comparison',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['status'],
+            properties: {
+              status: {
+                type: 'integer',
+                description:
+                  'Fork status: 0=UpToDate, 1=FastForwardable, 2=Conflict, 3=MissingBranch',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  ShTangledRepoForkSync: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.forkSync',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Sync a forked repository with its upstream source',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['did', 'source', 'name', 'branch'],
+            properties: {
+              did: {
+                type: 'string',
+                format: 'did',
+                description: 'DID of the fork owner',
+              },
+              source: {
+                type: 'string',
+                format: 'at-uri',
+                description: 'AT-URI of the source repository',
+              },
+              name: {
+                type: 'string',
+                description: 'Name of the forked repository',
+              },
+              branch: {
+                type: 'string',
+                description: 'Branch to sync',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  ShTangledRepoGetDefaultBranch: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.getDefaultBranch',
+    defs: {
+      main: {
+        type: 'query',
+        parameters: {
+          type: 'params',
+          required: ['repo'],
+          properties: {
+            repo: {
+              type: 'string',
+              description:
+                "Repository identifier in format 'did:plc:.../repoName'",
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['name', 'hash', 'when'],
+            properties: {
+              name: {
+                type: 'string',
+                description: 'Default branch name',
+              },
+              hash: {
+                type: 'string',
+                description: 'Latest commit hash on default branch',
+              },
+              shortHash: {
+                type: 'string',
+                description: 'Short commit hash',
+              },
+              when: {
+                type: 'string',
+                format: 'datetime',
+                description: 'Timestamp of latest commit',
+              },
+              message: {
+                type: 'string',
+                description: 'Latest commit message',
+              },
+              author: {
+                type: 'ref',
+                ref: 'lex:sh.tangled.repo.getDefaultBranch#signature',
+              },
+            },
+          },
+        },
+        errors: [
+          {
+            name: 'RepoNotFound',
+            description: 'Repository not found or access denied',
+          },
+          {
+            name: 'InvalidRequest',
+            description: 'Invalid request parameters',
+          },
+        ],
+      },
+      signature: {
+        type: 'object',
+        required: ['name', 'email', 'when'],
+        properties: {
+          name: {
+            type: 'string',
+            description: 'Author name',
+          },
+          email: {
+            type: 'string',
+            description: 'Author email',
+          },
+          when: {
+            type: 'string',
+            format: 'datetime',
+            description: 'Author timestamp',
+          },
+        },
+      },
+    },
+  },
+  ShTangledRepoHiddenRef: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.hiddenRef',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Create a hidden ref in a repository',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['repo', 'forkRef', 'remoteRef'],
+            properties: {
+              repo: {
+                type: 'string',
+                format: 'at-uri',
+                description: 'AT-URI of the repository',
+              },
+              forkRef: {
+                type: 'string',
+                description: 'Fork reference name',
+              },
+              remoteRef: {
+                type: 'string',
+                description: 'Remote reference name',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['success'],
+            properties: {
+              success: {
+                type: 'boolean',
+                description: 'Whether the hidden ref was created successfully',
+              },
+              ref: {
+                type: 'string',
+                description: 'The created hidden ref name',
+              },
+              error: {
+                type: 'string',
+                description: 'Error message if creation failed',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  ShTangledRepoLanguages: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.languages',
+    defs: {
+      main: {
+        type: 'query',
+        parameters: {
+          type: 'params',
+          required: ['repo'],
+          properties: {
+            repo: {
+              type: 'string',
+              description:
+                "Repository identifier in format 'did:plc:.../repoName'",
+            },
+            ref: {
+              type: 'string',
+              description: 'Git reference (branch, tag, or commit SHA)',
+              default: 'HEAD',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['ref', 'languages'],
+            properties: {
+              ref: {
+                type: 'string',
+                description: 'The git reference used',
+              },
+              languages: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:sh.tangled.repo.languages#language',
+                },
+              },
+              totalSize: {
+                type: 'integer',
+                description: 'Total size of all analyzed files in bytes',
+              },
+              totalFiles: {
+                type: 'integer',
+                description: 'Total number of files analyzed',
+              },
+            },
+          },
+        },
+        errors: [
+          {
+            name: 'RepoNotFound',
+            description: 'Repository not found or access denied',
+          },
+          {
+            name: 'RefNotFound',
+            description: 'Git reference not found',
+          },
+          {
+            name: 'InvalidRequest',
+            description: 'Invalid request parameters',
+          },
+        ],
+      },
+      language: {
+        type: 'object',
+        required: ['name', 'size', 'percentage'],
+        properties: {
+          name: {
+            type: 'string',
+            description: 'Programming language name',
+          },
+          size: {
+            type: 'integer',
+            description: 'Total size of files in this language (bytes)',
+          },
+          percentage: {
+            type: 'integer',
+            description: 'Percentage of total codebase (0-100)',
+          },
+          fileCount: {
+            type: 'integer',
+            description: 'Number of files in this language',
+          },
+          color: {
+            type: 'string',
+            description: 'Hex color code for this language',
+          },
+          extensions: {
+            type: 'array',
+            items: {
+              type: 'string',
+            },
+            description: 'File extensions associated with this language',
+          },
+        },
+      },
+    },
+  },
+  ShTangledRepoListSecrets: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.listSecrets',
+    defs: {
+      main: {
+        type: 'query',
+        parameters: {
+          type: 'params',
+          required: ['repo'],
+          properties: {
+            repo: {
+              type: 'string',
+              format: 'at-uri',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['secrets'],
+            properties: {
+              secrets: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:sh.tangled.repo.listSecrets#secret',
+                },
+              },
+            },
+          },
+        },
+      },
+      secret: {
+        type: 'object',
+        required: ['repo', 'key', 'createdAt', 'createdBy'],
+        properties: {
+          repo: {
+            type: 'string',
+            format: 'at-uri',
+          },
+          key: {
+            type: 'string',
+            maxLength: 50,
+            minLength: 1,
+          },
+          createdAt: {
+            type: 'string',
+            format: 'datetime',
+          },
+          createdBy: {
+            type: 'string',
+            format: 'did',
+          },
+        },
+      },
+    },
+  },
+  ShTangledRepoLog: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.log',
+    defs: {
+      main: {
+        type: 'query',
+        parameters: {
+          type: 'params',
+          required: ['repo', 'ref'],
+          properties: {
+            repo: {
+              type: 'string',
+              description:
+                "Repository identifier in format 'did:plc:.../repoName'",
+            },
+            ref: {
+              type: 'string',
+              description: 'Git reference (branch, tag, or commit SHA)',
+            },
+            path: {
+              type: 'string',
+              description: 'Path to filter commits by',
+              default: '',
+            },
+            limit: {
+              type: 'integer',
+              description: 'Maximum number of commits to return',
+              minimum: 1,
+              maximum: 100,
+              default: 50,
+            },
+            cursor: {
+              type: 'string',
+              description: 'Pagination cursor (commit SHA)',
+            },
+          },
+        },
+        output: {
+          encoding: '*/*',
+        },
+        errors: [
+          {
+            name: 'RepoNotFound',
+            description: 'Repository not found or access denied',
+          },
+          {
+            name: 'RefNotFound',
+            description: 'Git reference not found',
+          },
+          {
+            name: 'PathNotFound',
+            description: 'Path not found in repository',
+          },
+          {
+            name: 'InvalidRequest',
+            description: 'Invalid request parameters',
+          },
+        ],
+      },
+    },
+  },
+  ShTangledRepoMerge: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.merge',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Merge a patch into a repository branch',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['did', 'name', 'patch', 'branch'],
+            properties: {
+              did: {
+                type: 'string',
+                format: 'did',
+                description: 'DID of the repository owner',
+              },
+              name: {
+                type: 'string',
+                description: 'Name of the repository',
+              },
+              patch: {
+                type: 'string',
+                description: 'Patch content to merge',
+              },
+              branch: {
+                type: 'string',
+                description: 'Target branch to merge into',
+              },
+              authorName: {
+                type: 'string',
+                description: 'Author name for the merge commit',
+              },
+              authorEmail: {
+                type: 'string',
+                description: 'Author email for the merge commit',
+              },
+              commitBody: {
+                type: 'string',
+                description: 'Additional commit message body',
+              },
+              commitMessage: {
+                type: 'string',
+                description: 'Merge commit message',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  ShTangledRepoMergeCheck: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.mergeCheck',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Check if a merge is possible between two branches',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['did', 'name', 'patch', 'branch'],
+            properties: {
+              did: {
+                type: 'string',
+                format: 'did',
+                description: 'DID of the repository owner',
+              },
+              name: {
+                type: 'string',
+                description: 'Name of the repository',
+              },
+              patch: {
+                type: 'string',
+                description:
+                  'Patch or pull request to check for merge conflicts',
+              },
+              branch: {
+                type: 'string',
+                description: 'Target branch to merge into',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['is_conflicted'],
+            properties: {
+              is_conflicted: {
+                type: 'boolean',
+                description: 'Whether the merge has conflicts',
+              },
+              conflicts: {
+                type: 'array',
+                description: 'List of files with merge conflicts',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:sh.tangled.repo.mergeCheck#conflictInfo',
+                },
+              },
+              message: {
+                type: 'string',
+                description: 'Additional message about the merge check',
+              },
+              error: {
+                type: 'string',
+                description: 'Error message if check failed',
+              },
+            },
+          },
+        },
+      },
+      conflictInfo: {
+        type: 'object',
+        required: ['filename', 'reason'],
+        properties: {
+          filename: {
+            type: 'string',
+            description: 'Name of the conflicted file',
+          },
+          reason: {
+            type: 'string',
+            description: 'Reason for the conflict',
+          },
+        },
+      },
+    },
+  },
+  ShTangledRepoRemoveSecret: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.removeSecret',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Remove a CI secret',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['repo', 'key'],
+            properties: {
+              repo: {
+                type: 'string',
+                format: 'at-uri',
+              },
+              key: {
+                type: 'string',
+                maxLength: 50,
+                minLength: 1,
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  ShTangledRepo: {
+    lexicon: 1,
+    id: 'sh.tangled.repo',
+    needsCbor: true,
+    needsType: true,
+    defs: {
+      main: {
+        type: 'record',
+        key: 'tid',
+        record: {
+          type: 'object',
+          required: ['name', 'knot', 'createdAt'],
+          properties: {
+            name: {
+              type: 'string',
+              description: 'name of the repo',
+            },
+            knot: {
+              type: 'string',
+              description: 'knot where the repo was created',
+            },
+            spindle: {
+              type: 'string',
+              description: 'CI runner to send jobs to and receive results from',
+            },
+            description: {
+              type: 'string',
+              minGraphemes: 1,
+              maxGraphemes: 140,
+            },
+            website: {
+              type: 'string',
+              format: 'uri',
+              description: 'Any URI related to the repo',
+            },
+            topics: {
+              type: 'array',
+              description: 'Topics related to the repo',
+              items: {
+                type: 'string',
+                minLength: 1,
+                maxLength: 50,
+              },
+              maxLength: 50,
+            },
+            source: {
+              type: 'string',
+              format: 'uri',
+              description: 'source of the repo',
+            },
+            labels: {
+              type: 'array',
+              description: 'List of labels that this repo subscribes to',
+              items: {
+                type: 'string',
+                format: 'at-uri',
+              },
+            },
+            createdAt: {
+              type: 'string',
+              format: 'datetime',
+            },
+          },
+        },
+      },
+    },
+  },
+  ShTangledRepoTag: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.tag',
+    defs: {
+      main: {
+        type: 'query',
+        parameters: {
+          type: 'params',
+          required: ['repo', 'tag'],
+          properties: {
+            repo: {
+              type: 'string',
+              description:
+                "Repository identifier in format 'did:plc:.../repoName'",
+            },
+            tag: {
+              type: 'string',
+              description: 'Name of tag, such as v1.3.0',
+            },
+          },
+        },
+        output: {
+          encoding: '*/*',
+        },
+        errors: [
+          {
+            name: 'RepoNotFound',
+            description: 'Repository not found or access denied',
+          },
+          {
+            name: 'TagNotFound',
+            description: 'Tag not found',
+          },
+          {
+            name: 'InvalidRequest',
+            description: 'Invalid request parameters',
+          },
+        ],
+      },
+    },
+  },
+  ShTangledRepoTags: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.tags',
+    defs: {
+      main: {
+        type: 'query',
+        parameters: {
+          type: 'params',
+          required: ['repo'],
+          properties: {
+            repo: {
+              type: 'string',
+              description:
+                "Repository identifier in format 'did:plc:.../repoName'",
+            },
+            limit: {
+              type: 'integer',
+              description: 'Maximum number of tags to return',
+              minimum: 1,
+              maximum: 100,
+              default: 50,
+            },
+            cursor: {
+              type: 'string',
+              description: 'Pagination cursor',
+            },
+          },
+        },
+        output: {
+          encoding: '*/*',
+        },
+        errors: [
+          {
+            name: 'RepoNotFound',
+            description: 'Repository not found or access denied',
+          },
+          {
+            name: 'InvalidRequest',
+            description: 'Invalid request parameters',
+          },
+        ],
+      },
+    },
+  },
+  ShTangledRepoTree: {
+    lexicon: 1,
+    id: 'sh.tangled.repo.tree',
+    defs: {
+      main: {
+        type: 'query',
+        parameters: {
+          type: 'params',
+          required: ['repo', 'ref'],
+          properties: {
+            repo: {
+              type: 'string',
+              description:
+                "Repository identifier in format 'did:plc:.../repoName'",
+            },
+            ref: {
+              type: 'string',
+              description: 'Git reference (branch, tag, or commit SHA)',
+            },
+            path: {
+              type: 'string',
+              description: 'Path within the repository tree',
+              default: '',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['ref', 'files'],
+            properties: {
+              ref: {
+                type: 'string',
+                description: 'The git reference used',
+              },
+              parent: {
+                type: 'string',
+                description: 'The parent path in the tree',
+              },
+              dotdot: {
+                type: 'string',
+                description: 'Parent directory path',
+              },
+              readme: {
+                type: 'ref',
+                ref: 'lex:sh.tangled.repo.tree#readme',
+                description: 'Readme for this file tree',
+              },
+              lastCommit: {
+                type: 'ref',
+                ref: 'lex:sh.tangled.repo.tree#lastCommit',
+              },
+              files: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:sh.tangled.repo.tree#treeEntry',
+                },
+              },
+            },
+          },
+        },
+        errors: [
+          {
+            name: 'RepoNotFound',
+            description: 'Repository not found or access denied',
+          },
+          {
+            name: 'RefNotFound',
+            description: 'Git reference not found',
+          },
+          {
+            name: 'PathNotFound',
+            description: 'Path not found in repository tree',
+          },
+          {
+            name: 'InvalidRequest',
+            description: 'Invalid request parameters',
+          },
+        ],
+      },
+      readme: {
+        type: 'object',
+        required: ['filename', 'contents'],
+        properties: {
+          filename: {
+            type: 'string',
+            description: 'Name of the readme file',
+          },
+          contents: {
+            type: 'string',
+            description: 'Contents of the readme file',
+          },
+        },
+      },
+      treeEntry: {
+        type: 'object',
+        required: ['name', 'mode', 'size'],
+        properties: {
+          name: {
+            type: 'string',
+            description: 'Relative file or directory name',
+          },
+          mode: {
+            type: 'string',
+            description: 'File mode',
+          },
+          size: {
+            type: 'integer',
+            description: 'File size in bytes',
+          },
+          last_commit: {
+            type: 'ref',
+            ref: 'lex:sh.tangled.repo.tree#lastCommit',
+          },
+        },
+      },
+      lastCommit: {
+        type: 'object',
+        required: ['hash', 'message', 'when'],
+        properties: {
+          hash: {
+            type: 'string',
+            description: 'Commit hash',
+          },
+          message: {
+            type: 'string',
+            description: 'Commit message',
+          },
+          author: {
+            type: 'ref',
+            ref: 'lex:sh.tangled.repo.tree#signature',
+          },
+          when: {
+            type: 'string',
+            format: 'datetime',
+            description: 'Commit timestamp',
+          },
+        },
+      },
+      signature: {
+        type: 'object',
+        required: ['name', 'email', 'when'],
+        properties: {
+          name: {
+            type: 'string',
+            description: 'Author name',
+          },
+          email: {
+            type: 'string',
+            description: 'Author email',
+          },
+          when: {
+            type: 'string',
+            format: 'datetime',
+            description: 'Author timestamp',
+          },
+        },
+      },
+    },
+  },
+  ShTangledSpindleMember: {
+    lexicon: 1,
+    id: 'sh.tangled.spindle.member',
+    needsCbor: true,
+    needsType: true,
+    defs: {
+      main: {
+        type: 'record',
+        key: 'tid',
+        record: {
+          type: 'object',
+          required: ['subject', 'instance', 'createdAt'],
+          properties: {
+            subject: {
+              type: 'string',
+              format: 'did',
+            },
+            instance: {
+              type: 'string',
+              description:
+                'spindle instance that the subject is now a member of',
+            },
+            createdAt: {
+              type: 'string',
+              format: 'datetime',
+            },
+          },
+        },
+      },
+    },
+  },
+  ShTangledSpindle: {
+    lexicon: 1,
+    id: 'sh.tangled.spindle',
+    needsCbor: true,
+    needsType: true,
+    defs: {
+      main: {
+        type: 'record',
+        key: 'any',
+        record: {
+          type: 'object',
+          required: ['createdAt'],
+          properties: {
+            createdAt: {
+              type: 'string',
+              format: 'datetime',
+            },
+          },
+        },
+      },
+    },
+  },
+  ShTangledString: {
+    lexicon: 1,
+    id: 'sh.tangled.string',
+    needsCbor: true,
+    needsType: true,
+    defs: {
+      main: {
+        type: 'record',
+        key: 'tid',
+        record: {
+          type: 'object',
+          required: ['filename', 'description', 'createdAt', 'contents'],
+          properties: {
+            filename: {
+              type: 'string',
+              maxGraphemes: 140,
+              minGraphemes: 1,
+            },
+            description: {
+              type: 'string',
+              maxGraphemes: 280,
+            },
+            createdAt: {
+              type: 'string',
+              format: 'datetime',
+            },
+            contents: {
+              type: 'string',
+              minGraphemes: 1,
+            },
+          },
+        },
+      },
+    },
+  },
+} as const satisfies Record<string, LexiconDoc>
+export const schemas = Object.values(schemaDict) satisfies LexiconDoc[]
+export const lexicons: Lexicons = new Lexicons(schemas)
+
+export function validate<T extends { $type: string }>(
+  v: unknown,
+  id: string,
+  hash: string,
+  requiredType: true,
+): ValidationResult<T>
+export function validate<T extends { $type?: string }>(
+  v: unknown,
+  id: string,
+  hash: string,
+  requiredType?: false,
+): ValidationResult<T>
+export function validate(
+  v: unknown,
+  id: string,
+  hash: string,
+  requiredType?: boolean,
+): ValidationResult {
+  return (requiredType ? is$typed : maybe$typed)(v, id, hash)
+    ? lexicons.validate(`${id}#${hash}`, v)
+    : {
+        success: false,
+        error: new ValidationError(
+          `Must be an object with "${hash === 'main' ? id : `${id}#${hash}`}" $type property`,
+        ),
+      }
+}
+
+export const ids = {
+  ShTangledActorProfile: 'sh.tangled.actor.profile',
+  ShTangledFeedReaction: 'sh.tangled.feed.reaction',
+  ShTangledFeedStar: 'sh.tangled.feed.star',
+  ShTangledGitRefUpdate: 'sh.tangled.git.refUpdate',
+  ShTangledGraphFollow: 'sh.tangled.graph.follow',
+  ShTangledRepoIssueStateClosed: 'sh.tangled.repo.issue.state.closed',
+  ShTangledRepoIssueComment: 'sh.tangled.repo.issue.comment',
+  ShTangledRepoIssue: 'sh.tangled.repo.issue',
+  ShTangledRepoIssueStateOpen: 'sh.tangled.repo.issue.state.open',
+  ShTangledRepoIssueState: 'sh.tangled.repo.issue.state',
+  ShTangledKnot: 'sh.tangled.knot',
+  ShTangledKnotListKeys: 'sh.tangled.knot.listKeys',
+  ShTangledKnotMember: 'sh.tangled.knot.member',
+  ShTangledKnotVersion: 'sh.tangled.knot.version',
+  ShTangledLabelDefinition: 'sh.tangled.label.definition',
+  ShTangledLabelOp: 'sh.tangled.label.op',
+  ShTangledPipelineCancelPipeline: 'sh.tangled.pipeline.cancelPipeline',
+  ShTangledPipeline: 'sh.tangled.pipeline',
+  ShTangledPipelineStatus: 'sh.tangled.pipeline.status',
+  ShTangledRepoPullStatusClosed: 'sh.tangled.repo.pull.status.closed',
+  ShTangledRepoPullComment: 'sh.tangled.repo.pull.comment',
+  ShTangledRepoPullStatusMerged: 'sh.tangled.repo.pull.status.merged',
+  ShTangledRepoPullStatusOpen: 'sh.tangled.repo.pull.status.open',
+  ShTangledRepoPull: 'sh.tangled.repo.pull',
+  ShTangledRepoPullStatus: 'sh.tangled.repo.pull.status',
+  ShTangledRepoAddSecret: 'sh.tangled.repo.addSecret',
+  ShTangledRepoArchive: 'sh.tangled.repo.archive',
+  ShTangledRepoArtifact: 'sh.tangled.repo.artifact',
+  ShTangledRepoBlob: 'sh.tangled.repo.blob',
+  ShTangledRepoBranch: 'sh.tangled.repo.branch',
+  ShTangledRepoBranches: 'sh.tangled.repo.branches',
+  ShTangledRepoCollaborator: 'sh.tangled.repo.collaborator',
+  ShTangledRepoCompare: 'sh.tangled.repo.compare',
+  ShTangledRepoCreate: 'sh.tangled.repo.create',
+  ShTangledRepoSetDefaultBranch: 'sh.tangled.repo.setDefaultBranch',
+  ShTangledRepoDelete: 'sh.tangled.repo.delete',
+  ShTangledRepoDeleteBranch: 'sh.tangled.repo.deleteBranch',
+  ShTangledRepoDiff: 'sh.tangled.repo.diff',
+  ShTangledRepoForkStatus: 'sh.tangled.repo.forkStatus',
+  ShTangledRepoForkSync: 'sh.tangled.repo.forkSync',
+  ShTangledRepoGetDefaultBranch: 'sh.tangled.repo.getDefaultBranch',
+  ShTangledRepoHiddenRef: 'sh.tangled.repo.hiddenRef',
+  ShTangledRepoLanguages: 'sh.tangled.repo.languages',
+  ShTangledRepoListSecrets: 'sh.tangled.repo.listSecrets',
+  ShTangledRepoLog: 'sh.tangled.repo.log',
+  ShTangledRepoMerge: 'sh.tangled.repo.merge',
+  ShTangledRepoMergeCheck: 'sh.tangled.repo.mergeCheck',
+  ShTangledRepoRemoveSecret: 'sh.tangled.repo.removeSecret',
+  ShTangledRepo: 'sh.tangled.repo',
+  ShTangledRepoTag: 'sh.tangled.repo.tag',
+  ShTangledRepoTags: 'sh.tangled.repo.tags',
+  ShTangledRepoTree: 'sh.tangled.repo.tree',
+  ShTangledSpindleMember: 'sh.tangled.spindle.member',
+  ShTangledSpindle: 'sh.tangled.spindle',
+  ShTangledString: 'sh.tangled.string',
+} as const

src/lexicon/types/sh/tangled/actor/profile.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.actor.profile'
+
+export interface Main {
+  $type: 'sh.tangled.actor.profile'
+  /** Small image to be displayed next to posts from account. AKA, 'profile picture' */
+  avatar?: BlobRef
+  /** Free-form profile description text. */
+  description?: string
+  links?: string[]
+  stats?: (
+    | 'merged-pull-request-count'
+    | 'closed-pull-request-count'
+    | 'open-pull-request-count'
+    | 'open-issue-count'
+    | 'closed-issue-count'
+    | 'repository-count'
+    | 'star-count'
+  )[]
+  /** Include link to this account on Bluesky. */
+  bluesky: boolean
+  /** Free-form location text. */
+  location?: string
+  /** Any ATURI, it is up to appviews to validate these fields. */
+  pinnedRepositories?: string[]
+  /** Preferred gender pronouns. */
+  pronouns?: string
+  [k: string]: unknown
+}
+
+const hashMain = 'main'
+
+export function isMain<V>(v: V) {
+  return is$typed(v, id, hashMain)
+}
+
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain, true)
+}
+
+export {
+  type Main as Record,
+  isMain as isRecord,
+  validateMain as validateRecord,
+}

src/lexicon/types/sh/tangled/feed/reaction.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.feed.reaction'
+
+export interface Main {
+  $type: 'sh.tangled.feed.reaction'
+  subject: string
+  reaction: '👍' | '👎' | '😆' | '🎉' | '🫤' | '❤️' | '🚀' | '👀'
+  createdAt: string
+  [k: string]: unknown
+}
+
+const hashMain = 'main'
+
+export function isMain<V>(v: V) {
+  return is$typed(v, id, hashMain)
+}
+
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain, true)
+}
+
+export {
+  type Main as Record,
+  isMain as isRecord,
+  validateMain as validateRecord,
+}

src/lexicon/types/sh/tangled/feed/star.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.feed.star'
+
+export interface Main {
+  $type: 'sh.tangled.feed.star'
+  subject: string
+  createdAt: string
+  [k: string]: unknown
+}
+
+const hashMain = 'main'
+
+export function isMain<V>(v: V) {
+  return is$typed(v, id, hashMain)
+}
+
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain, true)
+}
+
+export {
+  type Main as Record,
+  isMain as isRecord,
+  validateMain as validateRecord,
+}

src/lexicon/types/sh/tangled/git/refUpdate.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.git.refUpdate'
+
+export interface Main {
+  $type: 'sh.tangled.git.refUpdate'
+  /** Ref being updated */
+  ref: string
+  /** did of the user that pushed this ref */
+  committerDid: string
+  /** did of the owner of the repo */
+  repoDid: string
+  /** name of the repo */
+  repoName: string
+  /** old SHA of this ref */
+  oldSha: string
+  /** new SHA of this ref */
+  newSha: string
+  meta: Meta
+  [k: string]: unknown
+}
+
+const hashMain = 'main'
+
+export function isMain<V>(v: V) {
+  return is$typed(v, id, hashMain)
+}
+
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain, true)
+}
+
+export {
+  type Main as Record,
+  isMain as isRecord,
+  validateMain as validateRecord,
+}
+
+export interface Meta {
+  $type?: 'sh.tangled.git.refUpdate#meta'
+  isDefaultRef: boolean
+  langBreakdown?: LangBreakdown
+  commitCount: CommitCountBreakdown
+}
+
+const hashMeta = 'meta'
+
+export function isMeta<V>(v: V) {
+  return is$typed(v, id, hashMeta)
+}
+
+export function validateMeta<V>(v: V) {
+  return validate<Meta & V>(v, id, hashMeta)
+}
+
+export interface LangBreakdown {
+  $type?: 'sh.tangled.git.refUpdate#langBreakdown'
+  inputs?: IndividualLanguageSize[]
+}
+
+const hashLangBreakdown = 'langBreakdown'
+
+export function isLangBreakdown<V>(v: V) {
+  return is$typed(v, id, hashLangBreakdown)
+}
+
+export function validateLangBreakdown<V>(v: V) {
+  return validate<LangBreakdown & V>(v, id, hashLangBreakdown)
+}
+
+export interface IndividualLanguageSize {
+  $type?: 'sh.tangled.git.refUpdate#individualLanguageSize'
+  lang: string
+  size: number
+}
+
+const hashIndividualLanguageSize = 'individualLanguageSize'
+
+export function isIndividualLanguageSize<V>(v: V) {
+  return is$typed(v, id, hashIndividualLanguageSize)
+}
+
+export function validateIndividualLanguageSize<V>(v: V) {
+  return validate<IndividualLanguageSize & V>(v, id, hashIndividualLanguageSize)
+}
+
+export interface CommitCountBreakdown {
+  $type?: 'sh.tangled.git.refUpdate#commitCountBreakdown'
+  byEmail?: IndividualEmailCommitCount[]
+}
+
+const hashCommitCountBreakdown = 'commitCountBreakdown'
+
+export function isCommitCountBreakdown<V>(v: V) {
+  return is$typed(v, id, hashCommitCountBreakdown)
+}
+
+export function validateCommitCountBreakdown<V>(v: V) {
+  return validate<CommitCountBreakdown & V>(v, id, hashCommitCountBreakdown)
+}
+
+export interface IndividualEmailCommitCount {
+  $type?: 'sh.tangled.git.refUpdate#individualEmailCommitCount'
+  email: string
+  count: number
+}
+
+const hashIndividualEmailCommitCount = 'individualEmailCommitCount'
+
+export function isIndividualEmailCommitCount<V>(v: V) {
+  return is$typed(v, id, hashIndividualEmailCommitCount)
+}
+
+export function validateIndividualEmailCommitCount<V>(v: V) {
+  return validate<IndividualEmailCommitCount & V>(
+    v,
+    id,
+    hashIndividualEmailCommitCount,
+  )
+}

src/lexicon/types/sh/tangled/graph/follow.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.graph.follow'
+
+export interface Main {
+  $type: 'sh.tangled.graph.follow'
+  subject: string
+  createdAt: string
+  [k: string]: unknown
+}
+
+const hashMain = 'main'
+
+export function isMain<V>(v: V) {
+  return is$typed(v, id, hashMain)
+}
+
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain, true)
+}
+
+export {
+  type Main as Record,
+  isMain as isRecord,
+  validateMain as validateRecord,
+}

src/lexicon/types/sh/tangled/knot.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../lexicons'
+import { type $Typed, is$typed as _is$typed, type OmitKey } from '../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.knot'
+
+export interface Main {
+  $type: 'sh.tangled.knot'
+  createdAt: string
+  [k: string]: unknown
+}
+
+const hashMain = 'main'
+
+export function isMain<V>(v: V) {
+  return is$typed(v, id, hashMain)
+}
+
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain, true)
+}
+
+export {
+  type Main as Record,
+  isMain as isRecord,
+  validateMain as validateRecord,
+}

src/lexicon/types/sh/tangled/knot/listKeys.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.knot.listKeys'
+
+export type QueryParams = {
+  /** Maximum number of keys to return */
+  limit?: number
+  /** Pagination cursor */
+  cursor?: string
+}
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  keys: PublicKey[]
+  /** Pagination cursor for next page */
+  cursor?: string
+}
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+  data: OutputSchema
+}
+
+export class InternalServerError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export function toKnownErr(e: any) {
+  if (e instanceof XRPCError) {
+    if (e.error === 'InternalServerError') return new InternalServerError(e)
+  }
+
+  return e
+}
+
+export interface PublicKey {
+  $type?: 'sh.tangled.knot.listKeys#publicKey'
+  /** DID associated with the public key */
+  did: string
+  /** Public key contents */
+  key: string
+  /** Key upload timestamp */
+  createdAt: string
+}
+
+const hashPublicKey = 'publicKey'
+
+export function isPublicKey<V>(v: V) {
+  return is$typed(v, id, hashPublicKey)
+}
+
+export function validatePublicKey<V>(v: V) {
+  return validate<PublicKey & V>(v, id, hashPublicKey)
+}

src/lexicon/types/sh/tangled/knot/member.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.knot.member'
+
+export interface Main {
+  $type: 'sh.tangled.knot.member'
+  subject: string
+  /** domain that this member now belongs to */
+  domain: string
+  createdAt: string
+  [k: string]: unknown
+}
+
+const hashMain = 'main'
+
+export function isMain<V>(v: V) {
+  return is$typed(v, id, hashMain)
+}
+
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain, true)
+}
+
+export {
+  type Main as Record,
+  isMain as isRecord,
+  validateMain as validateRecord,
+}

src/lexicon/types/sh/tangled/knot/version.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.knot.version'
+
+export type QueryParams = {}
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  version: string
+}
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+  data: OutputSchema
+}
+
+export function toKnownErr(e: any) {
+  return e
+}

src/lexicon/types/sh/tangled/label/definition.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.label.definition'
+
+export interface Main {
+  $type: 'sh.tangled.label.definition'
+  /** The display name of this label. */
+  name: string
+  valueType: ValueType
+  /** The areas of the repo this label may apply to, eg.: sh.tangled.repo.issue. Appviews may choose to respect this. */
+  scope: string[]
+  /** The hex value for the background color for the label. Appviews may choose to respect this. */
+  color?: string
+  createdAt: string
+  /** Whether this label can be repeated for a given entity, eg.: [reviewer:foo, reviewer:bar] */
+  multiple?: boolean
+  [k: string]: unknown
+}
+
+const hashMain = 'main'
+
+export function isMain<V>(v: V) {
+  return is$typed(v, id, hashMain)
+}
+
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain, true)
+}
+
+export {
+  type Main as Record,
+  isMain as isRecord,
+  validateMain as validateRecord,
+}
+
+export interface ValueType {
+  $type?: 'sh.tangled.label.definition#valueType'
+  /** The concrete type of this label's value. */
+  type: 'null' | 'boolean' | 'integer' | 'string'
+  /** An optional constraint that can be applied on string concrete types. */
+  format: 'any' | 'did' | 'nsid'
+  /** Closed set of values that this label can take. */
+  enum?: string[]
+}
+
+const hashValueType = 'valueType'
+
+export function isValueType<V>(v: V) {
+  return is$typed(v, id, hashValueType)
+}
+
+export function validateValueType<V>(v: V) {
+  return validate<ValueType & V>(v, id, hashValueType)
+}

src/lexicon/types/sh/tangled/label/op.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.label.op'
+
+export interface Main {
+  $type: 'sh.tangled.label.op'
+  /** The subject (task, pull or discussion) of this label. Appviews may apply a `scope` check and refuse this op. */
+  subject: string
+  performedAt: string
+  add: Operand[]
+  delete: Operand[]
+  [k: string]: unknown
+}
+
+const hashMain = 'main'
+
+export function isMain<V>(v: V) {
+  return is$typed(v, id, hashMain)
+}
+
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain, true)
+}
+
+export {
+  type Main as Record,
+  isMain as isRecord,
+  validateMain as validateRecord,
+}
+
+export interface Operand {
+  $type?: 'sh.tangled.label.op#operand'
+  /** ATURI to the label definition */
+  key: string
+  /** Stringified value of the label. This is first unstringed by appviews and then interpreted as a concrete value. */
+  value: string
+}
+
+const hashOperand = 'operand'
+
+export function isOperand<V>(v: V) {
+  return is$typed(v, id, hashOperand)
+}
+
+export function validateOperand<V>(v: V) {
+  return validate<Operand & V>(v, id, hashOperand)
+}

src/lexicon/types/sh/tangled/pipeline.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../lexicons'
+import { type $Typed, is$typed as _is$typed, type OmitKey } from '../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.pipeline'
+
+export interface Main {
+  $type: 'sh.tangled.pipeline'
+  triggerMetadata: TriggerMetadata
+  workflows: Workflow[]
+  [k: string]: unknown
+}
+
+const hashMain = 'main'
+
+export function isMain<V>(v: V) {
+  return is$typed(v, id, hashMain)
+}
+
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain, true)
+}
+
+export {
+  type Main as Record,
+  isMain as isRecord,
+  validateMain as validateRecord,
+}
+
+export interface TriggerMetadata {
+  $type?: 'sh.tangled.pipeline#triggerMetadata'
+  kind: 'push' | 'pull_request' | 'manual'
+  repo: TriggerRepo
+  push?: PushTriggerData
+  pullRequest?: PullRequestTriggerData
+  manual?: ManualTriggerData
+}
+
+const hashTriggerMetadata = 'triggerMetadata'
+
+export function isTriggerMetadata<V>(v: V) {
+  return is$typed(v, id, hashTriggerMetadata)
+}
+
+export function validateTriggerMetadata<V>(v: V) {
+  return validate<TriggerMetadata & V>(v, id, hashTriggerMetadata)
+}
+
+export interface TriggerRepo {
+  $type?: 'sh.tangled.pipeline#triggerRepo'
+  knot: string
+  did: string
+  repo: string
+  defaultBranch: string
+}
+
+const hashTriggerRepo = 'triggerRepo'
+
+export function isTriggerRepo<V>(v: V) {
+  return is$typed(v, id, hashTriggerRepo)
+}
+
+export function validateTriggerRepo<V>(v: V) {
+  return validate<TriggerRepo & V>(v, id, hashTriggerRepo)
+}
+
+export interface PushTriggerData {
+  $type?: 'sh.tangled.pipeline#pushTriggerData'
+  ref: string
+  newSha: string
+  oldSha: string
+}
+
+const hashPushTriggerData = 'pushTriggerData'
+
+export function isPushTriggerData<V>(v: V) {
+  return is$typed(v, id, hashPushTriggerData)
+}
+
+export function validatePushTriggerData<V>(v: V) {
+  return validate<PushTriggerData & V>(v, id, hashPushTriggerData)
+}
+
+export interface PullRequestTriggerData {
+  $type?: 'sh.tangled.pipeline#pullRequestTriggerData'
+  sourceBranch: string
+  targetBranch: string
+  sourceSha: string
+  action: string
+}
+
+const hashPullRequestTriggerData = 'pullRequestTriggerData'
+
+export function isPullRequestTriggerData<V>(v: V) {
+  return is$typed(v, id, hashPullRequestTriggerData)
+}
+
+export function validatePullRequestTriggerData<V>(v: V) {
+  return validate<PullRequestTriggerData & V>(v, id, hashPullRequestTriggerData)
+}
+
+export interface ManualTriggerData {
+  $type?: 'sh.tangled.pipeline#manualTriggerData'
+  inputs?: Pair[]
+}
+
+const hashManualTriggerData = 'manualTriggerData'
+
+export function isManualTriggerData<V>(v: V) {
+  return is$typed(v, id, hashManualTriggerData)
+}
+
+export function validateManualTriggerData<V>(v: V) {
+  return validate<ManualTriggerData & V>(v, id, hashManualTriggerData)
+}
+
+export interface Workflow {
+  $type?: 'sh.tangled.pipeline#workflow'
+  name: string
+  engine: string
+  clone: CloneOpts
+  raw: string
+}
+
+const hashWorkflow = 'workflow'
+
+export function isWorkflow<V>(v: V) {
+  return is$typed(v, id, hashWorkflow)
+}
+
+export function validateWorkflow<V>(v: V) {
+  return validate<Workflow & V>(v, id, hashWorkflow)
+}
+
+export interface CloneOpts {
+  $type?: 'sh.tangled.pipeline#cloneOpts'
+  skip: boolean
+  depth: number
+  submodules: boolean
+}
+
+const hashCloneOpts = 'cloneOpts'
+
+export function isCloneOpts<V>(v: V) {
+  return is$typed(v, id, hashCloneOpts)
+}
+
+export function validateCloneOpts<V>(v: V) {
+  return validate<CloneOpts & V>(v, id, hashCloneOpts)
+}
+
+export interface Pair {
+  $type?: 'sh.tangled.pipeline#pair'
+  key: string
+  value: string
+}
+
+const hashPair = 'pair'
+
+export function isPair<V>(v: V) {
+  return is$typed(v, id, hashPair)
+}
+
+export function validatePair<V>(v: V) {
+  return validate<Pair & V>(v, id, hashPair)
+}

src/lexicon/types/sh/tangled/pipeline/cancelPipeline.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.pipeline.cancelPipeline'
+
+export type QueryParams = {}
+
+export interface InputSchema {
+  /** repo at-uri, spindle can't resolve repo from pipeline at-uri yet */
+  repo: string
+  /** pipeline at-uri */
+  pipeline: string
+  /** workflow name */
+  workflow: string
+}
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+  qp?: QueryParams
+  encoding?: 'application/json'
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+}
+
+export function toKnownErr(e: any) {
+  return e
+}

src/lexicon/types/sh/tangled/pipeline/status.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.pipeline.status'
+
+export interface Main {
+  $type: 'sh.tangled.pipeline.status'
+  /** ATURI of the pipeline */
+  pipeline: string
+  /** name of the workflow within this pipeline */
+  workflow: string
+  /** status of the workflow */
+  status: 'pending' | 'running' | 'failed' | 'timeout' | 'cancelled' | 'success'
+  /** time of creation of this status update */
+  createdAt: string
+  /** error message if failed */
+  error?: string
+  /** exit code if failed */
+  exitCode?: number
+  [k: string]: unknown
+}
+
+const hashMain = 'main'
+
+export function isMain<V>(v: V) {
+  return is$typed(v, id, hashMain)
+}
+
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain, true)
+}
+
+export {
+  type Main as Record,
+  isMain as isRecord,
+  validateMain as validateRecord,
+}

src/lexicon/types/sh/tangled/repo.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../lexicons'
+import { type $Typed, is$typed as _is$typed, type OmitKey } from '../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo'
+
+export interface Main {
+  $type: 'sh.tangled.repo'
+  /** name of the repo */
+  name: string
+  /** knot where the repo was created */
+  knot: string
+  /** CI runner to send jobs to and receive results from */
+  spindle?: string
+  description?: string
+  /** Any URI related to the repo */
+  website?: string
+  /** Topics related to the repo */
+  topics?: string[]
+  /** source of the repo */
+  source?: string
+  /** List of labels that this repo subscribes to */
+  labels?: string[]
+  createdAt: string
+  [k: string]: unknown
+}
+
+const hashMain = 'main'
+
+export function isMain<V>(v: V) {
+  return is$typed(v, id, hashMain)
+}
+
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain, true)
+}
+
+export {
+  type Main as Record,
+  isMain as isRecord,
+  validateMain as validateRecord,
+}

src/lexicon/types/sh/tangled/repo/addSecret.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.addSecret'
+
+export type QueryParams = {}
+
+export interface InputSchema {
+  repo: string
+  key: string
+  value: string
+}
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+  qp?: QueryParams
+  encoding?: 'application/json'
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+}
+
+export function toKnownErr(e: any) {
+  return e
+}

src/lexicon/types/sh/tangled/repo/archive.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.archive'
+
+export type QueryParams = {
+  /** Repository identifier in format 'did:plc:.../repoName' */
+  repo: string
+  /** Git reference (branch, tag, or commit SHA) */
+  ref: string
+  /** Archive format */
+  format?: 'tar' | 'zip' | 'tar.gz' | 'tar.bz2' | 'tar.xz'
+  /** Prefix for files in the archive */
+  prefix?: string
+}
+export type InputSchema = undefined
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+  data: Uint8Array
+}
+
+export class RepoNotFoundError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class RefNotFoundError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class InvalidRequestError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class ArchiveError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export function toKnownErr(e: any) {
+  if (e instanceof XRPCError) {
+    if (e.error === 'RepoNotFound') return new RepoNotFoundError(e)
+    if (e.error === 'RefNotFound') return new RefNotFoundError(e)
+    if (e.error === 'InvalidRequest') return new InvalidRequestError(e)
+    if (e.error === 'ArchiveError') return new ArchiveError(e)
+  }
+
+  return e
+}

src/lexicon/types/sh/tangled/repo/artifact.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.artifact'
+
+export interface Main {
+  $type: 'sh.tangled.repo.artifact'
+  /** name of the artifact */
+  name: string
+  /** repo that this artifact is being uploaded to */
+  repo: string
+  /** hash of the tag object that this artifact is attached to (only annotated tags are supported) */
+  tag: Uint8Array
+  /** time of creation of this artifact */
+  createdAt: string
+  /** the artifact */
+  artifact: BlobRef
+  [k: string]: unknown
+}
+
+const hashMain = 'main'
+
+export function isMain<V>(v: V) {
+  return is$typed(v, id, hashMain)
+}
+
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain, true)
+}
+
+export {
+  type Main as Record,
+  isMain as isRecord,
+  validateMain as validateRecord,
+}

src/lexicon/types/sh/tangled/repo/blob.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.blob'
+
+export type QueryParams = {
+  /** Repository identifier in format 'did:plc:.../repoName' */
+  repo: string
+  /** Git reference (branch, tag, or commit SHA) */
+  ref: string
+  /** Path to the file within the repository */
+  path: string
+  /** Return raw file content instead of JSON response */
+  raw?: boolean
+}
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  /** The git reference used */
+  ref: string
+  /** The file path */
+  path: string
+  /** File content (base64 encoded for binary files) */
+  content?: string
+  /** Content encoding */
+  encoding?: 'utf-8' | 'base64'
+  /** File size in bytes */
+  size?: number
+  /** Whether the file is binary */
+  isBinary?: boolean
+  /** MIME type of the file */
+  mimeType?: string
+  submodule?: Submodule
+  lastCommit?: LastCommit
+}
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+  data: OutputSchema
+}
+
+export class RepoNotFoundError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class RefNotFoundError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class FileNotFoundError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class InvalidRequestError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export function toKnownErr(e: any) {
+  if (e instanceof XRPCError) {
+    if (e.error === 'RepoNotFound') return new RepoNotFoundError(e)
+    if (e.error === 'RefNotFound') return new RefNotFoundError(e)
+    if (e.error === 'FileNotFound') return new FileNotFoundError(e)
+    if (e.error === 'InvalidRequest') return new InvalidRequestError(e)
+  }
+
+  return e
+}
+
+export interface LastCommit {
+  $type?: 'sh.tangled.repo.blob#lastCommit'
+  /** Commit hash */
+  hash: string
+  /** Commit message */
+  message: string
+  author?: Signature
+  /** Commit timestamp */
+  when: string
+}
+
+const hashLastCommit = 'lastCommit'
+
+export function isLastCommit<V>(v: V) {
+  return is$typed(v, id, hashLastCommit)
+}
+
+export function validateLastCommit<V>(v: V) {
+  return validate<LastCommit & V>(v, id, hashLastCommit)
+}
+
+export interface Signature {
+  $type?: 'sh.tangled.repo.blob#signature'
+  /** Author name */
+  name: string
+  /** Author email */
+  email: string
+  /** Author timestamp */
+  when: string
+}
+
+const hashSignature = 'signature'
+
+export function isSignature<V>(v: V) {
+  return is$typed(v, id, hashSignature)
+}
+
+export function validateSignature<V>(v: V) {
+  return validate<Signature & V>(v, id, hashSignature)
+}
+
+export interface Submodule {
+  $type?: 'sh.tangled.repo.blob#submodule'
+  /** Submodule name */
+  name: string
+  /** Submodule repository URL */
+  url: string
+  /** Branch to track in the submodule */
+  branch?: string
+}
+
+const hashSubmodule = 'submodule'
+
+export function isSubmodule<V>(v: V) {
+  return is$typed(v, id, hashSubmodule)
+}
+
+export function validateSubmodule<V>(v: V) {
+  return validate<Submodule & V>(v, id, hashSubmodule)
+}

src/lexicon/types/sh/tangled/repo/branch.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.branch'
+
+export type QueryParams = {
+  /** Repository identifier in format 'did:plc:.../repoName' */
+  repo: string
+  /** Branch name to get information for */
+  name: string
+}
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  /** Branch name */
+  name: string
+  /** Latest commit hash on this branch */
+  hash: string
+  /** Short commit hash */
+  shortHash?: string
+  /** Timestamp of latest commit */
+  when: string
+  /** Latest commit message */
+  message?: string
+  author?: Signature
+  /** Whether this is the default branch */
+  isDefault?: boolean
+}
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+  data: OutputSchema
+}
+
+export class RepoNotFoundError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class BranchNotFoundError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class InvalidRequestError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export function toKnownErr(e: any) {
+  if (e instanceof XRPCError) {
+    if (e.error === 'RepoNotFound') return new RepoNotFoundError(e)
+    if (e.error === 'BranchNotFound') return new BranchNotFoundError(e)
+    if (e.error === 'InvalidRequest') return new InvalidRequestError(e)
+  }
+
+  return e
+}
+
+export interface Signature {
+  $type?: 'sh.tangled.repo.branch#signature'
+  /** Author name */
+  name: string
+  /** Author email */
+  email: string
+  /** Author timestamp */
+  when: string
+}
+
+const hashSignature = 'signature'
+
+export function isSignature<V>(v: V) {
+  return is$typed(v, id, hashSignature)
+}
+
+export function validateSignature<V>(v: V) {
+  return validate<Signature & V>(v, id, hashSignature)
+}

src/lexicon/types/sh/tangled/repo/branches.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.branches'
+
+export type QueryParams = {
+  /** Repository identifier in format 'did:plc:.../repoName' */
+  repo: string
+  /** Maximum number of branches to return */
+  limit?: number
+  /** Pagination cursor */
+  cursor?: string
+}
+export type InputSchema = undefined
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+  data: Uint8Array
+}
+
+export class RepoNotFoundError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class InvalidRequestError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export function toKnownErr(e: any) {
+  if (e instanceof XRPCError) {
+    if (e.error === 'RepoNotFound') return new RepoNotFoundError(e)
+    if (e.error === 'InvalidRequest') return new InvalidRequestError(e)
+  }
+
+  return e
+}

src/lexicon/types/sh/tangled/repo/collaborator.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.collaborator'
+
+export interface Main {
+  $type: 'sh.tangled.repo.collaborator'
+  subject: string
+  /** repo to add this user to */
+  repo: string
+  createdAt: string
+  [k: string]: unknown
+}
+
+const hashMain = 'main'
+
+export function isMain<V>(v: V) {
+  return is$typed(v, id, hashMain)
+}
+
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain, true)
+}
+
+export {
+  type Main as Record,
+  isMain as isRecord,
+  validateMain as validateRecord,
+}

src/lexicon/types/sh/tangled/repo/compare.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.compare'
+
+export type QueryParams = {
+  /** Repository identifier in format 'did:plc:.../repoName' */
+  repo: string
+  /** First revision (commit, branch, or tag) */
+  rev1: string
+  /** Second revision (commit, branch, or tag) */
+  rev2: string
+}
+export type InputSchema = undefined
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+  data: Uint8Array
+}
+
+export class RepoNotFoundError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class RevisionNotFoundError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class InvalidRequestError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class CompareError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export function toKnownErr(e: any) {
+  if (e instanceof XRPCError) {
+    if (e.error === 'RepoNotFound') return new RepoNotFoundError(e)
+    if (e.error === 'RevisionNotFound') return new RevisionNotFoundError(e)
+    if (e.error === 'InvalidRequest') return new InvalidRequestError(e)
+    if (e.error === 'CompareError') return new CompareError(e)
+  }
+
+  return e
+}

src/lexicon/types/sh/tangled/repo/create.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.create'
+
+export type QueryParams = {}
+
+export interface InputSchema {
+  /** Rkey of the repository record */
+  rkey: string
+  /** Default branch to push to */
+  defaultBranch?: string
+  /** A source URL to clone from, populate this when forking or importing a repository. */
+  source?: string
+}
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+  qp?: QueryParams
+  encoding?: 'application/json'
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+}
+
+export function toKnownErr(e: any) {
+  return e
+}

src/lexicon/types/sh/tangled/repo/delete.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.delete'
+
+export type QueryParams = {}
+
+export interface InputSchema {
+  /** DID of the repository owner */
+  did: string
+  /** Name of the repository to delete */
+  name: string
+  /** Rkey of the repository record */
+  rkey: string
+}
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+  qp?: QueryParams
+  encoding?: 'application/json'
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+}
+
+export function toKnownErr(e: any) {
+  return e
+}

src/lexicon/types/sh/tangled/repo/deleteBranch.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.deleteBranch'
+
+export type QueryParams = {}
+
+export interface InputSchema {
+  repo: string
+  branch: string
+}
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+  qp?: QueryParams
+  encoding?: 'application/json'
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+}
+
+export function toKnownErr(e: any) {
+  return e
+}

src/lexicon/types/sh/tangled/repo/diff.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.diff'
+
+export type QueryParams = {
+  /** Repository identifier in format 'did:plc:.../repoName' */
+  repo: string
+  /** Git reference (branch, tag, or commit SHA) */
+  ref: string
+}
+export type InputSchema = undefined
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+  data: Uint8Array
+}
+
+export class RepoNotFoundError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class RefNotFoundError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class InvalidRequestError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export function toKnownErr(e: any) {
+  if (e instanceof XRPCError) {
+    if (e.error === 'RepoNotFound') return new RepoNotFoundError(e)
+    if (e.error === 'RefNotFound') return new RefNotFoundError(e)
+    if (e.error === 'InvalidRequest') return new InvalidRequestError(e)
+  }
+
+  return e
+}

src/lexicon/types/sh/tangled/repo/forkStatus.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.forkStatus'
+
+export type QueryParams = {}
+
+export interface InputSchema {
+  /** DID of the fork owner */
+  did: string
+  /** Name of the forked repository */
+  name: string
+  /** Source repository URL */
+  source: string
+  /** Branch to check status for */
+  branch: string
+  /** Hidden ref to use for comparison */
+  hiddenRef: string
+}
+
+export interface OutputSchema {
+  /** Fork status: 0=UpToDate, 1=FastForwardable, 2=Conflict, 3=MissingBranch */
+  status: number
+}
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+  qp?: QueryParams
+  encoding?: 'application/json'
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+  data: OutputSchema
+}
+
+export function toKnownErr(e: any) {
+  return e
+}

src/lexicon/types/sh/tangled/repo/forkSync.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.forkSync'
+
+export type QueryParams = {}
+
+export interface InputSchema {
+  /** DID of the fork owner */
+  did: string
+  /** AT-URI of the source repository */
+  source: string
+  /** Name of the forked repository */
+  name: string
+  /** Branch to sync */
+  branch: string
+}
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+  qp?: QueryParams
+  encoding?: 'application/json'
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+}
+
+export function toKnownErr(e: any) {
+  return e
+}

src/lexicon/types/sh/tangled/repo/getDefaultBranch.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.getDefaultBranch'
+
+export type QueryParams = {
+  /** Repository identifier in format 'did:plc:.../repoName' */
+  repo: string
+}
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  /** Default branch name */
+  name: string
+  /** Latest commit hash on default branch */
+  hash: string
+  /** Short commit hash */
+  shortHash?: string
+  /** Timestamp of latest commit */
+  when: string
+  /** Latest commit message */
+  message?: string
+  author?: Signature
+}
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+  data: OutputSchema
+}
+
+export class RepoNotFoundError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class InvalidRequestError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export function toKnownErr(e: any) {
+  if (e instanceof XRPCError) {
+    if (e.error === 'RepoNotFound') return new RepoNotFoundError(e)
+    if (e.error === 'InvalidRequest') return new InvalidRequestError(e)
+  }
+
+  return e
+}
+
+export interface Signature {
+  $type?: 'sh.tangled.repo.getDefaultBranch#signature'
+  /** Author name */
+  name: string
+  /** Author email */
+  email: string
+  /** Author timestamp */
+  when: string
+}
+
+const hashSignature = 'signature'
+
+export function isSignature<V>(v: V) {
+  return is$typed(v, id, hashSignature)
+}
+
+export function validateSignature<V>(v: V) {
+  return validate<Signature & V>(v, id, hashSignature)
+}

src/lexicon/types/sh/tangled/repo/hiddenRef.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.hiddenRef'
+
+export type QueryParams = {}
+
+export interface InputSchema {
+  /** AT-URI of the repository */
+  repo: string
+  /** Fork reference name */
+  forkRef: string
+  /** Remote reference name */
+  remoteRef: string
+}
+
+export interface OutputSchema {
+  /** Whether the hidden ref was created successfully */
+  success: boolean
+  /** The created hidden ref name */
+  ref?: string
+  /** Error message if creation failed */
+  error?: string
+}
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+  qp?: QueryParams
+  encoding?: 'application/json'
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+  data: OutputSchema
+}
+
+export function toKnownErr(e: any) {
+  return e
+}

src/lexicon/types/sh/tangled/repo/issue.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.issue'
+
+export interface Main {
+  $type: 'sh.tangled.repo.issue'
+  repo: string
+  title: string
+  body?: string
+  createdAt: string
+  mentions?: string[]
+  references?: string[]
+  [k: string]: unknown
+}
+
+const hashMain = 'main'
+
+export function isMain<V>(v: V) {
+  return is$typed(v, id, hashMain)
+}
+
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain, true)
+}
+
+export {
+  type Main as Record,
+  isMain as isRecord,
+  validateMain as validateRecord,
+}

src/lexicon/types/sh/tangled/repo/issue/comment.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.issue.comment'
+
+export interface Main {
+  $type: 'sh.tangled.repo.issue.comment'
+  issue: string
+  body: string
+  createdAt: string
+  replyTo?: string
+  mentions?: string[]
+  references?: string[]
+  [k: string]: unknown
+}
+
+const hashMain = 'main'
+
+export function isMain<V>(v: V) {
+  return is$typed(v, id, hashMain)
+}
+
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain, true)
+}
+
+export {
+  type Main as Record,
+  isMain as isRecord,
+  validateMain as validateRecord,
+}

src/lexicon/types/sh/tangled/repo/issue/state.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.issue.state'
+
+export interface Main {
+  $type: 'sh.tangled.repo.issue.state'
+  issue: string
+  /** state of the issue */
+  state:
+    | 'sh.tangled.repo.issue.state.open'
+    | 'sh.tangled.repo.issue.state.closed'
+    | (string & {})
+  [k: string]: unknown
+}
+
+const hashMain = 'main'
+
+export function isMain<V>(v: V) {
+  return is$typed(v, id, hashMain)
+}
+
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain, true)
+}
+
+export {
+  type Main as Record,
+  isMain as isRecord,
+  validateMain as validateRecord,
+}

src/lexicon/types/sh/tangled/repo/issue/state/closed.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.issue.state.closed'
+/** closed issue */
+export const MAIN = `${id}#main`

src/lexicon/types/sh/tangled/repo/issue/state/open.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.issue.state.open'
+/** open issue */
+export const MAIN = `${id}#main`

src/lexicon/types/sh/tangled/repo/languages.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.languages'
+
+export type QueryParams = {
+  /** Repository identifier in format 'did:plc:.../repoName' */
+  repo: string
+  /** Git reference (branch, tag, or commit SHA) */
+  ref?: string
+}
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  /** The git reference used */
+  ref: string
+  languages: Language[]
+  /** Total size of all analyzed files in bytes */
+  totalSize?: number
+  /** Total number of files analyzed */
+  totalFiles?: number
+}
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+  data: OutputSchema
+}
+
+export class RepoNotFoundError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class RefNotFoundError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class InvalidRequestError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export function toKnownErr(e: any) {
+  if (e instanceof XRPCError) {
+    if (e.error === 'RepoNotFound') return new RepoNotFoundError(e)
+    if (e.error === 'RefNotFound') return new RefNotFoundError(e)
+    if (e.error === 'InvalidRequest') return new InvalidRequestError(e)
+  }
+
+  return e
+}
+
+export interface Language {
+  $type?: 'sh.tangled.repo.languages#language'
+  /** Programming language name */
+  name: string
+  /** Total size of files in this language (bytes) */
+  size: number
+  /** Percentage of total codebase (0-100) */
+  percentage: number
+  /** Number of files in this language */
+  fileCount?: number
+  /** Hex color code for this language */
+  color?: string
+  /** File extensions associated with this language */
+  extensions?: string[]
+}
+
+const hashLanguage = 'language'
+
+export function isLanguage<V>(v: V) {
+  return is$typed(v, id, hashLanguage)
+}
+
+export function validateLanguage<V>(v: V) {
+  return validate<Language & V>(v, id, hashLanguage)
+}

src/lexicon/types/sh/tangled/repo/listSecrets.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.listSecrets'
+
+export type QueryParams = {
+  repo: string
+}
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  secrets: Secret[]
+}
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+  data: OutputSchema
+}
+
+export function toKnownErr(e: any) {
+  return e
+}
+
+export interface Secret {
+  $type?: 'sh.tangled.repo.listSecrets#secret'
+  repo: string
+  key: string
+  createdAt: string
+  createdBy: string
+}
+
+const hashSecret = 'secret'
+
+export function isSecret<V>(v: V) {
+  return is$typed(v, id, hashSecret)
+}
+
+export function validateSecret<V>(v: V) {
+  return validate<Secret & V>(v, id, hashSecret)
+}

src/lexicon/types/sh/tangled/repo/log.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.log'
+
+export type QueryParams = {
+  /** Repository identifier in format 'did:plc:.../repoName' */
+  repo: string
+  /** Git reference (branch, tag, or commit SHA) */
+  ref: string
+  /** Path to filter commits by */
+  path?: string
+  /** Maximum number of commits to return */
+  limit?: number
+  /** Pagination cursor (commit SHA) */
+  cursor?: string
+}
+export type InputSchema = undefined
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+  data: Uint8Array
+}
+
+export class RepoNotFoundError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class RefNotFoundError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class PathNotFoundError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class InvalidRequestError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export function toKnownErr(e: any) {
+  if (e instanceof XRPCError) {
+    if (e.error === 'RepoNotFound') return new RepoNotFoundError(e)
+    if (e.error === 'RefNotFound') return new RefNotFoundError(e)
+    if (e.error === 'PathNotFound') return new PathNotFoundError(e)
+    if (e.error === 'InvalidRequest') return new InvalidRequestError(e)
+  }
+
+  return e
+}

src/lexicon/types/sh/tangled/repo/merge.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.merge'
+
+export type QueryParams = {}
+
+export interface InputSchema {
+  /** DID of the repository owner */
+  did: string
+  /** Name of the repository */
+  name: string
+  /** Patch content to merge */
+  patch: string
+  /** Target branch to merge into */
+  branch: string
+  /** Author name for the merge commit */
+  authorName?: string
+  /** Author email for the merge commit */
+  authorEmail?: string
+  /** Additional commit message body */
+  commitBody?: string
+  /** Merge commit message */
+  commitMessage?: string
+}
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+  qp?: QueryParams
+  encoding?: 'application/json'
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+}
+
+export function toKnownErr(e: any) {
+  return e
+}

src/lexicon/types/sh/tangled/repo/mergeCheck.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.mergeCheck'
+
+export type QueryParams = {}
+
+export interface InputSchema {
+  /** DID of the repository owner */
+  did: string
+  /** Name of the repository */
+  name: string
+  /** Patch or pull request to check for merge conflicts */
+  patch: string
+  /** Target branch to merge into */
+  branch: string
+}
+
+export interface OutputSchema {
+  /** Whether the merge has conflicts */
+  is_conflicted: boolean
+  /** List of files with merge conflicts */
+  conflicts?: ConflictInfo[]
+  /** Additional message about the merge check */
+  message?: string
+  /** Error message if check failed */
+  error?: string
+}
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+  qp?: QueryParams
+  encoding?: 'application/json'
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+  data: OutputSchema
+}
+
+export function toKnownErr(e: any) {
+  return e
+}
+
+export interface ConflictInfo {
+  $type?: 'sh.tangled.repo.mergeCheck#conflictInfo'
+  /** Name of the conflicted file */
+  filename: string
+  /** Reason for the conflict */
+  reason: string
+}
+
+const hashConflictInfo = 'conflictInfo'
+
+export function isConflictInfo<V>(v: V) {
+  return is$typed(v, id, hashConflictInfo)
+}
+
+export function validateConflictInfo<V>(v: V) {
+  return validate<ConflictInfo & V>(v, id, hashConflictInfo)
+}

src/lexicon/types/sh/tangled/repo/pull.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.pull'
+
+export interface Main {
+  $type: 'sh.tangled.repo.pull'
+  target: Target
+  title: string
+  body?: string
+  /** (deprecated) use patchBlob instead */
+  patch?: string
+  /** patch content */
+  patchBlob: BlobRef
+  source?: Source
+  createdAt: string
+  mentions?: string[]
+  references?: string[]
+  [k: string]: unknown
+}
+
+const hashMain = 'main'
+
+export function isMain<V>(v: V) {
+  return is$typed(v, id, hashMain)
+}
+
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain, true)
+}
+
+export {
+  type Main as Record,
+  isMain as isRecord,
+  validateMain as validateRecord,
+}
+
+export interface Target {
+  $type?: 'sh.tangled.repo.pull#target'
+  repo: string
+  branch: string
+}
+
+const hashTarget = 'target'
+
+export function isTarget<V>(v: V) {
+  return is$typed(v, id, hashTarget)
+}
+
+export function validateTarget<V>(v: V) {
+  return validate<Target & V>(v, id, hashTarget)
+}
+
+export interface Source {
+  $type?: 'sh.tangled.repo.pull#source'
+  branch: string
+  sha: string
+  repo?: string
+}
+
+const hashSource = 'source'
+
+export function isSource<V>(v: V) {
+  return is$typed(v, id, hashSource)
+}
+
+export function validateSource<V>(v: V) {
+  return validate<Source & V>(v, id, hashSource)
+}

src/lexicon/types/sh/tangled/repo/pull/comment.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.pull.comment'
+
+export interface Main {
+  $type: 'sh.tangled.repo.pull.comment'
+  pull: string
+  body: string
+  createdAt: string
+  mentions?: string[]
+  references?: string[]
+  [k: string]: unknown
+}
+
+const hashMain = 'main'
+
+export function isMain<V>(v: V) {
+  return is$typed(v, id, hashMain)
+}
+
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain, true)
+}
+
+export {
+  type Main as Record,
+  isMain as isRecord,
+  validateMain as validateRecord,
+}

src/lexicon/types/sh/tangled/repo/pull/status.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.pull.status'
+
+export interface Main {
+  $type: 'sh.tangled.repo.pull.status'
+  pull: string
+  /** status of the pull request */
+  status:
+    | 'sh.tangled.repo.pull.status.open'
+    | 'sh.tangled.repo.pull.status.closed'
+    | 'sh.tangled.repo.pull.status.merged'
+    | (string & {})
+  [k: string]: unknown
+}
+
+const hashMain = 'main'
+
+export function isMain<V>(v: V) {
+  return is$typed(v, id, hashMain)
+}
+
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain, true)
+}
+
+export {
+  type Main as Record,
+  isMain as isRecord,
+  validateMain as validateRecord,
+}

src/lexicon/types/sh/tangled/repo/pull/status/closed.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.pull.status.closed'
+/** closed pull request */
+export const MAIN = `${id}#main`

src/lexicon/types/sh/tangled/repo/pull/status/merged.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.pull.status.merged'
+/** merged pull request */
+export const MAIN = `${id}#main`

src/lexicon/types/sh/tangled/repo/pull/status/open.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.pull.status.open'
+/** open pull request */
+export const MAIN = `${id}#main`

src/lexicon/types/sh/tangled/repo/removeSecret.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.removeSecret'
+
+export type QueryParams = {}
+
+export interface InputSchema {
+  repo: string
+  key: string
+}
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+  qp?: QueryParams
+  encoding?: 'application/json'
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+}
+
+export function toKnownErr(e: any) {
+  return e
+}

src/lexicon/types/sh/tangled/repo/setDefaultBranch.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.setDefaultBranch'
+
+export type QueryParams = {}
+
+export interface InputSchema {
+  repo: string
+  defaultBranch: string
+}
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+  qp?: QueryParams
+  encoding?: 'application/json'
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+}
+
+export function toKnownErr(e: any) {
+  return e
+}

src/lexicon/types/sh/tangled/repo/tag.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.tag'
+
+export type QueryParams = {
+  /** Repository identifier in format 'did:plc:.../repoName' */
+  repo: string
+  /** Name of tag, such as v1.3.0 */
+  tag: string
+}
+export type InputSchema = undefined
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+  data: Uint8Array
+}
+
+export class RepoNotFoundError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class TagNotFoundError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class InvalidRequestError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export function toKnownErr(e: any) {
+  if (e instanceof XRPCError) {
+    if (e.error === 'RepoNotFound') return new RepoNotFoundError(e)
+    if (e.error === 'TagNotFound') return new TagNotFoundError(e)
+    if (e.error === 'InvalidRequest') return new InvalidRequestError(e)
+  }
+
+  return e
+}

src/lexicon/types/sh/tangled/repo/tags.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.tags'
+
+export type QueryParams = {
+  /** Repository identifier in format 'did:plc:.../repoName' */
+  repo: string
+  /** Maximum number of tags to return */
+  limit?: number
+  /** Pagination cursor */
+  cursor?: string
+}
+export type InputSchema = undefined
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+  data: Uint8Array
+}
+
+export class RepoNotFoundError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class InvalidRequestError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export function toKnownErr(e: any) {
+  if (e instanceof XRPCError) {
+    if (e.error === 'RepoNotFound') return new RepoNotFoundError(e)
+    if (e.error === 'InvalidRequest') return new InvalidRequestError(e)
+  }
+
+  return e
+}

src/lexicon/types/sh/tangled/repo/tree.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.repo.tree'
+
+export type QueryParams = {
+  /** Repository identifier in format 'did:plc:.../repoName' */
+  repo: string
+  /** Git reference (branch, tag, or commit SHA) */
+  ref: string
+  /** Path within the repository tree */
+  path?: string
+}
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  /** The git reference used */
+  ref: string
+  /** The parent path in the tree */
+  parent?: string
+  /** Parent directory path */
+  dotdot?: string
+  readme?: Readme
+  lastCommit?: LastCommit
+  files: TreeEntry[]
+}
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+  data: OutputSchema
+}
+
+export class RepoNotFoundError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class RefNotFoundError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class PathNotFoundError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class InvalidRequestError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export function toKnownErr(e: any) {
+  if (e instanceof XRPCError) {
+    if (e.error === 'RepoNotFound') return new RepoNotFoundError(e)
+    if (e.error === 'RefNotFound') return new RefNotFoundError(e)
+    if (e.error === 'PathNotFound') return new PathNotFoundError(e)
+    if (e.error === 'InvalidRequest') return new InvalidRequestError(e)
+  }
+
+  return e
+}
+
+export interface Readme {
+  $type?: 'sh.tangled.repo.tree#readme'
+  /** Name of the readme file */
+  filename: string
+  /** Contents of the readme file */
+  contents: string
+}
+
+const hashReadme = 'readme'
+
+export function isReadme<V>(v: V) {
+  return is$typed(v, id, hashReadme)
+}
+
+export function validateReadme<V>(v: V) {
+  return validate<Readme & V>(v, id, hashReadme)
+}
+
+export interface TreeEntry {
+  $type?: 'sh.tangled.repo.tree#treeEntry'
+  /** Relative file or directory name */
+  name: string
+  /** File mode */
+  mode: string
+  /** File size in bytes */
+  size: number
+  last_commit?: LastCommit
+}
+
+const hashTreeEntry = 'treeEntry'
+
+export function isTreeEntry<V>(v: V) {
+  return is$typed(v, id, hashTreeEntry)
+}
+
+export function validateTreeEntry<V>(v: V) {
+  return validate<TreeEntry & V>(v, id, hashTreeEntry)
+}
+
+export interface LastCommit {
+  $type?: 'sh.tangled.repo.tree#lastCommit'
+  /** Commit hash */
+  hash: string
+  /** Commit message */
+  message: string
+  author?: Signature
+  /** Commit timestamp */
+  when: string
+}
+
+const hashLastCommit = 'lastCommit'
+
+export function isLastCommit<V>(v: V) {
+  return is$typed(v, id, hashLastCommit)
+}
+
+export function validateLastCommit<V>(v: V) {
+  return validate<LastCommit & V>(v, id, hashLastCommit)
+}
+
+export interface Signature {
+  $type?: 'sh.tangled.repo.tree#signature'
+  /** Author name */
+  name: string
+  /** Author email */
+  email: string
+  /** Author timestamp */
+  when: string
+}
+
+const hashSignature = 'signature'
+
+export function isSignature<V>(v: V) {
+  return is$typed(v, id, hashSignature)
+}
+
+export function validateSignature<V>(v: V) {
+  return validate<Signature & V>(v, id, hashSignature)
+}

src/lexicon/types/sh/tangled/spindle.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../lexicons'
+import { type $Typed, is$typed as _is$typed, type OmitKey } from '../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.spindle'
+
+export interface Main {
+  $type: 'sh.tangled.spindle'
+  createdAt: string
+  [k: string]: unknown
+}
+
+const hashMain = 'main'
+
+export function isMain<V>(v: V) {
+  return is$typed(v, id, hashMain)
+}
+
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain, true)
+}
+
+export {
+  type Main as Record,
+  isMain as isRecord,
+  validateMain as validateRecord,
+}

src/lexicon/types/sh/tangled/spindle/member.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.spindle.member'
+
+export interface Main {
+  $type: 'sh.tangled.spindle.member'
+  subject: string
+  /** spindle instance that the subject is now a member of */
+  instance: string
+  createdAt: string
+  [k: string]: unknown
+}
+
+const hashMain = 'main'
+
+export function isMain<V>(v: V) {
+  return is$typed(v, id, hashMain)
+}
+
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain, true)
+}
+
+export {
+  type Main as Record,
+  isMain as isRecord,
+  validateMain as validateRecord,
+}

src/lexicon/types/sh/tangled/string.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../lexicons'
+import { type $Typed, is$typed as _is$typed, type OmitKey } from '../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'sh.tangled.string'
+
+export interface Main {
+  $type: 'sh.tangled.string'
+  filename: string
+  description: string
+  createdAt: string
+  contents: string
+  [k: string]: unknown
+}
+
+const hashMain = 'main'
+
+export function isMain<V>(v: V) {
+  return is$typed(v, id, hashMain)
+}
+
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain, true)
+}
+
+export {
+  type Main as Record,
+  isMain as isRecord,
+  validateMain as validateRecord,
+}

src/lexicon/util.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+
+import { type ValidationResult } from '@atproto/lexicon'
+
+export type OmitKey<T, K extends keyof T> = {
+  [K2 in keyof T as K2 extends K ? never : K2]: T[K2]
+}
+
+export type $Typed<V, T extends string = string> = V & { $type: T }
+export type Un$Typed<V extends { $type?: string }> = OmitKey<V, '$type'>
+
+export type $Type<Id extends string, Hash extends string> = Hash extends 'main'
+  ? Id
+  : `${Id}#${Hash}`
+
+function isObject<V>(v: V): v is V & object {
+  return v != null && typeof v === 'object'
+}
+
+function is$type<Id extends string, Hash extends string>(
+  $type: unknown,
+  id: Id,
+  hash: Hash,
+): $type is $Type<Id, Hash> {
+  return hash === 'main'
+    ? $type === id
+    : // $type === `${id}#${hash}`
+      typeof $type === 'string' &&
+        $type.length === id.length + 1 + hash.length &&
+        $type.charCodeAt(id.length) === 35 /* '#' */ &&
+        $type.startsWith(id) &&
+        $type.endsWith(hash)
+}
+
+export type $TypedObject<
+  V,
+  Id extends string,
+  Hash extends string,
+> = V extends {
+  $type: $Type<Id, Hash>
+}
+  ? V
+  : V extends { $type?: string }
+    ? V extends { $type?: infer T extends $Type<Id, Hash> }
+      ? V & { $type: T }
+      : never
+    : V & { $type: $Type<Id, Hash> }
+
+export function is$typed<V, Id extends string, Hash extends string>(
+  v: V,
+  id: Id,
+  hash: Hash,
+): v is $TypedObject<V, Id, Hash> {
+  return isObject(v) && '$type' in v && is$type(v.$type, id, hash)
+}
+
+export function maybe$typed<V, Id extends string, Hash extends string>(
+  v: V,
+  id: Id,
+  hash: Hash,
+): v is V & object & { $type?: $Type<Id, Hash> } {
+  return (
+    isObject(v) &&
+    ('$type' in v ? v.$type === undefined || is$type(v.$type, id, hash) : true)
+  )
+}
+
+export type Validator<R = unknown> = (v: unknown) => ValidationResult<R>
+export type ValidatorParam<V extends Validator> =
+  V extends Validator<infer R> ? R : never
+
+/**
+ * Utility function that allows to convert a "validate*" utility function into a
+ * type predicate.
+ */
+export function asPredicate<V extends Validator>(validate: V) {
+  return function <T>(v: T): v is T & ValidatorParam<V> {
+    return validate(v).success
+  }
+}