initial commit

.gitignore

···
+node_modules/
+dist/
+
+.npm-*.log
+.pnpm-*.log
+.yarn-*.log
+npm-*.log
+pnpm-*.log
+yarn-*.log
+
+*.local
+
+tsconfig.tsbuildinfo

.npmrc

···
+@jsr:registry=https://npm.jsr.io

.prettierignore

···
+pnpm-lock.yaml

.prettierrc

···
+{
+	"trailingComma": "all",
+	"useTabs": true,
+	"tabWidth": 2,
+	"printWidth": 110,
+	"semi": true,
+	"singleQuote": true,
+	"bracketSpacing": true,
+	"overrides": [
+		{
+			"files": ["tsconfig.json", "jsconfig.json"],
+			"options": {
+				"parser": "jsonc"
+			}
+		}
+	]
+}

.vscode/settings.json

···
+{
+	"editor.defaultFormatter": "esbenp.prettier-vscode",
+	"typescript.tsdk": "node_modules/typescript/lib"
+}

lexicons/README.md

···
+https://github.com/bluesky-social/atproto/tree/dc471da267955d0962a8affaf983df60d962d97c/lexicons

lexicons/app/bsky/actor/defs.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.actor.defs",
+	"defs": {
+		"profileViewBasic": {
+			"type": "object",
+			"required": ["did", "handle"],
+			"properties": {
+				"did": { "type": "string", "format": "did" },
+				"handle": { "type": "string", "format": "handle" },
+				"displayName": {
+					"type": "string",
+					"maxGraphemes": 64,
+					"maxLength": 640
+				},
+				"avatar": { "type": "string", "format": "uri" },
+				"associated": {
+					"type": "ref",
+					"ref": "#profileAssociated"
+				},
+				"viewer": { "type": "ref", "ref": "#viewerState" },
+				"labels": {
+					"type": "array",
+					"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+				},
+				"createdAt": { "type": "string", "format": "datetime" }
+			}
+		},
+		"profileView": {
+			"type": "object",
+			"required": ["did", "handle"],
+			"properties": {
+				"did": { "type": "string", "format": "did" },
+				"handle": { "type": "string", "format": "handle" },
+				"displayName": {
+					"type": "string",
+					"maxGraphemes": 64,
+					"maxLength": 640
+				},
+				"description": {
+					"type": "string",
+					"maxGraphemes": 256,
+					"maxLength": 2560
+				},
+				"avatar": { "type": "string", "format": "uri" },
+				"associated": {
+					"type": "ref",
+					"ref": "#profileAssociated"
+				},
+				"indexedAt": { "type": "string", "format": "datetime" },
+				"createdAt": { "type": "string", "format": "datetime" },
+				"viewer": { "type": "ref", "ref": "#viewerState" },
+				"labels": {
+					"type": "array",
+					"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+				}
+			}
+		},
+		"profileViewDetailed": {
+			"type": "object",
+			"required": ["did", "handle"],
+			"properties": {
+				"did": { "type": "string", "format": "did" },
+				"handle": { "type": "string", "format": "handle" },
+				"displayName": {
+					"type": "string",
+					"maxGraphemes": 64,
+					"maxLength": 640
+				},
+				"description": {
+					"type": "string",
+					"maxGraphemes": 256,
+					"maxLength": 2560
+				},
+				"avatar": { "type": "string", "format": "uri" },
+				"banner": { "type": "string", "format": "uri" },
+				"followersCount": { "type": "integer" },
+				"followsCount": { "type": "integer" },
+				"postsCount": { "type": "integer" },
+				"associated": {
+					"type": "ref",
+					"ref": "#profileAssociated"
+				},
+				"joinedViaStarterPack": {
+					"type": "ref",
+					"ref": "app.bsky.graph.defs#starterPackViewBasic"
+				},
+				"indexedAt": { "type": "string", "format": "datetime" },
+				"createdAt": { "type": "string", "format": "datetime" },
+				"viewer": { "type": "ref", "ref": "#viewerState" },
+				"labels": {
+					"type": "array",
+					"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+				}
+			}
+		},
+		"profileAssociated": {
+			"type": "object",
+			"properties": {
+				"lists": { "type": "integer" },
+				"feedgens": { "type": "integer" },
+				"starterPacks": { "type": "integer" },
+				"labeler": { "type": "boolean" },
+				"chat": { "type": "ref", "ref": "#profileAssociatedChat" }
+			}
+		},
+		"profileAssociatedChat": {
+			"type": "object",
+			"required": ["allowIncoming"],
+			"properties": {
+				"allowIncoming": {
+					"type": "string",
+					"knownValues": ["all", "none", "following"]
+				}
+			}
+		},
+		"viewerState": {
+			"type": "object",
+			"description": "Metadata about the requesting account's relationship with the subject account. Only has meaningful content for authed requests.",
+			"properties": {
+				"muted": { "type": "boolean" },
+				"mutedByList": {
+					"type": "ref",
+					"ref": "app.bsky.graph.defs#listViewBasic"
+				},
+				"blockedBy": { "type": "boolean" },
+				"blocking": { "type": "string", "format": "at-uri" },
+				"blockingByList": {
+					"type": "ref",
+					"ref": "app.bsky.graph.defs#listViewBasic"
+				},
+				"following": { "type": "string", "format": "at-uri" },
+				"followedBy": { "type": "string", "format": "at-uri" },
+				"knownFollowers": {
+					"type": "ref",
+					"ref": "#knownFollowers"
+				}
+			}
+		},
+		"knownFollowers": {
+			"type": "object",
+			"description": "The subject's followers whom you also follow",
+			"required": ["count", "followers"],
+			"properties": {
+				"count": { "type": "integer" },
+				"followers": {
+					"type": "array",
+					"minLength": 0,
+					"maxLength": 5,
+					"items": {
+						"type": "ref",
+						"ref": "#profileViewBasic"
+					}
+				}
+			}
+		},
+		"preferences": {
+			"type": "array",
+			"items": {
+				"type": "union",
+				"refs": [
+					"#adultContentPref",
+					"#contentLabelPref",
+					"#savedFeedsPref",
+					"#savedFeedsPrefV2",
+					"#personalDetailsPref",
+					"#feedViewPref",
+					"#threadViewPref",
+					"#interestsPref",
+					"#mutedWordsPref",
+					"#hiddenPostsPref",
+					"#bskyAppStatePref",
+					"#labelersPref"
+				]
+			}
+		},
+		"adultContentPref": {
+			"type": "object",
+			"required": ["enabled"],
+			"properties": {
+				"enabled": { "type": "boolean", "default": false }
+			}
+		},
+		"contentLabelPref": {
+			"type": "object",
+			"required": ["label", "visibility"],
+			"properties": {
+				"labelerDid": {
+					"type": "string",
+					"description": "Which labeler does this preference apply to? If undefined, applies globally.",
+					"format": "did"
+				},
+				"label": { "type": "string" },
+				"visibility": {
+					"type": "string",
+					"knownValues": ["ignore", "show", "warn", "hide"]
+				}
+			}
+		},
+		"savedFeed": {
+			"type": "object",
+			"required": ["id", "type", "value", "pinned"],
+			"properties": {
+				"id": {
+					"type": "string"
+				},
+				"type": {
+					"type": "string",
+					"knownValues": ["feed", "list", "timeline"]
+				},
+				"value": {
+					"type": "string"
+				},
+				"pinned": {
+					"type": "boolean"
+				}
+			}
+		},
+		"savedFeedsPrefV2": {
+			"type": "object",
+			"required": ["items"],
+			"properties": {
+				"items": {
+					"type": "array",
+					"items": {
+						"type": "ref",
+						"ref": "app.bsky.actor.defs#savedFeed"
+					}
+				}
+			}
+		},
+		"savedFeedsPref": {
+			"type": "object",
+			"required": ["pinned", "saved"],
+			"properties": {
+				"pinned": {
+					"type": "array",
+					"items": {
+						"type": "string",
+						"format": "at-uri"
+					}
+				},
+				"saved": {
+					"type": "array",
+					"items": {
+						"type": "string",
+						"format": "at-uri"
+					}
+				},
+				"timelineIndex": {
+					"type": "integer"
+				}
+			}
+		},
+		"personalDetailsPref": {
+			"type": "object",
+			"properties": {
+				"birthDate": {
+					"type": "string",
+					"format": "datetime",
+					"description": "The birth date of account owner."
+				}
+			}
+		},
+		"feedViewPref": {
+			"type": "object",
+			"required": ["feed"],
+			"properties": {
+				"feed": {
+					"type": "string",
+					"description": "The URI of the feed, or an identifier which describes the feed."
+				},
+				"hideReplies": {
+					"type": "boolean",
+					"description": "Hide replies in the feed."
+				},
+				"hideRepliesByUnfollowed": {
+					"type": "boolean",
+					"description": "Hide replies in the feed if they are not by followed users.",
+					"default": true
+				},
+				"hideRepliesByLikeCount": {
+					"type": "integer",
+					"description": "Hide replies in the feed if they do not have this number of likes."
+				},
+				"hideReposts": {
+					"type": "boolean",
+					"description": "Hide reposts in the feed."
+				},
+				"hideQuotePosts": {
+					"type": "boolean",
+					"description": "Hide quote posts in the feed."
+				}
+			}
+		},
+		"threadViewPref": {
+			"type": "object",
+			"properties": {
+				"sort": {
+					"type": "string",
+					"description": "Sorting mode for threads.",
+					"knownValues": ["oldest", "newest", "most-likes", "random"]
+				},
+				"prioritizeFollowedUsers": {
+					"type": "boolean",
+					"description": "Show followed users at the top of all replies."
+				}
+			}
+		},
+		"interestsPref": {
+			"type": "object",
+			"required": ["tags"],
+			"properties": {
+				"tags": {
+					"type": "array",
+					"maxLength": 100,
+					"items": { "type": "string", "maxLength": 640, "maxGraphemes": 64 },
+					"description": "A list of tags which describe the account owner's interests gathered during onboarding."
+				}
+			}
+		},
+		"mutedWordTarget": {
+			"type": "string",
+			"knownValues": ["content", "tag"],
+			"maxLength": 640,
+			"maxGraphemes": 64
+		},
+		"mutedWord": {
+			"type": "object",
+			"description": "A word that the account owner has muted.",
+			"required": ["value", "targets"],
+			"properties": {
+				"id": { "type": "string" },
+				"value": {
+					"type": "string",
+					"description": "The muted word itself.",
+					"maxLength": 10000,
+					"maxGraphemes": 1000
+				},
+				"targets": {
+					"type": "array",
+					"description": "The intended targets of the muted word.",
+					"items": {
+						"type": "ref",
+						"ref": "app.bsky.actor.defs#mutedWordTarget"
+					}
+				},
+				"actorTarget": {
+					"type": "string",
+					"description": "Groups of users to apply the muted word to. If undefined, applies to all users.",
+					"knownValues": ["all", "exclude-following"],
+					"default": "all"
+				},
+				"expiresAt": {
+					"type": "string",
+					"format": "datetime",
+					"description": "The date and time at which the muted word will expire and no longer be applied."
+				}
+			}
+		},
+		"mutedWordsPref": {
+			"type": "object",
+			"required": ["items"],
+			"properties": {
+				"items": {
+					"type": "array",
+					"items": {
+						"type": "ref",
+						"ref": "app.bsky.actor.defs#mutedWord"
+					},
+					"description": "A list of words the account owner has muted."
+				}
+			}
+		},
+		"hiddenPostsPref": {
+			"type": "object",
+			"required": ["items"],
+			"properties": {
+				"items": {
+					"type": "array",
+					"items": { "type": "string", "format": "at-uri" },
+					"description": "A list of URIs of posts the account owner has hidden."
+				}
+			}
+		},
+		"labelersPref": {
+			"type": "object",
+			"required": ["labelers"],
+			"properties": {
+				"labelers": {
+					"type": "array",
+					"items": {
+						"type": "ref",
+						"ref": "#labelerPrefItem"
+					}
+				}
+			}
+		},
+		"labelerPrefItem": {
+			"type": "object",
+			"required": ["did"],
+			"properties": {
+				"did": {
+					"type": "string",
+					"format": "did"
+				}
+			}
+		},
+		"bskyAppStatePref": {
+			"description": "A grab bag of state that's specific to the bsky.app program. Third-party apps shouldn't use this.",
+			"type": "object",
+			"properties": {
+				"activeProgressGuide": {
+					"type": "ref",
+					"ref": "#bskyAppProgressGuide"
+				},
+				"queuedNudges": {
+					"description": "An array of tokens which identify nudges (modals, popups, tours, highlight dots) that should be shown to the user.",
+					"type": "array",
+					"maxLength": 1000,
+					"items": { "type": "string", "maxLength": 100 }
+				}
+			}
+		},
+		"bskyAppProgressGuide": {
+			"description": "If set, an active progress guide. Once completed, can be set to undefined. Should have unspecced fields tracking progress.",
+			"type": "object",
+			"required": ["guide"],
+			"properties": {
+				"guide": { "type": "string", "maxLength": 100 }
+			}
+		}
+	}
+}

lexicons/app/bsky/actor/getPreferences.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.actor.getPreferences",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get private preferences attached to the current account. Expected use is synchronization between multiple devices, and import/export during account migration. Requires auth.",
+			"parameters": {
+				"type": "params",
+				"properties": {}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["preferences"],
+					"properties": {
+						"preferences": {
+							"type": "ref",
+							"ref": "app.bsky.actor.defs#preferences"
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/actor/getProfile.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.actor.getProfile",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get detailed profile view of an actor. Does not require auth, but contains relevant metadata with auth.",
+			"parameters": {
+				"type": "params",
+				"required": ["actor"],
+				"properties": {
+					"actor": {
+						"type": "string",
+						"format": "at-identifier",
+						"description": "Handle or DID of account to fetch profile of."
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "ref",
+					"ref": "app.bsky.actor.defs#profileViewDetailed"
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/actor/getProfiles.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.actor.getProfiles",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get detailed profile views of multiple actors.",
+			"parameters": {
+				"type": "params",
+				"required": ["actors"],
+				"properties": {
+					"actors": {
+						"type": "array",
+						"items": { "type": "string", "format": "at-identifier" },
+						"maxLength": 25
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["profiles"],
+					"properties": {
+						"profiles": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "app.bsky.actor.defs#profileViewDetailed"
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/actor/getSuggestions.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.actor.getSuggestions",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get a list of suggested actors. Expected use is discovery of accounts to follow during new account onboarding.",
+			"parameters": {
+				"type": "params",
+				"properties": {
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 50
+					},
+					"cursor": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["actors"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"actors": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "app.bsky.actor.defs#profileView"
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/actor/profile.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.actor.profile",
+	"defs": {
+		"main": {
+			"type": "record",
+			"description": "A declaration of a Bluesky account profile.",
+			"key": "literal:self",
+			"record": {
+				"type": "object",
+				"properties": {
+					"displayName": {
+						"type": "string",
+						"maxGraphemes": 64,
+						"maxLength": 640
+					},
+					"description": {
+						"type": "string",
+						"description": "Free-form profile description text.",
+						"maxGraphemes": 256,
+						"maxLength": 2560
+					},
+					"avatar": {
+						"type": "blob",
+						"description": "Small image to be displayed next to posts from account. AKA, 'profile picture'",
+						"accept": ["image/png", "image/jpeg"],
+						"maxSize": 1000000
+					},
+					"banner": {
+						"type": "blob",
+						"description": "Larger horizontal image to display behind profile view.",
+						"accept": ["image/png", "image/jpeg"],
+						"maxSize": 1000000
+					},
+					"labels": {
+						"type": "union",
+						"description": "Self-label values, specific to the Bluesky application, on the overall account.",
+						"refs": ["com.atproto.label.defs#selfLabels"]
+					},
+					"joinedViaStarterPack": {
+						"type": "ref",
+						"ref": "com.atproto.repo.strongRef"
+					},
+					"createdAt": { "type": "string", "format": "datetime" }
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/actor/putPreferences.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.actor.putPreferences",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Set the private preferences attached to the account.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["preferences"],
+					"properties": {
+						"preferences": {
+							"type": "ref",
+							"ref": "app.bsky.actor.defs#preferences"
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/actor/searchActors.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.actor.searchActors",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Find actors (profiles) matching search criteria. Does not require auth.",
+			"parameters": {
+				"type": "params",
+				"properties": {
+					"term": {
+						"type": "string",
+						"description": "DEPRECATED: use 'q' instead."
+					},
+					"q": {
+						"type": "string",
+						"description": "Search query string. Syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended."
+					},
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 25
+					},
+					"cursor": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["actors"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"actors": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "app.bsky.actor.defs#profileView"
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/actor/searchActorsTypeahead.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.actor.searchActorsTypeahead",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Find actor suggestions for a prefix search term. Expected use is for auto-completion during text field entry. Does not require auth.",
+			"parameters": {
+				"type": "params",
+				"properties": {
+					"term": {
+						"type": "string",
+						"description": "DEPRECATED: use 'q' instead."
+					},
+					"q": {
+						"type": "string",
+						"description": "Search query prefix; not a full query string."
+					},
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 10
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["actors"],
+					"properties": {
+						"actors": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "app.bsky.actor.defs#profileViewBasic"
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/embed/external.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.embed.external",
+	"defs": {
+		"main": {
+			"type": "object",
+			"description": "A representation of some externally linked content (eg, a URL and 'card'), embedded in a Bluesky record (eg, a post).",
+			"required": ["external"],
+			"properties": {
+				"external": {
+					"type": "ref",
+					"ref": "#external"
+				}
+			}
+		},
+		"external": {
+			"type": "object",
+			"required": ["uri", "title", "description"],
+			"properties": {
+				"uri": { "type": "string", "format": "uri" },
+				"title": { "type": "string" },
+				"description": { "type": "string" },
+				"thumb": {
+					"type": "blob",
+					"accept": ["image/*"],
+					"maxSize": 1000000
+				}
+			}
+		},
+		"view": {
+			"type": "object",
+			"required": ["external"],
+			"properties": {
+				"external": {
+					"type": "ref",
+					"ref": "#viewExternal"
+				}
+			}
+		},
+		"viewExternal": {
+			"type": "object",
+			"required": ["uri", "title", "description"],
+			"properties": {
+				"uri": { "type": "string", "format": "uri" },
+				"title": { "type": "string" },
+				"description": { "type": "string" },
+				"thumb": { "type": "string", "format": "uri" }
+			}
+		}
+	}
+}

lexicons/app/bsky/embed/images.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.embed.images",
+	"description": "A set of images embedded in a Bluesky record (eg, a post).",
+	"defs": {
+		"main": {
+			"type": "object",
+			"required": ["images"],
+			"properties": {
+				"images": {
+					"type": "array",
+					"items": { "type": "ref", "ref": "#image" },
+					"maxLength": 4
+				}
+			}
+		},
+		"image": {
+			"type": "object",
+			"required": ["image", "alt"],
+			"properties": {
+				"image": {
+					"type": "blob",
+					"accept": ["image/*"],
+					"maxSize": 1000000
+				},
+				"alt": {
+					"type": "string",
+					"description": "Alt text description of the image, for accessibility."
+				},
+				"aspectRatio": { "type": "ref", "ref": "#aspectRatio" }
+			}
+		},
+		"aspectRatio": {
+			"type": "object",
+			"description": "width:height represents an aspect ratio. It may be approximate, and may not correspond to absolute dimensions in any given unit.",
+			"required": ["width", "height"],
+			"properties": {
+				"width": { "type": "integer", "minimum": 1 },
+				"height": { "type": "integer", "minimum": 1 }
+			}
+		},
+		"view": {
+			"type": "object",
+			"required": ["images"],
+			"properties": {
+				"images": {
+					"type": "array",
+					"items": { "type": "ref", "ref": "#viewImage" },
+					"maxLength": 4
+				}
+			}
+		},
+		"viewImage": {
+			"type": "object",
+			"required": ["thumb", "fullsize", "alt"],
+			"properties": {
+				"thumb": {
+					"type": "string",
+					"format": "uri",
+					"description": "Fully-qualified URL where a thumbnail of the image can be fetched. For example, CDN location provided by the App View."
+				},
+				"fullsize": {
+					"type": "string",
+					"format": "uri",
+					"description": "Fully-qualified URL where a large version of the image can be fetched. May or may not be the exact original blob. For example, CDN location provided by the App View."
+				},
+				"alt": {
+					"type": "string",
+					"description": "Alt text description of the image, for accessibility."
+				},
+				"aspectRatio": { "type": "ref", "ref": "#aspectRatio" }
+			}
+		}
+	}
+}

lexicons/app/bsky/embed/record.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.embed.record",
+	"description": "A representation of a record embedded in a Bluesky record (eg, a post). For example, a quote-post, or sharing a feed generator record.",
+	"defs": {
+		"main": {
+			"type": "object",
+			"required": ["record"],
+			"properties": {
+				"record": { "type": "ref", "ref": "com.atproto.repo.strongRef" }
+			}
+		},
+		"view": {
+			"type": "object",
+			"required": ["record"],
+			"properties": {
+				"record": {
+					"type": "union",
+					"refs": [
+						"#viewRecord",
+						"#viewNotFound",
+						"#viewBlocked",
+						"app.bsky.feed.defs#generatorView",
+						"app.bsky.graph.defs#listView",
+						"app.bsky.labeler.defs#labelerView",
+						"app.bsky.graph.defs#starterPackViewBasic"
+					]
+				}
+			}
+		},
+		"viewRecord": {
+			"type": "object",
+			"required": ["uri", "cid", "author", "value", "indexedAt"],
+			"properties": {
+				"uri": { "type": "string", "format": "at-uri" },
+				"cid": { "type": "string", "format": "cid" },
+				"author": {
+					"type": "ref",
+					"ref": "app.bsky.actor.defs#profileViewBasic"
+				},
+				"value": {
+					"type": "unknown",
+					"description": "The record data itself."
+				},
+				"labels": {
+					"type": "array",
+					"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+				},
+				"replyCount": { "type": "integer" },
+				"repostCount": { "type": "integer" },
+				"likeCount": { "type": "integer" },
+				"embeds": {
+					"type": "array",
+					"items": {
+						"type": "union",
+						"refs": [
+							"app.bsky.embed.images#view",
+							"app.bsky.embed.external#view",
+							"app.bsky.embed.record#view",
+							"app.bsky.embed.recordWithMedia#view"
+						]
+					}
+				},
+				"indexedAt": { "type": "string", "format": "datetime" }
+			}
+		},
+		"viewNotFound": {
+			"type": "object",
+			"required": ["uri", "notFound"],
+			"properties": {
+				"uri": { "type": "string", "format": "at-uri" },
+				"notFound": { "type": "boolean", "const": true }
+			}
+		},
+		"viewBlocked": {
+			"type": "object",
+			"required": ["uri", "blocked", "author"],
+			"properties": {
+				"uri": { "type": "string", "format": "at-uri" },
+				"blocked": { "type": "boolean", "const": true },
+				"author": { "type": "ref", "ref": "app.bsky.feed.defs#blockedAuthor" }
+			}
+		}
+	}
+}

lexicons/app/bsky/embed/recordWithMedia.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.embed.recordWithMedia",
+	"description": "A representation of a record embedded in a Bluesky record (eg, a post), alongside other compatible embeds. For example, a quote post and image, or a quote post and external URL card.",
+	"defs": {
+		"main": {
+			"type": "object",
+			"required": ["record", "media"],
+			"properties": {
+				"record": {
+					"type": "ref",
+					"ref": "app.bsky.embed.record"
+				},
+				"media": {
+					"type": "union",
+					"refs": ["app.bsky.embed.images", "app.bsky.embed.external"]
+				}
+			}
+		},
+		"view": {
+			"type": "object",
+			"required": ["record", "media"],
+			"properties": {
+				"record": {
+					"type": "ref",
+					"ref": "app.bsky.embed.record#view"
+				},
+				"media": {
+					"type": "union",
+					"refs": ["app.bsky.embed.images#view", "app.bsky.embed.external#view"]
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/feed/defs.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.feed.defs",
+	"defs": {
+		"postView": {
+			"type": "object",
+			"required": ["uri", "cid", "author", "record", "indexedAt"],
+			"properties": {
+				"uri": { "type": "string", "format": "at-uri" },
+				"cid": { "type": "string", "format": "cid" },
+				"author": {
+					"type": "ref",
+					"ref": "app.bsky.actor.defs#profileViewBasic"
+				},
+				"record": { "type": "unknown" },
+				"embed": {
+					"type": "union",
+					"refs": [
+						"app.bsky.embed.images#view",
+						"app.bsky.embed.external#view",
+						"app.bsky.embed.record#view",
+						"app.bsky.embed.recordWithMedia#view"
+					]
+				},
+				"replyCount": { "type": "integer" },
+				"repostCount": { "type": "integer" },
+				"likeCount": { "type": "integer" },
+				"indexedAt": { "type": "string", "format": "datetime" },
+				"viewer": { "type": "ref", "ref": "#viewerState" },
+				"labels": {
+					"type": "array",
+					"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+				},
+				"threadgate": { "type": "ref", "ref": "#threadgateView" }
+			}
+		},
+		"viewerState": {
+			"type": "object",
+			"description": "Metadata about the requesting account's relationship with the subject content. Only has meaningful content for authed requests.",
+			"properties": {
+				"repost": { "type": "string", "format": "at-uri" },
+				"like": { "type": "string", "format": "at-uri" },
+				"threadMuted": { "type": "boolean" },
+				"replyDisabled": { "type": "boolean" }
+			}
+		},
+		"feedViewPost": {
+			"type": "object",
+			"required": ["post"],
+			"properties": {
+				"post": { "type": "ref", "ref": "#postView" },
+				"reply": { "type": "ref", "ref": "#replyRef" },
+				"reason": { "type": "union", "refs": ["#reasonRepost"] },
+				"feedContext": {
+					"type": "string",
+					"description": "Context provided by feed generator that may be passed back alongside interactions.",
+					"maxLength": 2000
+				}
+			}
+		},
+		"replyRef": {
+			"type": "object",
+			"required": ["root", "parent"],
+			"properties": {
+				"root": {
+					"type": "union",
+					"refs": ["#postView", "#notFoundPost", "#blockedPost"]
+				},
+				"parent": {
+					"type": "union",
+					"refs": ["#postView", "#notFoundPost", "#blockedPost"]
+				},
+				"grandparentAuthor": {
+					"type": "ref",
+					"ref": "app.bsky.actor.defs#profileViewBasic",
+					"description": "When parent is a reply to another post, this is the author of that post."
+				}
+			}
+		},
+		"reasonRepost": {
+			"type": "object",
+			"required": ["by", "indexedAt"],
+			"properties": {
+				"by": { "type": "ref", "ref": "app.bsky.actor.defs#profileViewBasic" },
+				"indexedAt": { "type": "string", "format": "datetime" }
+			}
+		},
+		"threadViewPost": {
+			"type": "object",
+			"required": ["post"],
+			"properties": {
+				"post": { "type": "ref", "ref": "#postView" },
+				"parent": {
+					"type": "union",
+					"refs": ["#threadViewPost", "#notFoundPost", "#blockedPost"]
+				},
+				"replies": {
+					"type": "array",
+					"items": {
+						"type": "union",
+						"refs": ["#threadViewPost", "#notFoundPost", "#blockedPost"]
+					}
+				}
+			}
+		},
+		"notFoundPost": {
+			"type": "object",
+			"required": ["uri", "notFound"],
+			"properties": {
+				"uri": { "type": "string", "format": "at-uri" },
+				"notFound": { "type": "boolean", "const": true }
+			}
+		},
+		"blockedPost": {
+			"type": "object",
+			"required": ["uri", "blocked", "author"],
+			"properties": {
+				"uri": { "type": "string", "format": "at-uri" },
+				"blocked": { "type": "boolean", "const": true },
+				"author": { "type": "ref", "ref": "#blockedAuthor" }
+			}
+		},
+		"blockedAuthor": {
+			"type": "object",
+			"required": ["did"],
+			"properties": {
+				"did": { "type": "string", "format": "did" },
+				"viewer": { "type": "ref", "ref": "app.bsky.actor.defs#viewerState" }
+			}
+		},
+		"generatorView": {
+			"type": "object",
+			"required": ["uri", "cid", "did", "creator", "displayName", "indexedAt"],
+			"properties": {
+				"uri": { "type": "string", "format": "at-uri" },
+				"cid": { "type": "string", "format": "cid" },
+				"did": { "type": "string", "format": "did" },
+				"creator": { "type": "ref", "ref": "app.bsky.actor.defs#profileView" },
+				"displayName": { "type": "string" },
+				"description": {
+					"type": "string",
+					"maxGraphemes": 300,
+					"maxLength": 3000
+				},
+				"descriptionFacets": {
+					"type": "array",
+					"items": { "type": "ref", "ref": "app.bsky.richtext.facet" }
+				},
+				"avatar": { "type": "string", "format": "uri" },
+				"likeCount": { "type": "integer", "minimum": 0 },
+				"acceptsInteractions": { "type": "boolean" },
+				"labels": {
+					"type": "array",
+					"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+				},
+				"viewer": { "type": "ref", "ref": "#generatorViewerState" },
+				"indexedAt": { "type": "string", "format": "datetime" }
+			}
+		},
+		"generatorViewerState": {
+			"type": "object",
+			"properties": {
+				"like": { "type": "string", "format": "at-uri" }
+			}
+		},
+		"skeletonFeedPost": {
+			"type": "object",
+			"required": ["post"],
+			"properties": {
+				"post": { "type": "string", "format": "at-uri" },
+				"reason": { "type": "union", "refs": ["#skeletonReasonRepost"] },
+				"feedContext": {
+					"type": "string",
+					"description": "Context that will be passed through to client and may be passed to feed generator back alongside interactions.",
+					"maxLength": 2000
+				}
+			}
+		},
+		"skeletonReasonRepost": {
+			"type": "object",
+			"required": ["repost"],
+			"properties": {
+				"repost": { "type": "string", "format": "at-uri" }
+			}
+		},
+		"threadgateView": {
+			"type": "object",
+			"properties": {
+				"uri": { "type": "string", "format": "at-uri" },
+				"cid": { "type": "string", "format": "cid" },
+				"record": { "type": "unknown" },
+				"lists": {
+					"type": "array",
+					"items": { "type": "ref", "ref": "app.bsky.graph.defs#listViewBasic" }
+				}
+			}
+		},
+		"interaction": {
+			"type": "object",
+			"properties": {
+				"item": { "type": "string", "format": "at-uri" },
+				"event": {
+					"type": "string",
+					"knownValues": [
+						"app.bsky.feed.defs#requestLess",
+						"app.bsky.feed.defs#requestMore",
+						"app.bsky.feed.defs#clickthroughItem",
+						"app.bsky.feed.defs#clickthroughAuthor",
+						"app.bsky.feed.defs#clickthroughReposter",
+						"app.bsky.feed.defs#clickthroughEmbed",
+						"app.bsky.feed.defs#interactionSeen",
+						"app.bsky.feed.defs#interactionLike",
+						"app.bsky.feed.defs#interactionRepost",
+						"app.bsky.feed.defs#interactionReply",
+						"app.bsky.feed.defs#interactionQuote",
+						"app.bsky.feed.defs#interactionShare"
+					]
+				},
+				"feedContext": {
+					"type": "string",
+					"description": "Context on a feed item that was originally supplied by the feed generator on getFeedSkeleton.",
+					"maxLength": 2000
+				}
+			}
+		},
+		"requestLess": {
+			"type": "token",
+			"description": "Request that less content like the given feed item be shown in the feed"
+		},
+		"requestMore": {
+			"type": "token",
+			"description": "Request that more content like the given feed item be shown in the feed"
+		},
+		"clickthroughItem": {
+			"type": "token",
+			"description": "User clicked through to the feed item"
+		},
+		"clickthroughAuthor": {
+			"type": "token",
+			"description": "User clicked through to the author of the feed item"
+		},
+		"clickthroughReposter": {
+			"type": "token",
+			"description": "User clicked through to the reposter of the feed item"
+		},
+		"clickthroughEmbed": {
+			"type": "token",
+			"description": "User clicked through to the embedded content of the feed item"
+		},
+		"interactionSeen": {
+			"type": "token",
+			"description": "Feed item was seen by user"
+		},
+		"interactionLike": {
+			"type": "token",
+			"description": "User liked the feed item"
+		},
+		"interactionRepost": {
+			"type": "token",
+			"description": "User reposted the feed item"
+		},
+		"interactionReply": {
+			"type": "token",
+			"description": "User replied to the feed item"
+		},
+		"interactionQuote": {
+			"type": "token",
+			"description": "User quoted the feed item"
+		},
+		"interactionShare": {
+			"type": "token",
+			"description": "User shared the feed item"
+		}
+	}
+}

lexicons/app/bsky/feed/describeFeedGenerator.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.feed.describeFeedGenerator",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get information about a feed generator, including policies and offered feed URIs. Does not require auth; implemented by Feed Generator services (not App View).",
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["did", "feeds"],
+					"properties": {
+						"did": { "type": "string", "format": "did" },
+						"feeds": {
+							"type": "array",
+							"items": { "type": "ref", "ref": "#feed" }
+						},
+						"links": { "type": "ref", "ref": "#links" }
+					}
+				}
+			}
+		},
+		"feed": {
+			"type": "object",
+			"required": ["uri"],
+			"properties": {
+				"uri": { "type": "string", "format": "at-uri" }
+			}
+		},
+		"links": {
+			"type": "object",
+			"properties": {
+				"privacyPolicy": { "type": "string" },
+				"termsOfService": { "type": "string" }
+			}
+		}
+	}
+}

lexicons/app/bsky/feed/generator.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.feed.generator",
+	"defs": {
+		"main": {
+			"type": "record",
+			"description": "Record declaring of the existence of a feed generator, and containing metadata about it. The record can exist in any repository.",
+			"key": "any",
+			"record": {
+				"type": "object",
+				"required": ["did", "displayName", "createdAt"],
+				"properties": {
+					"did": { "type": "string", "format": "did" },
+					"displayName": {
+						"type": "string",
+						"maxGraphemes": 24,
+						"maxLength": 240
+					},
+					"description": {
+						"type": "string",
+						"maxGraphemes": 300,
+						"maxLength": 3000
+					},
+					"descriptionFacets": {
+						"type": "array",
+						"items": { "type": "ref", "ref": "app.bsky.richtext.facet" }
+					},
+					"avatar": {
+						"type": "blob",
+						"accept": ["image/png", "image/jpeg"],
+						"maxSize": 1000000
+					},
+					"acceptsInteractions": {
+						"type": "boolean",
+						"description": "Declaration that a feed accepts feedback interactions from a client through app.bsky.feed.sendInteractions"
+					},
+					"labels": {
+						"type": "union",
+						"description": "Self-label values",
+						"refs": ["com.atproto.label.defs#selfLabels"]
+					},
+					"createdAt": { "type": "string", "format": "datetime" }
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/feed/getActorFeeds.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.feed.getActorFeeds",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get a list of feeds (feed generator records) created by the actor (in the actor's repo).",
+			"parameters": {
+				"type": "params",
+				"required": ["actor"],
+				"properties": {
+					"actor": { "type": "string", "format": "at-identifier" },
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 50
+					},
+					"cursor": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["feeds"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"feeds": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "app.bsky.feed.defs#generatorView"
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/feed/getActorLikes.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.feed.getActorLikes",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get a list of posts liked by an actor. Does not require auth.",
+			"parameters": {
+				"type": "params",
+				"required": ["actor"],
+				"properties": {
+					"actor": { "type": "string", "format": "at-identifier" },
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 50
+					},
+					"cursor": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["feed"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"feed": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "app.bsky.feed.defs#feedViewPost"
+							}
+						}
+					}
+				}
+			},
+			"errors": [{ "name": "BlockedActor" }, { "name": "BlockedByActor" }]
+		}
+	}
+}

lexicons/app/bsky/feed/getAuthorFeed.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.feed.getAuthorFeed",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get a view of an actor's 'author feed' (post and reposts by the author). Does not require auth.",
+			"parameters": {
+				"type": "params",
+				"required": ["actor"],
+				"properties": {
+					"actor": { "type": "string", "format": "at-identifier" },
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 50
+					},
+					"cursor": { "type": "string" },
+					"filter": {
+						"type": "string",
+						"description": "Combinations of post/repost types to include in response.",
+						"knownValues": [
+							"posts_with_replies",
+							"posts_no_replies",
+							"posts_with_media",
+							"posts_and_author_threads"
+						],
+						"default": "posts_with_replies"
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["feed"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"feed": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "app.bsky.feed.defs#feedViewPost"
+							}
+						}
+					}
+				}
+			},
+			"errors": [{ "name": "BlockedActor" }, { "name": "BlockedByActor" }]
+		}
+	}
+}

lexicons/app/bsky/feed/getFeed.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.feed.getFeed",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get a hydrated feed from an actor's selected feed generator. Implemented by App View.",
+			"parameters": {
+				"type": "params",
+				"required": ["feed"],
+				"properties": {
+					"feed": { "type": "string", "format": "at-uri" },
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 50
+					},
+					"cursor": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["feed"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"feed": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "app.bsky.feed.defs#feedViewPost"
+							}
+						}
+					}
+				}
+			},
+			"errors": [{ "name": "UnknownFeed" }]
+		}
+	}
+}

lexicons/app/bsky/feed/getFeedGenerator.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.feed.getFeedGenerator",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get information about a feed generator. Implemented by AppView.",
+			"parameters": {
+				"type": "params",
+				"required": ["feed"],
+				"properties": {
+					"feed": {
+						"type": "string",
+						"format": "at-uri",
+						"description": "AT-URI of the feed generator record."
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["view", "isOnline", "isValid"],
+					"properties": {
+						"view": {
+							"type": "ref",
+							"ref": "app.bsky.feed.defs#generatorView"
+						},
+						"isOnline": {
+							"type": "boolean",
+							"description": "Indicates whether the feed generator service has been online recently, or else seems to be inactive."
+						},
+						"isValid": {
+							"type": "boolean",
+							"description": "Indicates whether the feed generator service is compatible with the record declaration."
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/feed/getFeedGenerators.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.feed.getFeedGenerators",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get information about a list of feed generators.",
+			"parameters": {
+				"type": "params",
+				"required": ["feeds"],
+				"properties": {
+					"feeds": {
+						"type": "array",
+						"items": { "type": "string", "format": "at-uri" }
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["feeds"],
+					"properties": {
+						"feeds": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "app.bsky.feed.defs#generatorView"
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/feed/getFeedSkeleton.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.feed.getFeedSkeleton",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get a skeleton of a feed provided by a feed generator. Auth is optional, depending on provider requirements, and provides the DID of the requester. Implemented by Feed Generator Service.",
+			"parameters": {
+				"type": "params",
+				"required": ["feed"],
+				"properties": {
+					"feed": {
+						"type": "string",
+						"format": "at-uri",
+						"description": "Reference to feed generator record describing the specific feed being requested."
+					},
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 50
+					},
+					"cursor": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["feed"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"feed": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "app.bsky.feed.defs#skeletonFeedPost"
+							}
+						}
+					}
+				}
+			},
+			"errors": [{ "name": "UnknownFeed" }]
+		}
+	}
+}

lexicons/app/bsky/feed/getLikes.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.feed.getLikes",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get like records which reference a subject (by AT-URI and CID).",
+			"parameters": {
+				"type": "params",
+				"required": ["uri"],
+				"properties": {
+					"uri": {
+						"type": "string",
+						"format": "at-uri",
+						"description": "AT-URI of the subject (eg, a post record)."
+					},
+					"cid": {
+						"type": "string",
+						"format": "cid",
+						"description": "CID of the subject record (aka, specific version of record), to filter likes."
+					},
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 50
+					},
+					"cursor": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["uri", "likes"],
+					"properties": {
+						"uri": { "type": "string", "format": "at-uri" },
+						"cid": { "type": "string", "format": "cid" },
+						"cursor": { "type": "string" },
+						"likes": {
+							"type": "array",
+							"items": { "type": "ref", "ref": "#like" }
+						}
+					}
+				}
+			}
+		},
+		"like": {
+			"type": "object",
+			"required": ["indexedAt", "createdAt", "actor"],
+			"properties": {
+				"indexedAt": { "type": "string", "format": "datetime" },
+				"createdAt": { "type": "string", "format": "datetime" },
+				"actor": { "type": "ref", "ref": "app.bsky.actor.defs#profileView" }
+			}
+		}
+	}
+}

lexicons/app/bsky/feed/getListFeed.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.feed.getListFeed",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get a feed of recent posts from a list (posts and reposts from any actors on the list). Does not require auth.",
+			"parameters": {
+				"type": "params",
+				"required": ["list"],
+				"properties": {
+					"list": {
+						"type": "string",
+						"format": "at-uri",
+						"description": "Reference (AT-URI) to the list record."
+					},
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 50
+					},
+					"cursor": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["feed"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"feed": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "app.bsky.feed.defs#feedViewPost"
+							}
+						}
+					}
+				}
+			},
+			"errors": [{ "name": "UnknownList" }]
+		}
+	}
+}

lexicons/app/bsky/feed/getPostThread.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.feed.getPostThread",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get posts in a thread. Does not require auth, but additional metadata and filtering will be applied for authed requests.",
+			"parameters": {
+				"type": "params",
+				"required": ["uri"],
+				"properties": {
+					"uri": {
+						"type": "string",
+						"format": "at-uri",
+						"description": "Reference (AT-URI) to post record."
+					},
+					"depth": {
+						"type": "integer",
+						"description": "How many levels of reply depth should be included in response.",
+						"default": 6,
+						"minimum": 0,
+						"maximum": 1000
+					},
+					"parentHeight": {
+						"type": "integer",
+						"description": "How many levels of parent (and grandparent, etc) post to include.",
+						"default": 80,
+						"minimum": 0,
+						"maximum": 1000
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["thread"],
+					"properties": {
+						"thread": {
+							"type": "union",
+							"refs": [
+								"app.bsky.feed.defs#threadViewPost",
+								"app.bsky.feed.defs#notFoundPost",
+								"app.bsky.feed.defs#blockedPost"
+							]
+						}
+					}
+				}
+			},
+			"errors": [{ "name": "NotFound" }]
+		}
+	}
+}

lexicons/app/bsky/feed/getPosts.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.feed.getPosts",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Gets post views for a specified list of posts (by AT-URI). This is sometimes referred to as 'hydrating' a 'feed skeleton'.",
+			"parameters": {
+				"type": "params",
+				"required": ["uris"],
+				"properties": {
+					"uris": {
+						"type": "array",
+						"description": "List of post AT-URIs to return hydrated views for.",
+						"items": { "type": "string", "format": "at-uri" },
+						"maxLength": 25
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["posts"],
+					"properties": {
+						"posts": {
+							"type": "array",
+							"items": { "type": "ref", "ref": "app.bsky.feed.defs#postView" }
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/feed/getRepostedBy.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.feed.getRepostedBy",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get a list of reposts for a given post.",
+			"parameters": {
+				"type": "params",
+				"required": ["uri"],
+				"properties": {
+					"uri": {
+						"type": "string",
+						"format": "at-uri",
+						"description": "Reference (AT-URI) of post record"
+					},
+					"cid": {
+						"type": "string",
+						"format": "cid",
+						"description": "If supplied, filters to reposts of specific version (by CID) of the post record."
+					},
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 50
+					},
+					"cursor": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["uri", "repostedBy"],
+					"properties": {
+						"uri": { "type": "string", "format": "at-uri" },
+						"cid": { "type": "string", "format": "cid" },
+						"cursor": { "type": "string" },
+						"repostedBy": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "app.bsky.actor.defs#profileView"
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/feed/getSuggestedFeeds.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.feed.getSuggestedFeeds",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get a list of suggested feeds (feed generators) for the requesting account.",
+			"parameters": {
+				"type": "params",
+				"properties": {
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 50
+					},
+					"cursor": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["feeds"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"feeds": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "app.bsky.feed.defs#generatorView"
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/feed/getTimeline.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.feed.getTimeline",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get a view of the requesting account's home timeline. This is expected to be some form of reverse-chronological feed.",
+			"parameters": {
+				"type": "params",
+				"properties": {
+					"algorithm": {
+						"type": "string",
+						"description": "Variant 'algorithm' for timeline. Implementation-specific. NOTE: most feed flexibility has been moved to feed generator mechanism."
+					},
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 50
+					},
+					"cursor": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["feed"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"feed": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "app.bsky.feed.defs#feedViewPost"
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/feed/like.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.feed.like",
+	"defs": {
+		"main": {
+			"type": "record",
+			"description": "Record declaring a 'like' of a piece of subject content.",
+			"key": "tid",
+			"record": {
+				"type": "object",
+				"required": ["subject", "createdAt"],
+				"properties": {
+					"subject": { "type": "ref", "ref": "com.atproto.repo.strongRef" },
+					"createdAt": { "type": "string", "format": "datetime" }
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/feed/post.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.feed.post",
+	"defs": {
+		"main": {
+			"type": "record",
+			"description": "Record containing a Bluesky post.",
+			"key": "tid",
+			"record": {
+				"type": "object",
+				"required": ["text", "createdAt"],
+				"properties": {
+					"text": {
+						"type": "string",
+						"maxLength": 3000,
+						"maxGraphemes": 300,
+						"description": "The primary post content. May be an empty string, if there are embeds."
+					},
+					"entities": {
+						"type": "array",
+						"description": "DEPRECATED: replaced by app.bsky.richtext.facet.",
+						"items": { "type": "ref", "ref": "#entity" }
+					},
+					"facets": {
+						"type": "array",
+						"description": "Annotations of text (mentions, URLs, hashtags, etc)",
+						"items": { "type": "ref", "ref": "app.bsky.richtext.facet" }
+					},
+					"reply": { "type": "ref", "ref": "#replyRef" },
+					"embed": {
+						"type": "union",
+						"refs": [
+							"app.bsky.embed.images",
+							"app.bsky.embed.external",
+							"app.bsky.embed.record",
+							"app.bsky.embed.recordWithMedia"
+						]
+					},
+					"langs": {
+						"type": "array",
+						"description": "Indicates human language of post primary text content.",
+						"maxLength": 3,
+						"items": { "type": "string", "format": "language" }
+					},
+					"labels": {
+						"type": "union",
+						"description": "Self-label values for this post. Effectively content warnings.",
+						"refs": ["com.atproto.label.defs#selfLabels"]
+					},
+					"tags": {
+						"type": "array",
+						"description": "Additional hashtags, in addition to any included in post text and facets.",
+						"maxLength": 8,
+						"items": { "type": "string", "maxLength": 640, "maxGraphemes": 64 }
+					},
+					"createdAt": {
+						"type": "string",
+						"format": "datetime",
+						"description": "Client-declared timestamp when this post was originally created."
+					}
+				}
+			}
+		},
+		"replyRef": {
+			"type": "object",
+			"required": ["root", "parent"],
+			"properties": {
+				"root": { "type": "ref", "ref": "com.atproto.repo.strongRef" },
+				"parent": { "type": "ref", "ref": "com.atproto.repo.strongRef" }
+			}
+		},
+		"entity": {
+			"type": "object",
+			"description": "Deprecated: use facets instead.",
+			"required": ["index", "type", "value"],
+			"properties": {
+				"index": { "type": "ref", "ref": "#textSlice" },
+				"type": {
+					"type": "string",
+					"description": "Expected values are 'mention' and 'link'."
+				},
+				"value": { "type": "string" }
+			}
+		},
+		"textSlice": {
+			"type": "object",
+			"description": "Deprecated. Use app.bsky.richtext instead -- A text segment. Start is inclusive, end is exclusive. Indices are for utf16-encoded strings.",
+			"required": ["start", "end"],
+			"properties": {
+				"start": { "type": "integer", "minimum": 0 },
+				"end": { "type": "integer", "minimum": 0 }
+			}
+		}
+	}
+}

lexicons/app/bsky/feed/repost.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.feed.repost",
+	"defs": {
+		"main": {
+			"description": "Record representing a 'repost' of an existing Bluesky post.",
+			"type": "record",
+			"key": "tid",
+			"record": {
+				"type": "object",
+				"required": ["subject", "createdAt"],
+				"properties": {
+					"subject": { "type": "ref", "ref": "com.atproto.repo.strongRef" },
+					"createdAt": { "type": "string", "format": "datetime" }
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/feed/searchPosts.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.feed.searchPosts",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Find posts matching search criteria, returning views of those posts.",
+			"parameters": {
+				"type": "params",
+				"required": ["q"],
+				"properties": {
+					"q": {
+						"type": "string",
+						"description": "Search query string; syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended."
+					},
+					"sort": {
+						"type": "string",
+						"knownValues": ["top", "latest"],
+						"default": "latest",
+						"description": "Specifies the ranking order of results."
+					},
+					"since": {
+						"type": "string",
+						"description": "Filter results for posts after the indicated datetime (inclusive). Expected to use 'sortAt' timestamp, which may not match 'createdAt'. Can be a datetime, or just an ISO date (YYYY-MM-DD)."
+					},
+					"until": {
+						"type": "string",
+						"description": "Filter results for posts before the indicated datetime (not inclusive). Expected to use 'sortAt' timestamp, which may not match 'createdAt'. Can be a datetime, or just an ISO date (YYY-MM-DD)."
+					},
+					"mentions": {
+						"type": "string",
+						"format": "at-identifier",
+						"description": "Filter to posts which mention the given account. Handles are resolved to DID before query-time. Only matches rich-text facet mentions."
+					},
+					"author": {
+						"type": "string",
+						"format": "at-identifier",
+						"description": "Filter to posts by the given account. Handles are resolved to DID before query-time."
+					},
+					"lang": {
+						"type": "string",
+						"format": "language",
+						"description": "Filter to posts in the given language. Expected to be based on post language field, though server may override language detection."
+					},
+					"domain": {
+						"type": "string",
+						"description": "Filter to posts with URLs (facet links or embeds) linking to the given domain (hostname). Server may apply hostname normalization."
+					},
+					"url": {
+						"type": "string",
+						"format": "uri",
+						"description": "Filter to posts with links (facet links or embeds) pointing to this URL. Server may apply URL normalization or fuzzy matching."
+					},
+					"tag": {
+						"type": "array",
+						"items": {
+							"type": "string",
+							"maxLength": 640,
+							"maxGraphemes": 64
+						},
+						"description": "Filter to posts with the given tag (hashtag), based on rich-text facet or tag field. Do not include the hash (#) prefix. Multiple tags can be specified, with 'AND' matching."
+					},
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 25
+					},
+					"cursor": {
+						"type": "string",
+						"description": "Optional pagination mechanism; may not necessarily allow scrolling through entire result set."
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["posts"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"hitsTotal": {
+							"type": "integer",
+							"description": "Count of search hits. Optional, may be rounded/truncated, and may not be possible to paginate through all hits."
+						},
+						"posts": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "app.bsky.feed.defs#postView"
+							}
+						}
+					}
+				}
+			},
+			"errors": [{ "name": "BadQueryString" }]
+		}
+	}
+}

lexicons/app/bsky/feed/sendInteractions.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.feed.sendInteractions",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Send information about interactions with feed items back to the feed generator that served them.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["interactions"],
+					"properties": {
+						"interactions": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "app.bsky.feed.defs#interaction"
+							}
+						}
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"properties": {}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/feed/threadgate.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.feed.threadgate",
+	"defs": {
+		"main": {
+			"type": "record",
+			"key": "tid",
+			"description": "Record defining interaction gating rules for a thread (aka, reply controls). The record key (rkey) of the threadgate record must match the record key of the thread's root post, and that record must be in the same repository..",
+			"record": {
+				"type": "object",
+				"required": ["post", "createdAt"],
+				"properties": {
+					"post": {
+						"type": "string",
+						"format": "at-uri",
+						"description": "Reference (AT-URI) to the post record."
+					},
+					"allow": {
+						"type": "array",
+						"maxLength": 5,
+						"items": {
+							"type": "union",
+							"refs": ["#mentionRule", "#followingRule", "#listRule"]
+						}
+					},
+					"createdAt": { "type": "string", "format": "datetime" }
+				}
+			}
+		},
+		"mentionRule": {
+			"type": "object",
+			"description": "Allow replies from actors mentioned in your post.",
+			"properties": {}
+		},
+		"followingRule": {
+			"type": "object",
+			"description": "Allow replies from actors you follow.",
+			"properties": {}
+		},
+		"listRule": {
+			"type": "object",
+			"description": "Allow replies from actors on a list.",
+			"required": ["list"],
+			"properties": {
+				"list": { "type": "string", "format": "at-uri" }
+			}
+		}
+	}
+}

lexicons/app/bsky/graph/block.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.graph.block",
+	"defs": {
+		"main": {
+			"type": "record",
+			"description": "Record declaring a 'block' relationship against another account. NOTE: blocks are public in Bluesky; see blog posts for details.",
+			"key": "tid",
+			"record": {
+				"type": "object",
+				"required": ["subject", "createdAt"],
+				"properties": {
+					"subject": {
+						"type": "string",
+						"format": "did",
+						"description": "DID of the account to be blocked."
+					},
+					"createdAt": { "type": "string", "format": "datetime" }
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/graph/defs.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.graph.defs",
+	"defs": {
+		"listViewBasic": {
+			"type": "object",
+			"required": ["uri", "cid", "name", "purpose"],
+			"properties": {
+				"uri": { "type": "string", "format": "at-uri" },
+				"cid": { "type": "string", "format": "cid" },
+				"name": { "type": "string", "maxLength": 64, "minLength": 1 },
+				"purpose": { "type": "ref", "ref": "#listPurpose" },
+				"avatar": { "type": "string", "format": "uri" },
+				"listItemCount": { "type": "integer", "minimum": 0 },
+				"labels": {
+					"type": "array",
+					"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+				},
+				"viewer": { "type": "ref", "ref": "#listViewerState" },
+				"indexedAt": { "type": "string", "format": "datetime" }
+			}
+		},
+		"listView": {
+			"type": "object",
+			"required": ["uri", "cid", "creator", "name", "purpose", "indexedAt"],
+			"properties": {
+				"uri": { "type": "string", "format": "at-uri" },
+				"cid": { "type": "string", "format": "cid" },
+				"creator": { "type": "ref", "ref": "app.bsky.actor.defs#profileView" },
+				"name": { "type": "string", "maxLength": 64, "minLength": 1 },
+				"purpose": { "type": "ref", "ref": "#listPurpose" },
+				"description": {
+					"type": "string",
+					"maxGraphemes": 300,
+					"maxLength": 3000
+				},
+				"descriptionFacets": {
+					"type": "array",
+					"items": { "type": "ref", "ref": "app.bsky.richtext.facet" }
+				},
+				"avatar": { "type": "string", "format": "uri" },
+				"listItemCount": { "type": "integer", "minimum": 0 },
+				"labels": {
+					"type": "array",
+					"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+				},
+				"viewer": { "type": "ref", "ref": "#listViewerState" },
+				"indexedAt": { "type": "string", "format": "datetime" }
+			}
+		},
+		"listItemView": {
+			"type": "object",
+			"required": ["uri", "subject"],
+			"properties": {
+				"uri": { "type": "string", "format": "at-uri" },
+				"subject": { "type": "ref", "ref": "app.bsky.actor.defs#profileView" }
+			}
+		},
+		"starterPackView": {
+			"type": "object",
+			"required": ["uri", "cid", "record", "creator", "indexedAt"],
+			"properties": {
+				"uri": { "type": "string", "format": "at-uri" },
+				"cid": { "type": "string", "format": "cid" },
+				"record": { "type": "unknown" },
+				"creator": {
+					"type": "ref",
+					"ref": "app.bsky.actor.defs#profileViewBasic"
+				},
+				"list": { "type": "ref", "ref": "#listViewBasic" },
+				"listItemsSample": {
+					"type": "array",
+					"maxLength": 12,
+					"items": { "type": "ref", "ref": "#listItemView" }
+				},
+				"feeds": {
+					"type": "array",
+					"maxLength": 3,
+					"items": { "type": "ref", "ref": "app.bsky.feed.defs#generatorView" }
+				},
+				"joinedWeekCount": { "type": "integer", "minimum": 0 },
+				"joinedAllTimeCount": { "type": "integer", "minimum": 0 },
+				"labels": {
+					"type": "array",
+					"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+				},
+				"indexedAt": { "type": "string", "format": "datetime" }
+			}
+		},
+		"starterPackViewBasic": {
+			"type": "object",
+			"required": ["uri", "cid", "record", "creator", "indexedAt"],
+			"properties": {
+				"uri": { "type": "string", "format": "at-uri" },
+				"cid": { "type": "string", "format": "cid" },
+				"record": { "type": "unknown" },
+				"creator": {
+					"type": "ref",
+					"ref": "app.bsky.actor.defs#profileViewBasic"
+				},
+				"listItemCount": { "type": "integer", "minimum": 0 },
+				"joinedWeekCount": { "type": "integer", "minimum": 0 },
+				"joinedAllTimeCount": { "type": "integer", "minimum": 0 },
+				"labels": {
+					"type": "array",
+					"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+				},
+				"indexedAt": { "type": "string", "format": "datetime" }
+			}
+		},
+		"listPurpose": {
+			"type": "string",
+			"knownValues": [
+				"app.bsky.graph.defs#modlist",
+				"app.bsky.graph.defs#curatelist",
+				"app.bsky.graph.defs#referencelist"
+			]
+		},
+		"modlist": {
+			"type": "token",
+			"description": "A list of actors to apply an aggregate moderation action (mute/block) on."
+		},
+		"curatelist": {
+			"type": "token",
+			"description": "A list of actors used for curation purposes such as list feeds or interaction gating."
+		},
+		"referencelist": {
+			"type": "token",
+			"description": "A list of actors used for only for reference purposes such as within a starter pack."
+		},
+		"listViewerState": {
+			"type": "object",
+			"properties": {
+				"muted": { "type": "boolean" },
+				"blocked": { "type": "string", "format": "at-uri" }
+			}
+		},
+		"notFoundActor": {
+			"type": "object",
+			"description": "indicates that a handle or DID could not be resolved",
+			"required": ["actor", "notFound"],
+			"properties": {
+				"actor": { "type": "string", "format": "at-identifier" },
+				"notFound": { "type": "boolean", "const": true }
+			}
+		},
+		"relationship": {
+			"type": "object",
+			"description": "lists the bi-directional graph relationships between one actor (not indicated in the object), and the target actors (the DID included in the object)",
+			"required": ["did"],
+			"properties": {
+				"did": { "type": "string", "format": "did" },
+				"following": {
+					"type": "string",
+					"format": "at-uri",
+					"description": "if the actor follows this DID, this is the AT-URI of the follow record"
+				},
+				"followedBy": {
+					"type": "string",
+					"format": "at-uri",
+					"description": "if the actor is followed by this DID, contains the AT-URI of the follow record"
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/graph/follow.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.graph.follow",
+	"defs": {
+		"main": {
+			"type": "record",
+			"description": "Record declaring a social 'follow' relationship of another account. Duplicate follows will be ignored by the AppView.",
+			"key": "tid",
+			"record": {
+				"type": "object",
+				"required": ["subject", "createdAt"],
+				"properties": {
+					"subject": { "type": "string", "format": "did" },
+					"createdAt": { "type": "string", "format": "datetime" }
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/graph/getActorStarterPacks.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.graph.getActorStarterPacks",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get a list of starter packs created by the actor.",
+			"parameters": {
+				"type": "params",
+				"required": ["actor"],
+				"properties": {
+					"actor": { "type": "string", "format": "at-identifier" },
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 50
+					},
+					"cursor": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["starterPacks"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"starterPacks": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "app.bsky.graph.defs#starterPackViewBasic"
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/graph/getBlocks.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.graph.getBlocks",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Enumerates which accounts the requesting account is currently blocking. Requires auth.",
+			"parameters": {
+				"type": "params",
+				"properties": {
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 50
+					},
+					"cursor": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["blocks"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"blocks": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "app.bsky.actor.defs#profileView"
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/graph/getFollowers.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.graph.getFollowers",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Enumerates accounts which follow a specified account (actor).",
+			"parameters": {
+				"type": "params",
+				"required": ["actor"],
+				"properties": {
+					"actor": { "type": "string", "format": "at-identifier" },
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 50
+					},
+					"cursor": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["subject", "followers"],
+					"properties": {
+						"subject": {
+							"type": "ref",
+							"ref": "app.bsky.actor.defs#profileView"
+						},
+						"cursor": { "type": "string" },
+						"followers": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "app.bsky.actor.defs#profileView"
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/graph/getFollows.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.graph.getFollows",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Enumerates accounts which a specified account (actor) follows.",
+			"parameters": {
+				"type": "params",
+				"required": ["actor"],
+				"properties": {
+					"actor": { "type": "string", "format": "at-identifier" },
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 50
+					},
+					"cursor": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["subject", "follows"],
+					"properties": {
+						"subject": {
+							"type": "ref",
+							"ref": "app.bsky.actor.defs#profileView"
+						},
+						"cursor": { "type": "string" },
+						"follows": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "app.bsky.actor.defs#profileView"
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/graph/getKnownFollowers.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.graph.getKnownFollowers",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Enumerates accounts which follow a specified account (actor) and are followed by the viewer.",
+			"parameters": {
+				"type": "params",
+				"required": ["actor"],
+				"properties": {
+					"actor": { "type": "string", "format": "at-identifier" },
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 50
+					},
+					"cursor": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["subject", "followers"],
+					"properties": {
+						"subject": {
+							"type": "ref",
+							"ref": "app.bsky.actor.defs#profileView"
+						},
+						"cursor": { "type": "string" },
+						"followers": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "app.bsky.actor.defs#profileView"
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/graph/getList.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.graph.getList",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Gets a 'view' (with additional context) of a specified list.",
+			"parameters": {
+				"type": "params",
+				"required": ["list"],
+				"properties": {
+					"list": {
+						"type": "string",
+						"format": "at-uri",
+						"description": "Reference (AT-URI) of the list record to hydrate."
+					},
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 50
+					},
+					"cursor": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["list", "items"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"list": { "type": "ref", "ref": "app.bsky.graph.defs#listView" },
+						"items": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "app.bsky.graph.defs#listItemView"
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/graph/getListBlocks.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.graph.getListBlocks",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get mod lists that the requesting account (actor) is blocking. Requires auth.",
+			"parameters": {
+				"type": "params",
+				"properties": {
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 50
+					},
+					"cursor": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["lists"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"lists": {
+							"type": "array",
+							"items": { "type": "ref", "ref": "app.bsky.graph.defs#listView" }
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/graph/getListMutes.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.graph.getListMutes",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Enumerates mod lists that the requesting account (actor) currently has muted. Requires auth.",
+			"parameters": {
+				"type": "params",
+				"properties": {
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 50
+					},
+					"cursor": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["lists"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"lists": {
+							"type": "array",
+							"items": { "type": "ref", "ref": "app.bsky.graph.defs#listView" }
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/graph/getLists.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.graph.getLists",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Enumerates the lists created by a specified account (actor).",
+			"parameters": {
+				"type": "params",
+				"required": ["actor"],
+				"properties": {
+					"actor": {
+						"type": "string",
+						"format": "at-identifier",
+						"description": "The account (actor) to enumerate lists from."
+					},
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 50
+					},
+					"cursor": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["lists"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"lists": {
+							"type": "array",
+							"items": { "type": "ref", "ref": "app.bsky.graph.defs#listView" }
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/graph/getMutes.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.graph.getMutes",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Enumerates accounts that the requesting account (actor) currently has muted. Requires auth.",
+			"parameters": {
+				"type": "params",
+				"properties": {
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 50
+					},
+					"cursor": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["mutes"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"mutes": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "app.bsky.actor.defs#profileView"
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/graph/getRelationships.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.graph.getRelationships",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Enumerates public relationships between one account, and a list of other accounts. Does not require auth.",
+			"parameters": {
+				"type": "params",
+				"required": ["actor"],
+				"properties": {
+					"actor": {
+						"type": "string",
+						"format": "at-identifier",
+						"description": "Primary account requesting relationships for."
+					},
+					"others": {
+						"type": "array",
+						"description": "List of 'other' accounts to be related back to the primary.",
+						"maxLength": 30,
+						"items": {
+							"type": "string",
+							"format": "at-identifier"
+						}
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["relationships"],
+					"properties": {
+						"actor": { "type": "string", "format": "did" },
+						"relationships": {
+							"type": "array",
+							"items": {
+								"type": "union",
+								"refs": ["app.bsky.graph.defs#relationship", "app.bsky.graph.defs#notFoundActor"]
+							}
+						}
+					}
+				}
+			},
+			"errors": [
+				{
+					"name": "ActorNotFound",
+					"description": "the primary actor at-identifier could not be resolved"
+				}
+			]
+		}
+	}
+}

lexicons/app/bsky/graph/getStarterPack.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.graph.getStarterPack",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Gets a view of a starter pack.",
+			"parameters": {
+				"type": "params",
+				"required": ["starterPack"],
+				"properties": {
+					"starterPack": {
+						"type": "string",
+						"format": "at-uri",
+						"description": "Reference (AT-URI) of the starter pack record."
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["starterPack"],
+					"properties": {
+						"starterPack": {
+							"type": "ref",
+							"ref": "app.bsky.graph.defs#starterPackView"
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/graph/getStarterPacks.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.graph.getStarterPacks",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get views for a list of starter packs.",
+			"parameters": {
+				"type": "params",
+				"required": ["uris"],
+				"properties": {
+					"uris": {
+						"type": "array",
+						"items": { "type": "string", "format": "at-uri" },
+						"maxLength": 25
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["starterPacks"],
+					"properties": {
+						"starterPacks": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "app.bsky.graph.defs#starterPackViewBasic"
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/graph/getSuggestedFollowsByActor.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.graph.getSuggestedFollowsByActor",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Enumerates follows similar to a given account (actor). Expected use is to recommend additional accounts immediately after following one account.",
+			"parameters": {
+				"type": "params",
+				"required": ["actor"],
+				"properties": {
+					"actor": { "type": "string", "format": "at-identifier" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["suggestions"],
+					"properties": {
+						"suggestions": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "app.bsky.actor.defs#profileView"
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/graph/list.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.graph.list",
+	"defs": {
+		"main": {
+			"type": "record",
+			"description": "Record representing a list of accounts (actors). Scope includes both moderation-oriented lists and curration-oriented lists.",
+			"key": "tid",
+			"record": {
+				"type": "object",
+				"required": ["name", "purpose", "createdAt"],
+				"properties": {
+					"purpose": {
+						"type": "ref",
+						"description": "Defines the purpose of the list (aka, moderation-oriented or curration-oriented)",
+						"ref": "app.bsky.graph.defs#listPurpose"
+					},
+					"name": {
+						"type": "string",
+						"maxLength": 64,
+						"minLength": 1,
+						"description": "Display name for list; can not be empty."
+					},
+					"description": {
+						"type": "string",
+						"maxGraphemes": 300,
+						"maxLength": 3000
+					},
+					"descriptionFacets": {
+						"type": "array",
+						"items": { "type": "ref", "ref": "app.bsky.richtext.facet" }
+					},
+					"avatar": {
+						"type": "blob",
+						"accept": ["image/png", "image/jpeg"],
+						"maxSize": 1000000
+					},
+					"labels": {
+						"type": "union",
+						"refs": ["com.atproto.label.defs#selfLabels"]
+					},
+					"createdAt": { "type": "string", "format": "datetime" }
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/graph/listblock.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.graph.listblock",
+	"defs": {
+		"main": {
+			"type": "record",
+			"description": "Record representing a block relationship against an entire an entire list of accounts (actors).",
+			"key": "tid",
+			"record": {
+				"type": "object",
+				"required": ["subject", "createdAt"],
+				"properties": {
+					"subject": {
+						"type": "string",
+						"format": "at-uri",
+						"description": "Reference (AT-URI) to the mod list record."
+					},
+					"createdAt": { "type": "string", "format": "datetime" }
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/graph/listitem.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.graph.listitem",
+	"defs": {
+		"main": {
+			"type": "record",
+			"description": "Record representing an account's inclusion on a specific list. The AppView will ignore duplicate listitem records.",
+			"key": "tid",
+			"record": {
+				"type": "object",
+				"required": ["subject", "list", "createdAt"],
+				"properties": {
+					"subject": {
+						"type": "string",
+						"format": "did",
+						"description": "The account which is included on the list."
+					},
+					"list": {
+						"type": "string",
+						"format": "at-uri",
+						"description": "Reference (AT-URI) to the list record (app.bsky.graph.list)."
+					},
+					"createdAt": { "type": "string", "format": "datetime" }
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/graph/muteActor.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.graph.muteActor",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Creates a mute relationship for the specified account. Mutes are private in Bluesky. Requires auth.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["actor"],
+					"properties": {
+						"actor": { "type": "string", "format": "at-identifier" }
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/graph/muteActorList.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.graph.muteActorList",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Creates a mute relationship for the specified list of accounts. Mutes are private in Bluesky. Requires auth.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["list"],
+					"properties": {
+						"list": { "type": "string", "format": "at-uri" }
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/graph/muteThread.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.graph.muteThread",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Mutes a thread preventing notifications from the thread and any of its children. Mutes are private in Bluesky. Requires auth.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["root"],
+					"properties": {
+						"root": { "type": "string", "format": "at-uri" }
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/graph/starterpack.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.graph.starterpack",
+	"defs": {
+		"main": {
+			"type": "record",
+			"description": "Record defining a starter pack of actors and feeds for new users.",
+			"key": "tid",
+			"record": {
+				"type": "object",
+				"required": ["name", "list", "createdAt"],
+				"properties": {
+					"name": {
+						"type": "string",
+						"maxGraphemes": 50,
+						"maxLength": 500,
+						"minLength": 1,
+						"description": "Display name for starter pack; can not be empty."
+					},
+					"description": {
+						"type": "string",
+						"maxGraphemes": 300,
+						"maxLength": 3000
+					},
+					"descriptionFacets": {
+						"type": "array",
+						"items": { "type": "ref", "ref": "app.bsky.richtext.facet" }
+					},
+					"list": {
+						"type": "string",
+						"format": "at-uri",
+						"description": "Reference (AT-URI) to the list record."
+					},
+					"feeds": {
+						"type": "array",
+						"maxLength": 3,
+						"items": { "type": "ref", "ref": "#feedItem" }
+					},
+					"createdAt": { "type": "string", "format": "datetime" }
+				}
+			}
+		},
+		"feedItem": {
+			"type": "object",
+			"required": ["uri"],
+			"properties": {
+				"uri": { "type": "string", "format": "at-uri" }
+			}
+		}
+	}
+}

lexicons/app/bsky/graph/unmuteActor.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.graph.unmuteActor",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Unmutes the specified account. Requires auth.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["actor"],
+					"properties": {
+						"actor": { "type": "string", "format": "at-identifier" }
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/graph/unmuteActorList.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.graph.unmuteActorList",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Unmutes the specified list of accounts. Requires auth.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["list"],
+					"properties": {
+						"list": { "type": "string", "format": "at-uri" }
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/graph/unmuteThread.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.graph.unmuteThread",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Unmutes the specified thread. Requires auth.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["root"],
+					"properties": {
+						"root": { "type": "string", "format": "at-uri" }
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/labeler/defs.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.labeler.defs",
+	"defs": {
+		"labelerView": {
+			"type": "object",
+			"required": ["uri", "cid", "creator", "indexedAt"],
+			"properties": {
+				"uri": { "type": "string", "format": "at-uri" },
+				"cid": { "type": "string", "format": "cid" },
+				"creator": { "type": "ref", "ref": "app.bsky.actor.defs#profileView" },
+				"likeCount": { "type": "integer", "minimum": 0 },
+				"viewer": { "type": "ref", "ref": "#labelerViewerState" },
+				"indexedAt": { "type": "string", "format": "datetime" },
+				"labels": {
+					"type": "array",
+					"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+				}
+			}
+		},
+		"labelerViewDetailed": {
+			"type": "object",
+			"required": ["uri", "cid", "creator", "policies", "indexedAt"],
+			"properties": {
+				"uri": { "type": "string", "format": "at-uri" },
+				"cid": { "type": "string", "format": "cid" },
+				"creator": { "type": "ref", "ref": "app.bsky.actor.defs#profileView" },
+				"policies": {
+					"type": "ref",
+					"ref": "app.bsky.labeler.defs#labelerPolicies"
+				},
+				"likeCount": { "type": "integer", "minimum": 0 },
+				"viewer": { "type": "ref", "ref": "#labelerViewerState" },
+				"indexedAt": { "type": "string", "format": "datetime" },
+				"labels": {
+					"type": "array",
+					"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+				}
+			}
+		},
+		"labelerViewerState": {
+			"type": "object",
+			"properties": {
+				"like": { "type": "string", "format": "at-uri" }
+			}
+		},
+		"labelerPolicies": {
+			"type": "object",
+			"required": ["labelValues"],
+			"properties": {
+				"labelValues": {
+					"type": "array",
+					"description": "The label values which this labeler publishes. May include global or custom labels.",
+					"items": {
+						"type": "ref",
+						"ref": "com.atproto.label.defs#labelValue"
+					}
+				},
+				"labelValueDefinitions": {
+					"type": "array",
+					"description": "Label values created by this labeler and scoped exclusively to it. Labels defined here will override global label definitions for this labeler.",
+					"items": {
+						"type": "ref",
+						"ref": "com.atproto.label.defs#labelValueDefinition"
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/labeler/getServices.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.labeler.getServices",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get information about a list of labeler services.",
+			"parameters": {
+				"type": "params",
+				"required": ["dids"],
+				"properties": {
+					"dids": {
+						"type": "array",
+						"items": { "type": "string", "format": "did" }
+					},
+					"detailed": {
+						"type": "boolean",
+						"default": false
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["views"],
+					"properties": {
+						"views": {
+							"type": "array",
+							"items": {
+								"type": "union",
+								"refs": ["app.bsky.labeler.defs#labelerView", "app.bsky.labeler.defs#labelerViewDetailed"]
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/labeler/service.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.labeler.service",
+	"defs": {
+		"main": {
+			"type": "record",
+			"description": "A declaration of the existence of labeler service.",
+			"key": "literal:self",
+			"record": {
+				"type": "object",
+				"required": ["policies", "createdAt"],
+				"properties": {
+					"policies": {
+						"type": "ref",
+						"ref": "app.bsky.labeler.defs#labelerPolicies"
+					},
+					"labels": {
+						"type": "union",
+						"refs": ["com.atproto.label.defs#selfLabels"]
+					},
+					"createdAt": { "type": "string", "format": "datetime" }
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/notification/getUnreadCount.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.notification.getUnreadCount",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Count the number of unread notifications for the requesting account. Requires auth.",
+			"parameters": {
+				"type": "params",
+				"properties": {
+					"priority": { "type": "boolean" },
+					"seenAt": { "type": "string", "format": "datetime" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["count"],
+					"properties": {
+						"count": { "type": "integer" }
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/notification/listNotifications.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.notification.listNotifications",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Enumerate notifications for the requesting account. Requires auth.",
+			"parameters": {
+				"type": "params",
+				"properties": {
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 50
+					},
+					"priority": { "type": "boolean" },
+					"cursor": { "type": "string" },
+					"seenAt": { "type": "string", "format": "datetime" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["notifications"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"notifications": {
+							"type": "array",
+							"items": { "type": "ref", "ref": "#notification" }
+						},
+						"priority": { "type": "boolean" },
+						"seenAt": { "type": "string", "format": "datetime" }
+					}
+				}
+			}
+		},
+		"notification": {
+			"type": "object",
+			"required": ["uri", "cid", "author", "reason", "record", "isRead", "indexedAt"],
+			"properties": {
+				"uri": { "type": "string", "format": "at-uri" },
+				"cid": { "type": "string", "format": "cid" },
+				"author": { "type": "ref", "ref": "app.bsky.actor.defs#profileView" },
+				"reason": {
+					"type": "string",
+					"description": "Expected values are 'like', 'repost', 'follow', 'mention', 'reply', 'quote', and 'starterpack-joined'.",
+					"knownValues": ["like", "repost", "follow", "mention", "reply", "quote", "starterpack-joined"]
+				},
+				"reasonSubject": { "type": "string", "format": "at-uri" },
+				"record": { "type": "unknown" },
+				"isRead": { "type": "boolean" },
+				"indexedAt": { "type": "string", "format": "datetime" },
+				"labels": {
+					"type": "array",
+					"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/notification/putPreferences.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.notification.putPreferences",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Set notification-related preferences for an account. Requires auth.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["priority"],
+					"properties": {
+						"priority": { "type": "boolean" }
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/notification/registerPush.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.notification.registerPush",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Register to receive push notifications, via a specified service, for the requesting account. Requires auth.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["serviceDid", "token", "platform", "appId"],
+					"properties": {
+						"serviceDid": { "type": "string", "format": "did" },
+						"token": { "type": "string" },
+						"platform": {
+							"type": "string",
+							"knownValues": ["ios", "android", "web"]
+						},
+						"appId": { "type": "string" }
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/notification/updateSeen.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.notification.updateSeen",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Notify server that the requesting account has seen notifications. Requires auth.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["seenAt"],
+					"properties": {
+						"seenAt": { "type": "string", "format": "datetime" }
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/richtext/facet.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.richtext.facet",
+	"defs": {
+		"main": {
+			"type": "object",
+			"description": "Annotation of a sub-string within rich text.",
+			"required": ["index", "features"],
+			"properties": {
+				"index": { "type": "ref", "ref": "#byteSlice" },
+				"features": {
+					"type": "array",
+					"items": { "type": "union", "refs": ["#mention", "#link", "#tag"] }
+				}
+			}
+		},
+		"mention": {
+			"type": "object",
+			"description": "Facet feature for mention of another account. The text is usually a handle, including a '@' prefix, but the facet reference is a DID.",
+			"required": ["did"],
+			"properties": {
+				"did": { "type": "string", "format": "did" }
+			}
+		},
+		"link": {
+			"type": "object",
+			"description": "Facet feature for a URL. The text URL may have been simplified or truncated, but the facet reference should be a complete URL.",
+			"required": ["uri"],
+			"properties": {
+				"uri": { "type": "string", "format": "uri" }
+			}
+		},
+		"tag": {
+			"type": "object",
+			"description": "Facet feature for a hashtag. The text usually includes a '#' prefix, but the facet reference should not (except in the case of 'double hash tags').",
+			"required": ["tag"],
+			"properties": {
+				"tag": { "type": "string", "maxLength": 640, "maxGraphemes": 64 }
+			}
+		},
+		"byteSlice": {
+			"type": "object",
+			"description": "Specifies the sub-string range a facet feature applies to. Start index is inclusive, end index is exclusive. Indices are zero-indexed, counting bytes of the UTF-8 encoded text. NOTE: some languages, like Javascript, use UTF-16 or Unicode codepoints for string slice indexing; in these languages, convert to byte arrays before working with facets.",
+			"required": ["byteStart", "byteEnd"],
+			"properties": {
+				"byteStart": { "type": "integer", "minimum": 0 },
+				"byteEnd": { "type": "integer", "minimum": 0 }
+			}
+		}
+	}
+}

lexicons/app/bsky/unspecced/defs.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.unspecced.defs",
+	"defs": {
+		"skeletonSearchPost": {
+			"type": "object",
+			"required": ["uri"],
+			"properties": {
+				"uri": { "type": "string", "format": "at-uri" }
+			}
+		},
+		"skeletonSearchActor": {
+			"type": "object",
+			"required": ["did"],
+			"properties": {
+				"did": { "type": "string", "format": "did" }
+			}
+		}
+	}
+}

lexicons/app/bsky/unspecced/getPopularFeedGenerators.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.unspecced.getPopularFeedGenerators",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "An unspecced view of globally popular feed generators.",
+			"parameters": {
+				"type": "params",
+				"properties": {
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 50
+					},
+					"cursor": { "type": "string" },
+					"query": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["feeds"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"feeds": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "app.bsky.feed.defs#generatorView"
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/unspecced/getSuggestionsSkeleton.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.unspecced.getSuggestionsSkeleton",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get a skeleton of suggested actors. Intended to be called and then hydrated through app.bsky.actor.getSuggestions",
+			"parameters": {
+				"type": "params",
+				"properties": {
+					"viewer": {
+						"type": "string",
+						"format": "did",
+						"description": "DID of the account making the request (not included for public/unauthenticated queries). Used to boost followed accounts in ranking."
+					},
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 50
+					},
+					"cursor": { "type": "string" },
+					"relativeToDid": {
+						"type": "string",
+						"format": "did",
+						"description": "DID of the account to get suggestions relative to. If not provided, suggestions will be based on the viewer."
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["actors"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"actors": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "app.bsky.unspecced.defs#skeletonSearchActor"
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/app/bsky/unspecced/getTaggedSuggestions.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.unspecced.getTaggedSuggestions",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get a list of suggestions (feeds and users) tagged with categories",
+			"parameters": {
+				"type": "params",
+				"properties": {}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["suggestions"],
+					"properties": {
+						"suggestions": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "#suggestion"
+							}
+						}
+					}
+				}
+			}
+		},
+		"suggestion": {
+			"type": "object",
+			"required": ["tag", "subjectType", "subject"],
+			"properties": {
+				"tag": { "type": "string" },
+				"subjectType": {
+					"type": "string",
+					"knownValues": ["actor", "feed"]
+				},
+				"subject": { "type": "string", "format": "uri" }
+			}
+		}
+	}
+}

lexicons/app/bsky/unspecced/searchActorsSkeleton.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.unspecced.searchActorsSkeleton",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Backend Actors (profile) search, returns only skeleton.",
+			"parameters": {
+				"type": "params",
+				"required": ["q"],
+				"properties": {
+					"q": {
+						"type": "string",
+						"description": "Search query string; syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended. For typeahead search, only simple term match is supported, not full syntax."
+					},
+					"viewer": {
+						"type": "string",
+						"format": "did",
+						"description": "DID of the account making the request (not included for public/unauthenticated queries). Used to boost followed accounts in ranking."
+					},
+					"typeahead": {
+						"type": "boolean",
+						"description": "If true, acts as fast/simple 'typeahead' query."
+					},
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 25
+					},
+					"cursor": {
+						"type": "string",
+						"description": "Optional pagination mechanism; may not necessarily allow scrolling through entire result set."
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["actors"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"hitsTotal": {
+							"type": "integer",
+							"description": "Count of search hits. Optional, may be rounded/truncated, and may not be possible to paginate through all hits."
+						},
+						"actors": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "app.bsky.unspecced.defs#skeletonSearchActor"
+							}
+						}
+					}
+				}
+			},
+			"errors": [{ "name": "BadQueryString" }]
+		}
+	}
+}

lexicons/app/bsky/unspecced/searchPostsSkeleton.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.unspecced.searchPostsSkeleton",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Backend Posts search, returns only skeleton",
+			"parameters": {
+				"type": "params",
+				"required": ["q"],
+				"properties": {
+					"q": {
+						"type": "string",
+						"description": "Search query string; syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended."
+					},
+					"sort": {
+						"type": "string",
+						"knownValues": ["top", "latest"],
+						"default": "latest",
+						"description": "Specifies the ranking order of results."
+					},
+					"since": {
+						"type": "string",
+						"description": "Filter results for posts after the indicated datetime (inclusive). Expected to use 'sortAt' timestamp, which may not match 'createdAt'. Can be a datetime, or just an ISO date (YYYY-MM-DD)."
+					},
+					"until": {
+						"type": "string",
+						"description": "Filter results for posts before the indicated datetime (not inclusive). Expected to use 'sortAt' timestamp, which may not match 'createdAt'. Can be a datetime, or just an ISO date (YYY-MM-DD)."
+					},
+					"mentions": {
+						"type": "string",
+						"format": "at-identifier",
+						"description": "Filter to posts which mention the given account. Handles are resolved to DID before query-time. Only matches rich-text facet mentions."
+					},
+					"author": {
+						"type": "string",
+						"format": "at-identifier",
+						"description": "Filter to posts by the given account. Handles are resolved to DID before query-time."
+					},
+					"lang": {
+						"type": "string",
+						"format": "language",
+						"description": "Filter to posts in the given language. Expected to be based on post language field, though server may override language detection."
+					},
+					"domain": {
+						"type": "string",
+						"description": "Filter to posts with URLs (facet links or embeds) linking to the given domain (hostname). Server may apply hostname normalization."
+					},
+					"url": {
+						"type": "string",
+						"format": "uri",
+						"description": "Filter to posts with links (facet links or embeds) pointing to this URL. Server may apply URL normalization or fuzzy matching."
+					},
+					"tag": {
+						"type": "array",
+						"items": {
+							"type": "string",
+							"maxLength": 640,
+							"maxGraphemes": 64
+						},
+						"description": "Filter to posts with the given tag (hashtag), based on rich-text facet or tag field. Do not include the hash (#) prefix. Multiple tags can be specified, with 'AND' matching."
+					},
+					"viewer": {
+						"type": "string",
+						"format": "did",
+						"description": "DID of the account making the request (not included for public/unauthenticated queries). Used for 'from:me' queries."
+					},
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 25
+					},
+					"cursor": {
+						"type": "string",
+						"description": "Optional pagination mechanism; may not necessarily allow scrolling through entire result set."
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["posts"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"hitsTotal": {
+							"type": "integer",
+							"description": "Count of search hits. Optional, may be rounded/truncated, and may not be possible to paginate through all hits."
+						},
+						"posts": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "app.bsky.unspecced.defs#skeletonSearchPost"
+							}
+						}
+					}
+				}
+			},
+			"errors": [{ "name": "BadQueryString" }]
+		}
+	}
+}

lexicons/chat/bsky/actor/declaration.json

···
+{
+	"lexicon": 1,
+	"id": "chat.bsky.actor.declaration",
+	"defs": {
+		"main": {
+			"type": "record",
+			"description": "A declaration of a Bluesky chat account.",
+			"key": "literal:self",
+			"record": {
+				"type": "object",
+				"required": ["allowIncoming"],
+				"properties": {
+					"allowIncoming": {
+						"type": "string",
+						"knownValues": ["all", "none", "following"]
+					}
+				}
+			}
+		}
+	}
+}

lexicons/chat/bsky/actor/defs.json

···
+{
+	"lexicon": 1,
+	"id": "chat.bsky.actor.defs",
+	"defs": {
+		"profileViewBasic": {
+			"type": "object",
+			"required": ["did", "handle"],
+			"properties": {
+				"did": { "type": "string", "format": "did" },
+				"handle": { "type": "string", "format": "handle" },
+				"displayName": {
+					"type": "string",
+					"maxGraphemes": 64,
+					"maxLength": 640
+				},
+				"avatar": { "type": "string", "format": "uri" },
+				"associated": {
+					"type": "ref",
+					"ref": "app.bsky.actor.defs#profileAssociated"
+				},
+				"viewer": { "type": "ref", "ref": "app.bsky.actor.defs#viewerState" },
+				"labels": {
+					"type": "array",
+					"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+				},
+				"chatDisabled": {
+					"type": "boolean",
+					"description": "Set to true when the actor cannot actively participate in converations"
+				}
+			}
+		}
+	}
+}

lexicons/chat/bsky/actor/deleteAccount.json

···
+{
+	"lexicon": 1,
+	"id": "chat.bsky.actor.deleteAccount",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"properties": {}
+				}
+			}
+		}
+	}
+}

lexicons/chat/bsky/actor/exportAccountData.json

···
+{
+	"lexicon": 1,
+	"id": "chat.bsky.actor.exportAccountData",
+	"defs": {
+		"main": {
+			"type": "query",
+			"output": {
+				"encoding": "application/jsonl"
+			}
+		}
+	}
+}

lexicons/chat/bsky/convo/defs.json

···
+{
+	"lexicon": 1,
+	"id": "chat.bsky.convo.defs",
+	"defs": {
+		"messageRef": {
+			"type": "object",
+			"required": ["did", "messageId", "convoId"],
+			"properties": {
+				"did": { "type": "string", "format": "did" },
+				"convoId": { "type": "string" },
+				"messageId": { "type": "string" }
+			}
+		},
+		"messageInput": {
+			"type": "object",
+			"required": ["text"],
+			"properties": {
+				"text": {
+					"type": "string",
+					"maxLength": 10000,
+					"maxGraphemes": 1000
+				},
+				"facets": {
+					"type": "array",
+					"description": "Annotations of text (mentions, URLs, hashtags, etc)",
+					"items": { "type": "ref", "ref": "app.bsky.richtext.facet" }
+				},
+				"embed": {
+					"type": "union",
+					"refs": ["app.bsky.embed.record"]
+				}
+			}
+		},
+		"messageView": {
+			"type": "object",
+			"required": ["id", "rev", "text", "sender", "sentAt"],
+			"properties": {
+				"id": { "type": "string" },
+				"rev": { "type": "string" },
+				"text": {
+					"type": "string",
+					"maxLength": 10000,
+					"maxGraphemes": 1000
+				},
+				"facets": {
+					"type": "array",
+					"description": "Annotations of text (mentions, URLs, hashtags, etc)",
+					"items": { "type": "ref", "ref": "app.bsky.richtext.facet" }
+				},
+				"embed": {
+					"type": "union",
+					"refs": ["app.bsky.embed.record#view"]
+				},
+				"sender": { "type": "ref", "ref": "#messageViewSender" },
+				"sentAt": { "type": "string", "format": "datetime" }
+			}
+		},
+		"deletedMessageView": {
+			"type": "object",
+			"required": ["id", "rev", "sender", "sentAt"],
+			"properties": {
+				"id": { "type": "string" },
+				"rev": { "type": "string" },
+				"sender": { "type": "ref", "ref": "#messageViewSender" },
+				"sentAt": { "type": "string", "format": "datetime" }
+			}
+		},
+		"messageViewSender": {
+			"type": "object",
+			"required": ["did"],
+			"properties": {
+				"did": { "type": "string", "format": "did" }
+			}
+		},
+		"convoView": {
+			"type": "object",
+			"required": ["id", "rev", "members", "muted", "unreadCount"],
+			"properties": {
+				"id": { "type": "string" },
+				"rev": { "type": "string" },
+				"members": {
+					"type": "array",
+					"items": {
+						"type": "ref",
+						"ref": "chat.bsky.actor.defs#profileViewBasic"
+					}
+				},
+				"lastMessage": {
+					"type": "union",
+					"refs": ["#messageView", "#deletedMessageView"]
+				},
+				"muted": { "type": "boolean" },
+				"unreadCount": { "type": "integer" }
+			}
+		},
+		"logBeginConvo": {
+			"type": "object",
+			"required": ["rev", "convoId"],
+			"properties": {
+				"rev": { "type": "string" },
+				"convoId": { "type": "string" }
+			}
+		},
+		"logLeaveConvo": {
+			"type": "object",
+			"required": ["rev", "convoId"],
+			"properties": {
+				"rev": { "type": "string" },
+				"convoId": { "type": "string" }
+			}
+		},
+		"logCreateMessage": {
+			"type": "object",
+			"required": ["rev", "convoId", "message"],
+			"properties": {
+				"rev": { "type": "string" },
+				"convoId": { "type": "string" },
+				"message": {
+					"type": "union",
+					"refs": ["#messageView", "#deletedMessageView"]
+				}
+			}
+		},
+		"logDeleteMessage": {
+			"type": "object",
+			"required": ["rev", "convoId", "message"],
+			"properties": {
+				"rev": { "type": "string" },
+				"convoId": { "type": "string" },
+				"message": {
+					"type": "union",
+					"refs": ["#messageView", "#deletedMessageView"]
+				}
+			}
+		}
+	}
+}

lexicons/chat/bsky/convo/deleteMessageForSelf.json

···
+{
+	"lexicon": 1,
+	"id": "chat.bsky.convo.deleteMessageForSelf",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["convoId", "messageId"],
+					"properties": {
+						"convoId": { "type": "string" },
+						"messageId": { "type": "string" }
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "ref",
+					"ref": "chat.bsky.convo.defs#deletedMessageView"
+				}
+			}
+		}
+	}
+}

lexicons/chat/bsky/convo/getConvo.json

···
+{
+	"lexicon": 1,
+	"id": "chat.bsky.convo.getConvo",
+	"defs": {
+		"main": {
+			"type": "query",
+			"parameters": {
+				"type": "params",
+				"required": ["convoId"],
+				"properties": {
+					"convoId": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["convo"],
+					"properties": {
+						"convo": {
+							"type": "ref",
+							"ref": "chat.bsky.convo.defs#convoView"
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/chat/bsky/convo/getConvoForMembers.json

···
+{
+	"lexicon": 1,
+	"id": "chat.bsky.convo.getConvoForMembers",
+	"defs": {
+		"main": {
+			"type": "query",
+			"parameters": {
+				"type": "params",
+				"required": ["members"],
+				"properties": {
+					"members": {
+						"type": "array",
+						"minLength": 1,
+						"maxLength": 10,
+						"items": {
+							"type": "string",
+							"format": "did"
+						}
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["convo"],
+					"properties": {
+						"convo": {
+							"type": "ref",
+							"ref": "chat.bsky.convo.defs#convoView"
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/chat/bsky/convo/getLog.json

···
+{
+	"lexicon": 1,
+	"id": "chat.bsky.convo.getLog",
+	"defs": {
+		"main": {
+			"type": "query",
+			"parameters": {
+				"type": "params",
+				"required": [],
+				"properties": {
+					"cursor": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["logs"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"logs": {
+							"type": "array",
+							"items": {
+								"type": "union",
+								"refs": [
+									"chat.bsky.convo.defs#logBeginConvo",
+									"chat.bsky.convo.defs#logLeaveConvo",
+									"chat.bsky.convo.defs#logCreateMessage",
+									"chat.bsky.convo.defs#logDeleteMessage"
+								]
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/chat/bsky/convo/getMessages.json

···
+{
+	"lexicon": 1,
+	"id": "chat.bsky.convo.getMessages",
+	"defs": {
+		"main": {
+			"type": "query",
+			"parameters": {
+				"type": "params",
+				"required": ["convoId"],
+				"properties": {
+					"convoId": { "type": "string" },
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 50
+					},
+					"cursor": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["messages"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"messages": {
+							"type": "array",
+							"items": {
+								"type": "union",
+								"refs": ["chat.bsky.convo.defs#messageView", "chat.bsky.convo.defs#deletedMessageView"]
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/chat/bsky/convo/leaveConvo.json

···
+{
+	"lexicon": 1,
+	"id": "chat.bsky.convo.leaveConvo",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["convoId"],
+					"properties": {
+						"convoId": { "type": "string" }
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["convoId", "rev"],
+					"properties": {
+						"convoId": { "type": "string" },
+						"rev": { "type": "string" }
+					}
+				}
+			}
+		}
+	}
+}

lexicons/chat/bsky/convo/listConvos.json

···
+{
+	"lexicon": 1,
+	"id": "chat.bsky.convo.listConvos",
+	"defs": {
+		"main": {
+			"type": "query",
+			"parameters": {
+				"type": "params",
+				"properties": {
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 50
+					},
+					"cursor": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["convos"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"convos": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "chat.bsky.convo.defs#convoView"
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/chat/bsky/convo/muteConvo.json

···
+{
+	"lexicon": 1,
+	"id": "chat.bsky.convo.muteConvo",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["convoId"],
+					"properties": {
+						"convoId": { "type": "string" }
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["convo"],
+					"properties": {
+						"convo": {
+							"type": "ref",
+							"ref": "chat.bsky.convo.defs#convoView"
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/chat/bsky/convo/sendMessage.json

···
+{
+	"lexicon": 1,
+	"id": "chat.bsky.convo.sendMessage",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["convoId", "message"],
+					"properties": {
+						"convoId": { "type": "string" },
+						"message": {
+							"type": "ref",
+							"ref": "chat.bsky.convo.defs#messageInput"
+						}
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "ref",
+					"ref": "chat.bsky.convo.defs#messageView"
+				}
+			}
+		}
+	}
+}

lexicons/chat/bsky/convo/sendMessageBatch.json

···
+{
+	"lexicon": 1,
+	"id": "chat.bsky.convo.sendMessageBatch",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["items"],
+					"properties": {
+						"items": {
+							"type": "array",
+							"maxLength": 100,
+							"items": {
+								"type": "ref",
+								"ref": "#batchItem"
+							}
+						}
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["items"],
+					"properties": {
+						"items": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "chat.bsky.convo.defs#messageView"
+							}
+						}
+					}
+				}
+			}
+		},
+		"batchItem": {
+			"type": "object",
+			"required": ["convoId", "message"],
+			"properties": {
+				"convoId": { "type": "string" },
+				"message": {
+					"type": "ref",
+					"ref": "chat.bsky.convo.defs#messageInput"
+				}
+			}
+		}
+	}
+}

lexicons/chat/bsky/convo/unmuteConvo.json

···
+{
+	"lexicon": 1,
+	"id": "chat.bsky.convo.unmuteConvo",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["convoId"],
+					"properties": {
+						"convoId": { "type": "string" }
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["convo"],
+					"properties": {
+						"convo": {
+							"type": "ref",
+							"ref": "chat.bsky.convo.defs#convoView"
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/chat/bsky/convo/updateRead.json

···
+{
+	"lexicon": 1,
+	"id": "chat.bsky.convo.updateRead",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["convoId"],
+					"properties": {
+						"convoId": { "type": "string" },
+						"messageId": { "type": "string" }
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["convo"],
+					"properties": {
+						"convo": {
+							"type": "ref",
+							"ref": "chat.bsky.convo.defs#convoView"
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/chat/bsky/moderation/getActorMetadata.json

···
+{
+	"lexicon": 1,
+	"id": "chat.bsky.moderation.getActorMetadata",
+	"defs": {
+		"main": {
+			"type": "query",
+			"parameters": {
+				"type": "params",
+				"required": ["actor"],
+				"properties": {
+					"actor": { "type": "string", "format": "did" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["day", "month", "all"],
+					"properties": {
+						"day": { "type": "ref", "ref": "#metadata" },
+						"month": { "type": "ref", "ref": "#metadata" },
+						"all": { "type": "ref", "ref": "#metadata" }
+					}
+				}
+			}
+		},
+		"metadata": {
+			"type": "object",
+			"required": ["messagesSent", "messagesReceived", "convos", "convosStarted"],
+			"properties": {
+				"messagesSent": { "type": "integer" },
+				"messagesReceived": { "type": "integer" },
+				"convos": { "type": "integer" },
+				"convosStarted": { "type": "integer" }
+			}
+		}
+	}
+}

lexicons/chat/bsky/moderation/getMessageContext.json

···
+{
+	"lexicon": 1,
+	"id": "chat.bsky.moderation.getMessageContext",
+	"defs": {
+		"main": {
+			"type": "query",
+			"parameters": {
+				"type": "params",
+				"required": ["messageId"],
+				"properties": {
+					"convoId": {
+						"type": "string",
+						"description": "Conversation that the message is from. NOTE: this field will eventually be required."
+					},
+					"messageId": { "type": "string" },
+					"before": { "type": "integer", "default": 5 },
+					"after": { "type": "integer", "default": 5 }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["messages"],
+					"properties": {
+						"messages": {
+							"type": "array",
+							"items": {
+								"type": "union",
+								"refs": ["chat.bsky.convo.defs#messageView", "chat.bsky.convo.defs#deletedMessageView"]
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/chat/bsky/moderation/updateActorAccess.json

···
+{
+	"lexicon": 1,
+	"id": "chat.bsky.moderation.updateActorAccess",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["actor", "allowAccess"],
+					"properties": {
+						"actor": { "type": "string", "format": "did" },
+						"allowAccess": { "type": "boolean" },
+						"ref": { "type": "string" }
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/admin/defs.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.admin.defs",
+	"defs": {
+		"statusAttr": {
+			"type": "object",
+			"required": ["applied"],
+			"properties": {
+				"applied": { "type": "boolean" },
+				"ref": { "type": "string" }
+			}
+		},
+		"accountView": {
+			"type": "object",
+			"required": ["did", "handle", "indexedAt"],
+			"properties": {
+				"did": { "type": "string", "format": "did" },
+				"handle": { "type": "string", "format": "handle" },
+				"email": { "type": "string" },
+				"relatedRecords": { "type": "array", "items": { "type": "unknown" } },
+				"indexedAt": { "type": "string", "format": "datetime" },
+				"invitedBy": {
+					"type": "ref",
+					"ref": "com.atproto.server.defs#inviteCode"
+				},
+				"invites": {
+					"type": "array",
+					"items": {
+						"type": "ref",
+						"ref": "com.atproto.server.defs#inviteCode"
+					}
+				},
+				"invitesDisabled": { "type": "boolean" },
+				"emailConfirmedAt": { "type": "string", "format": "datetime" },
+				"inviteNote": { "type": "string" },
+				"deactivatedAt": { "type": "string", "format": "datetime" }
+			}
+		},
+		"repoRef": {
+			"type": "object",
+			"required": ["did"],
+			"properties": {
+				"did": { "type": "string", "format": "did" }
+			}
+		},
+		"repoBlobRef": {
+			"type": "object",
+			"required": ["did", "cid"],
+			"properties": {
+				"did": { "type": "string", "format": "did" },
+				"cid": { "type": "string", "format": "cid" },
+				"recordUri": { "type": "string", "format": "at-uri" }
+			}
+		}
+	}
+}

lexicons/com/atproto/admin/deleteAccount.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.admin.deleteAccount",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Delete a user account as an administrator.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["did"],
+					"properties": {
+						"did": { "type": "string", "format": "did" }
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/admin/disableAccountInvites.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.admin.disableAccountInvites",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Disable an account from receiving new invite codes, but does not invalidate existing codes.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["account"],
+					"properties": {
+						"account": { "type": "string", "format": "did" },
+						"note": {
+							"type": "string",
+							"description": "Optional reason for disabled invites."
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/admin/disableInviteCodes.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.admin.disableInviteCodes",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Disable some set of codes and/or all codes associated with a set of users.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"properties": {
+						"codes": {
+							"type": "array",
+							"items": { "type": "string" }
+						},
+						"accounts": {
+							"type": "array",
+							"items": { "type": "string" }
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/admin/enableAccountInvites.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.admin.enableAccountInvites",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Re-enable an account's ability to receive invite codes.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["account"],
+					"properties": {
+						"account": { "type": "string", "format": "did" },
+						"note": {
+							"type": "string",
+							"description": "Optional reason for enabled invites."
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/admin/getAccountInfo.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.admin.getAccountInfo",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get details about an account.",
+			"parameters": {
+				"type": "params",
+				"required": ["did"],
+				"properties": {
+					"did": { "type": "string", "format": "did" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "ref",
+					"ref": "com.atproto.admin.defs#accountView"
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/admin/getAccountInfos.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.admin.getAccountInfos",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get details about some accounts.",
+			"parameters": {
+				"type": "params",
+				"required": ["dids"],
+				"properties": {
+					"dids": {
+						"type": "array",
+						"items": { "type": "string", "format": "did" }
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["infos"],
+					"properties": {
+						"infos": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "com.atproto.admin.defs#accountView"
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/admin/getInviteCodes.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.admin.getInviteCodes",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get an admin view of invite codes.",
+			"parameters": {
+				"type": "params",
+				"properties": {
+					"sort": {
+						"type": "string",
+						"knownValues": ["recent", "usage"],
+						"default": "recent"
+					},
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 500,
+						"default": 100
+					},
+					"cursor": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["codes"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"codes": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "com.atproto.server.defs#inviteCode"
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/admin/getSubjectStatus.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.admin.getSubjectStatus",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get the service-specific admin status of a subject (account, record, or blob).",
+			"parameters": {
+				"type": "params",
+				"properties": {
+					"did": { "type": "string", "format": "did" },
+					"uri": { "type": "string", "format": "at-uri" },
+					"blob": { "type": "string", "format": "cid" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["subject"],
+					"properties": {
+						"subject": {
+							"type": "union",
+							"refs": [
+								"com.atproto.admin.defs#repoRef",
+								"com.atproto.repo.strongRef",
+								"com.atproto.admin.defs#repoBlobRef"
+							]
+						},
+						"takedown": {
+							"type": "ref",
+							"ref": "com.atproto.admin.defs#statusAttr"
+						},
+						"deactivated": {
+							"type": "ref",
+							"ref": "com.atproto.admin.defs#statusAttr"
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/admin/searchAccounts.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.admin.searchAccounts",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get list of accounts that matches your search query.",
+			"parameters": {
+				"type": "params",
+				"properties": {
+					"email": { "type": "string" },
+					"cursor": { "type": "string" },
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 50
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["accounts"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"accounts": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "com.atproto.admin.defs#accountView"
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/admin/sendEmail.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.admin.sendEmail",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Send email to a user's account email address.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["recipientDid", "content", "senderDid"],
+					"properties": {
+						"recipientDid": { "type": "string", "format": "did" },
+						"content": { "type": "string" },
+						"subject": { "type": "string" },
+						"senderDid": { "type": "string", "format": "did" },
+						"comment": {
+							"type": "string",
+							"description": "Additional comment by the sender that won't be used in the email itself but helpful to provide more context for moderators/reviewers"
+						}
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["sent"],
+					"properties": {
+						"sent": { "type": "boolean" }
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/admin/updateAccountEmail.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.admin.updateAccountEmail",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Administrative action to update an account's email.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["account", "email"],
+					"properties": {
+						"account": {
+							"type": "string",
+							"format": "at-identifier",
+							"description": "The handle or DID of the repo."
+						},
+						"email": { "type": "string" }
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/admin/updateAccountHandle.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.admin.updateAccountHandle",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Administrative action to update an account's handle.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["did", "handle"],
+					"properties": {
+						"did": { "type": "string", "format": "did" },
+						"handle": { "type": "string", "format": "handle" }
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/admin/updateAccountPassword.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.admin.updateAccountPassword",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Update the password for a user account as an administrator.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["did", "password"],
+					"properties": {
+						"did": { "type": "string", "format": "did" },
+						"password": { "type": "string" }
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/admin/updateSubjectStatus.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.admin.updateSubjectStatus",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Update the service-specific admin status of a subject (account, record, or blob).",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["subject"],
+					"properties": {
+						"subject": {
+							"type": "union",
+							"refs": [
+								"com.atproto.admin.defs#repoRef",
+								"com.atproto.repo.strongRef",
+								"com.atproto.admin.defs#repoBlobRef"
+							]
+						},
+						"takedown": {
+							"type": "ref",
+							"ref": "com.atproto.admin.defs#statusAttr"
+						},
+						"deactivated": {
+							"type": "ref",
+							"ref": "com.atproto.admin.defs#statusAttr"
+						}
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["subject"],
+					"properties": {
+						"subject": {
+							"type": "union",
+							"refs": [
+								"com.atproto.admin.defs#repoRef",
+								"com.atproto.repo.strongRef",
+								"com.atproto.admin.defs#repoBlobRef"
+							]
+						},
+						"takedown": {
+							"type": "ref",
+							"ref": "com.atproto.admin.defs#statusAttr"
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/identity/getRecommendedDidCredentials.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.identity.getRecommendedDidCredentials",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Describe the credentials that should be included in the DID doc of an account that is migrating to this service.",
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"properties": {
+						"rotationKeys": {
+							"description": "Recommended rotation keys for PLC dids. Should be undefined (or ignored) for did:webs.",
+							"type": "array",
+							"items": { "type": "string" }
+						},
+						"alsoKnownAs": {
+							"type": "array",
+							"items": { "type": "string" }
+						},
+						"verificationMethods": { "type": "unknown" },
+						"services": { "type": "unknown" }
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/identity/requestPlcOperationSignature.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.identity.requestPlcOperationSignature",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Request an email with a code to in order to request a signed PLC operation. Requires Auth."
+		}
+	}
+}

lexicons/com/atproto/identity/resolveHandle.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.identity.resolveHandle",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Resolves a handle (domain name) to a DID.",
+			"parameters": {
+				"type": "params",
+				"required": ["handle"],
+				"properties": {
+					"handle": {
+						"type": "string",
+						"format": "handle",
+						"description": "The handle to resolve."
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["did"],
+					"properties": {
+						"did": { "type": "string", "format": "did" }
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/identity/signPlcOperation.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.identity.signPlcOperation",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Signs a PLC operation to update some value(s) in the requesting DID's document.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"properties": {
+						"token": {
+							"description": "A token received through com.atproto.identity.requestPlcOperationSignature",
+							"type": "string"
+						},
+						"rotationKeys": {
+							"type": "array",
+							"items": { "type": "string" }
+						},
+						"alsoKnownAs": {
+							"type": "array",
+							"items": { "type": "string" }
+						},
+						"verificationMethods": { "type": "unknown" },
+						"services": { "type": "unknown" }
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["operation"],
+					"properties": {
+						"operation": {
+							"type": "unknown",
+							"description": "A signed DID PLC operation."
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/identity/submitPlcOperation.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.identity.submitPlcOperation",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Validates a PLC operation to ensure that it doesn't violate a service's constraints or get the identity into a bad state, then submits it to the PLC registry",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["operation"],
+					"properties": {
+						"operation": { "type": "unknown" }
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/identity/updateHandle.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.identity.updateHandle",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Updates the current account's handle. Verifies handle validity, and updates did:plc document if necessary. Implemented by PDS, and requires auth.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["handle"],
+					"properties": {
+						"handle": {
+							"type": "string",
+							"format": "handle",
+							"description": "The new handle."
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/label/defs.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.label.defs",
+	"defs": {
+		"label": {
+			"type": "object",
+			"description": "Metadata tag on an atproto resource (eg, repo or record).",
+			"required": ["src", "uri", "val", "cts"],
+			"properties": {
+				"ver": {
+					"type": "integer",
+					"description": "The AT Protocol version of the label object."
+				},
+				"src": {
+					"type": "string",
+					"format": "did",
+					"description": "DID of the actor who created this label."
+				},
+				"uri": {
+					"type": "string",
+					"format": "uri",
+					"description": "AT URI of the record, repository (account), or other resource that this label applies to."
+				},
+				"cid": {
+					"type": "string",
+					"format": "cid",
+					"description": "Optionally, CID specifying the specific version of 'uri' resource this label applies to."
+				},
+				"val": {
+					"type": "string",
+					"maxLength": 128,
+					"description": "The short string name of the value or type of this label."
+				},
+				"neg": {
+					"type": "boolean",
+					"description": "If true, this is a negation label, overwriting a previous label."
+				},
+				"cts": {
+					"type": "string",
+					"format": "datetime",
+					"description": "Timestamp when this label was created."
+				},
+				"exp": {
+					"type": "string",
+					"format": "datetime",
+					"description": "Timestamp at which this label expires (no longer applies)."
+				},
+				"sig": {
+					"type": "bytes",
+					"description": "Signature of dag-cbor encoded label."
+				}
+			}
+		},
+		"selfLabels": {
+			"type": "object",
+			"description": "Metadata tags on an atproto record, published by the author within the record.",
+			"required": ["values"],
+			"properties": {
+				"values": {
+					"type": "array",
+					"items": { "type": "ref", "ref": "#selfLabel" },
+					"maxLength": 10
+				}
+			}
+		},
+		"selfLabel": {
+			"type": "object",
+			"description": "Metadata tag on an atproto record, published by the author within the record. Note that schemas should use #selfLabels, not #selfLabel.",
+			"required": ["val"],
+			"properties": {
+				"val": {
+					"type": "string",
+					"maxLength": 128,
+					"description": "The short string name of the value or type of this label."
+				}
+			}
+		},
+		"labelValueDefinition": {
+			"type": "object",
+			"description": "Declares a label value and its expected interpretations and behaviors.",
+			"required": ["identifier", "severity", "blurs", "locales"],
+			"properties": {
+				"identifier": {
+					"type": "string",
+					"description": "The value of the label being defined. Must only include lowercase ascii and the '-' character ([a-z-]+).",
+					"maxLength": 100,
+					"maxGraphemes": 100
+				},
+				"severity": {
+					"type": "string",
+					"description": "How should a client visually convey this label? 'inform' means neutral and informational; 'alert' means negative and warning; 'none' means show nothing.",
+					"knownValues": ["inform", "alert", "none"]
+				},
+				"blurs": {
+					"type": "string",
+					"description": "What should this label hide in the UI, if applied? 'content' hides all of the target; 'media' hides the images/video/audio; 'none' hides nothing.",
+					"knownValues": ["content", "media", "none"]
+				},
+				"defaultSetting": {
+					"type": "string",
+					"description": "The default setting for this label.",
+					"knownValues": ["ignore", "warn", "hide"],
+					"default": "warn"
+				},
+				"adultOnly": {
+					"type": "boolean",
+					"description": "Does the user need to have adult content enabled in order to configure this label?"
+				},
+				"locales": {
+					"type": "array",
+					"items": { "type": "ref", "ref": "#labelValueDefinitionStrings" }
+				}
+			}
+		},
+		"labelValueDefinitionStrings": {
+			"type": "object",
+			"description": "Strings which describe the label in the UI, localized into a specific language.",
+			"required": ["lang", "name", "description"],
+			"properties": {
+				"lang": {
+					"type": "string",
+					"description": "The code of the language these strings are written in.",
+					"format": "language"
+				},
+				"name": {
+					"type": "string",
+					"description": "A short human-readable name for the label.",
+					"maxGraphemes": 64,
+					"maxLength": 640
+				},
+				"description": {
+					"type": "string",
+					"description": "A longer description of what the label means and why it might be applied.",
+					"maxGraphemes": 10000,
+					"maxLength": 100000
+				}
+			}
+		},
+		"labelValue": {
+			"type": "string",
+			"knownValues": [
+				"!hide",
+				"!no-promote",
+				"!warn",
+				"!no-unauthenticated",
+				"dmca-violation",
+				"doxxing",
+				"porn",
+				"sexual",
+				"nudity",
+				"nsfl",
+				"gore"
+			]
+		}
+	}
+}

lexicons/com/atproto/label/queryLabels.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.label.queryLabels",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Find labels relevant to the provided AT-URI patterns. Public endpoint for moderation services, though may return different or additional results with auth.",
+			"parameters": {
+				"type": "params",
+				"required": ["uriPatterns"],
+				"properties": {
+					"uriPatterns": {
+						"type": "array",
+						"items": { "type": "string" },
+						"description": "List of AT URI patterns to match (boolean 'OR'). Each may be a prefix (ending with '*'; will match inclusive of the string leading to '*'), or a full URI."
+					},
+					"sources": {
+						"type": "array",
+						"items": { "type": "string", "format": "did" },
+						"description": "Optional list of label sources (DIDs) to filter on."
+					},
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 250,
+						"default": 50
+					},
+					"cursor": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["labels"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"labels": {
+							"type": "array",
+							"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/label/subscribeLabels.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.label.subscribeLabels",
+	"defs": {
+		"main": {
+			"type": "subscription",
+			"description": "Subscribe to stream of labels (and negations). Public endpoint implemented by mod services. Uses same sequencing scheme as repo event stream.",
+			"parameters": {
+				"type": "params",
+				"properties": {
+					"cursor": {
+						"type": "integer",
+						"description": "The last known event seq number to backfill from."
+					}
+				}
+			},
+			"message": {
+				"schema": {
+					"type": "union",
+					"refs": ["#labels", "#info"]
+				}
+			},
+			"errors": [{ "name": "FutureCursor" }]
+		},
+		"labels": {
+			"type": "object",
+			"required": ["seq", "labels"],
+			"properties": {
+				"seq": { "type": "integer" },
+				"labels": {
+					"type": "array",
+					"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+				}
+			}
+		},
+		"info": {
+			"type": "object",
+			"required": ["name"],
+			"properties": {
+				"name": {
+					"type": "string",
+					"knownValues": ["OutdatedCursor"]
+				},
+				"message": {
+					"type": "string"
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/moderation/createReport.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.moderation.createReport",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Submit a moderation report regarding an atproto account or record. Implemented by moderation services (with PDS proxying), and requires auth.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["reasonType", "subject"],
+					"properties": {
+						"reasonType": {
+							"type": "ref",
+							"description": "Indicates the broad category of violation the report is for.",
+							"ref": "com.atproto.moderation.defs#reasonType"
+						},
+						"reason": {
+							"type": "string",
+							"maxGraphemes": 2000,
+							"maxLength": 20000,
+							"description": "Additional context about the content and violation."
+						},
+						"subject": {
+							"type": "union",
+							"refs": ["com.atproto.admin.defs#repoRef", "com.atproto.repo.strongRef"]
+						}
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["id", "reasonType", "subject", "reportedBy", "createdAt"],
+					"properties": {
+						"id": { "type": "integer" },
+						"reasonType": {
+							"type": "ref",
+							"ref": "com.atproto.moderation.defs#reasonType"
+						},
+						"reason": {
+							"type": "string",
+							"maxGraphemes": 2000,
+							"maxLength": 20000
+						},
+						"subject": {
+							"type": "union",
+							"refs": ["com.atproto.admin.defs#repoRef", "com.atproto.repo.strongRef"]
+						},
+						"reportedBy": { "type": "string", "format": "did" },
+						"createdAt": { "type": "string", "format": "datetime" }
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/moderation/defs.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.moderation.defs",
+	"defs": {
+		"reasonType": {
+			"type": "string",
+			"knownValues": [
+				"com.atproto.moderation.defs#reasonSpam",
+				"com.atproto.moderation.defs#reasonViolation",
+				"com.atproto.moderation.defs#reasonMisleading",
+				"com.atproto.moderation.defs#reasonSexual",
+				"com.atproto.moderation.defs#reasonRude",
+				"com.atproto.moderation.defs#reasonOther",
+				"com.atproto.moderation.defs#reasonAppeal"
+			]
+		},
+		"reasonSpam": {
+			"type": "token",
+			"description": "Spam: frequent unwanted promotion, replies, mentions"
+		},
+		"reasonViolation": {
+			"type": "token",
+			"description": "Direct violation of server rules, laws, terms of service"
+		},
+		"reasonMisleading": {
+			"type": "token",
+			"description": "Misleading identity, affiliation, or content"
+		},
+		"reasonSexual": {
+			"type": "token",
+			"description": "Unwanted or mislabeled sexual content"
+		},
+		"reasonRude": {
+			"type": "token",
+			"description": "Rude, harassing, explicit, or otherwise unwelcoming behavior"
+		},
+		"reasonOther": {
+			"type": "token",
+			"description": "Other: reports not falling under another report category"
+		},
+		"reasonAppeal": {
+			"type": "token",
+			"description": "Appeal: appeal a previously taken moderation action"
+		}
+	}
+}

lexicons/com/atproto/repo/applyWrites.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.repo.applyWrites",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Apply a batch transaction of repository creates, updates, and deletes. Requires auth, implemented by PDS.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["repo", "writes"],
+					"properties": {
+						"repo": {
+							"type": "string",
+							"format": "at-identifier",
+							"description": "The handle or DID of the repo (aka, current account)."
+						},
+						"validate": {
+							"type": "boolean",
+							"default": true,
+							"description": "Can be set to 'false' to skip Lexicon schema validation of record data, for all operations."
+						},
+						"writes": {
+							"type": "array",
+							"items": {
+								"type": "union",
+								"refs": ["#create", "#update", "#delete"],
+								"closed": true
+							}
+						},
+						"swapCommit": {
+							"type": "string",
+							"description": "If provided, the entire operation will fail if the current repo commit CID does not match this value. Used to prevent conflicting repo mutations.",
+							"format": "cid"
+						}
+					}
+				}
+			},
+			"errors": [
+				{
+					"name": "InvalidSwap",
+					"description": "Indicates that the 'swapCommit' parameter did not match current commit."
+				}
+			]
+		},
+		"create": {
+			"type": "object",
+			"description": "Operation which creates a new record.",
+			"required": ["collection", "value"],
+			"properties": {
+				"collection": { "type": "string", "format": "nsid" },
+				"rkey": { "type": "string", "maxLength": 15 },
+				"value": { "type": "unknown" }
+			}
+		},
+		"update": {
+			"type": "object",
+			"description": "Operation which updates an existing record.",
+			"required": ["collection", "rkey", "value"],
+			"properties": {
+				"collection": { "type": "string", "format": "nsid" },
+				"rkey": { "type": "string" },
+				"value": { "type": "unknown" }
+			}
+		},
+		"delete": {
+			"type": "object",
+			"description": "Operation which deletes an existing record.",
+			"required": ["collection", "rkey"],
+			"properties": {
+				"collection": { "type": "string", "format": "nsid" },
+				"rkey": { "type": "string" }
+			}
+		}
+	}
+}

lexicons/com/atproto/repo/createRecord.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.repo.createRecord",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Create a single new repository record. Requires auth, implemented by PDS.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["repo", "collection", "record"],
+					"properties": {
+						"repo": {
+							"type": "string",
+							"format": "at-identifier",
+							"description": "The handle or DID of the repo (aka, current account)."
+						},
+						"collection": {
+							"type": "string",
+							"format": "nsid",
+							"description": "The NSID of the record collection."
+						},
+						"rkey": {
+							"type": "string",
+							"description": "The Record Key.",
+							"maxLength": 15
+						},
+						"validate": {
+							"type": "boolean",
+							"default": true,
+							"description": "Can be set to 'false' to skip Lexicon schema validation of record data."
+						},
+						"record": {
+							"type": "unknown",
+							"description": "The record itself. Must contain a $type field."
+						},
+						"swapCommit": {
+							"type": "string",
+							"format": "cid",
+							"description": "Compare and swap with the previous commit by CID."
+						}
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["uri", "cid"],
+					"properties": {
+						"uri": { "type": "string", "format": "at-uri" },
+						"cid": { "type": "string", "format": "cid" }
+					}
+				}
+			},
+			"errors": [
+				{
+					"name": "InvalidSwap",
+					"description": "Indicates that 'swapCommit' didn't match current repo commit."
+				}
+			]
+		}
+	}
+}

lexicons/com/atproto/repo/deleteRecord.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.repo.deleteRecord",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Delete a repository record, or ensure it doesn't exist. Requires auth, implemented by PDS.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["repo", "collection", "rkey"],
+					"properties": {
+						"repo": {
+							"type": "string",
+							"format": "at-identifier",
+							"description": "The handle or DID of the repo (aka, current account)."
+						},
+						"collection": {
+							"type": "string",
+							"format": "nsid",
+							"description": "The NSID of the record collection."
+						},
+						"rkey": {
+							"type": "string",
+							"description": "The Record Key."
+						},
+						"swapRecord": {
+							"type": "string",
+							"format": "cid",
+							"description": "Compare and swap with the previous record by CID."
+						},
+						"swapCommit": {
+							"type": "string",
+							"format": "cid",
+							"description": "Compare and swap with the previous commit by CID."
+						}
+					}
+				}
+			},
+			"errors": [{ "name": "InvalidSwap" }]
+		}
+	}
+}

lexicons/com/atproto/repo/describeRepo.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.repo.describeRepo",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get information about an account and repository, including the list of collections. Does not require auth.",
+			"parameters": {
+				"type": "params",
+				"required": ["repo"],
+				"properties": {
+					"repo": {
+						"type": "string",
+						"format": "at-identifier",
+						"description": "The handle or DID of the repo."
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["handle", "did", "didDoc", "collections", "handleIsCorrect"],
+					"properties": {
+						"handle": { "type": "string", "format": "handle" },
+						"did": { "type": "string", "format": "did" },
+						"didDoc": {
+							"type": "unknown",
+							"description": "The complete DID document for this account."
+						},
+						"collections": {
+							"type": "array",
+							"description": "List of all the collections (NSIDs) for which this repo contains at least one record.",
+							"items": { "type": "string", "format": "nsid" }
+						},
+						"handleIsCorrect": {
+							"type": "boolean",
+							"description": "Indicates if handle is currently valid (resolves bi-directionally)"
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/repo/getRecord.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.repo.getRecord",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get a single record from a repository. Does not require auth.",
+			"parameters": {
+				"type": "params",
+				"required": ["repo", "collection", "rkey"],
+				"properties": {
+					"repo": {
+						"type": "string",
+						"format": "at-identifier",
+						"description": "The handle or DID of the repo."
+					},
+					"collection": {
+						"type": "string",
+						"format": "nsid",
+						"description": "The NSID of the record collection."
+					},
+					"rkey": { "type": "string", "description": "The Record Key." },
+					"cid": {
+						"type": "string",
+						"format": "cid",
+						"description": "The CID of the version of the record. If not specified, then return the most recent version."
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["uri", "value"],
+					"properties": {
+						"uri": { "type": "string", "format": "at-uri" },
+						"cid": { "type": "string", "format": "cid" },
+						"value": { "type": "unknown" }
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/repo/importRepo.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.repo.importRepo",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Import a repo in the form of a CAR file. Requires Content-Length HTTP header to be set.",
+			"input": {
+				"encoding": "application/vnd.ipld.car"
+			}
+		}
+	}
+}

lexicons/com/atproto/repo/listMissingBlobs.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.repo.listMissingBlobs",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Returns a list of missing blobs for the requesting account. Intended to be used in the account migration flow.",
+			"parameters": {
+				"type": "params",
+				"properties": {
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 1000,
+						"default": 500
+					},
+					"cursor": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["blobs"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"blobs": {
+							"type": "array",
+							"items": { "type": "ref", "ref": "#recordBlob" }
+						}
+					}
+				}
+			}
+		},
+		"recordBlob": {
+			"type": "object",
+			"required": ["cid", "recordUri"],
+			"properties": {
+				"cid": { "type": "string", "format": "cid" },
+				"recordUri": { "type": "string", "format": "at-uri" }
+			}
+		}
+	}
+}

lexicons/com/atproto/repo/listRecords.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.repo.listRecords",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "List a range of records in a repository, matching a specific collection. Does not require auth.",
+			"parameters": {
+				"type": "params",
+				"required": ["repo", "collection"],
+				"properties": {
+					"repo": {
+						"type": "string",
+						"format": "at-identifier",
+						"description": "The handle or DID of the repo."
+					},
+					"collection": {
+						"type": "string",
+						"format": "nsid",
+						"description": "The NSID of the record type."
+					},
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 50,
+						"description": "The number of records to return."
+					},
+					"cursor": { "type": "string" },
+					"rkeyStart": {
+						"type": "string",
+						"description": "DEPRECATED: The lowest sort-ordered rkey to start from (exclusive)"
+					},
+					"rkeyEnd": {
+						"type": "string",
+						"description": "DEPRECATED: The highest sort-ordered rkey to stop at (exclusive)"
+					},
+					"reverse": {
+						"type": "boolean",
+						"description": "Flag to reverse the order of the returned records."
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["records"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"records": {
+							"type": "array",
+							"items": { "type": "ref", "ref": "#record" }
+						}
+					}
+				}
+			}
+		},
+		"record": {
+			"type": "object",
+			"required": ["uri", "cid", "value"],
+			"properties": {
+				"uri": { "type": "string", "format": "at-uri" },
+				"cid": { "type": "string", "format": "cid" },
+				"value": { "type": "unknown" }
+			}
+		}
+	}
+}

lexicons/com/atproto/repo/putRecord.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.repo.putRecord",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Write a repository record, creating or updating it as needed. Requires auth, implemented by PDS.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["repo", "collection", "rkey", "record"],
+					"nullable": ["swapRecord"],
+					"properties": {
+						"repo": {
+							"type": "string",
+							"format": "at-identifier",
+							"description": "The handle or DID of the repo (aka, current account)."
+						},
+						"collection": {
+							"type": "string",
+							"format": "nsid",
+							"description": "The NSID of the record collection."
+						},
+						"rkey": {
+							"type": "string",
+							"description": "The Record Key.",
+							"maxLength": 15
+						},
+						"validate": {
+							"type": "boolean",
+							"default": true,
+							"description": "Can be set to 'false' to skip Lexicon schema validation of record data."
+						},
+						"record": {
+							"type": "unknown",
+							"description": "The record to write."
+						},
+						"swapRecord": {
+							"type": "string",
+							"format": "cid",
+							"description": "Compare and swap with the previous record by CID. WARNING: nullable and optional field; may cause problems with golang implementation"
+						},
+						"swapCommit": {
+							"type": "string",
+							"format": "cid",
+							"description": "Compare and swap with the previous commit by CID."
+						}
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["uri", "cid"],
+					"properties": {
+						"uri": { "type": "string", "format": "at-uri" },
+						"cid": { "type": "string", "format": "cid" }
+					}
+				}
+			},
+			"errors": [{ "name": "InvalidSwap" }]
+		}
+	}
+}

lexicons/com/atproto/repo/strongRef.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.repo.strongRef",
+	"description": "A URI with a content-hash fingerprint.",
+	"defs": {
+		"main": {
+			"type": "object",
+			"required": ["uri", "cid"],
+			"properties": {
+				"uri": { "type": "string", "format": "at-uri" },
+				"cid": { "type": "string", "format": "cid" }
+			}
+		}
+	}
+}

lexicons/com/atproto/repo/uploadBlob.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.repo.uploadBlob",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Upload a new blob, to be referenced from a repository record. The blob will be deleted if it is not referenced within a time window (eg, minutes). Blob restrictions (mimetype, size, etc) are enforced when the reference is created. Requires auth, implemented by PDS.",
+			"input": {
+				"encoding": "*/*"
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["blob"],
+					"properties": {
+						"blob": { "type": "blob" }
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/server/activateAccount.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.server.activateAccount",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Activates a currently deactivated account. Used to finalize account migration after the account's repo is imported and identity is setup."
+		}
+	}
+}

lexicons/com/atproto/server/checkAccountStatus.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.server.checkAccountStatus",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Returns the status of an account, especially as pertaining to import or recovery. Can be called many times over the course of an account migration. Requires auth and can only be called pertaining to oneself.",
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": [
+						"activated",
+						"validDid",
+						"repoCommit",
+						"repoRev",
+						"repoBlocks",
+						"indexedRecords",
+						"privateStateValues",
+						"expectedBlobs",
+						"importedBlobs"
+					],
+					"properties": {
+						"activated": { "type": "boolean" },
+						"validDid": { "type": "boolean" },
+						"repoCommit": { "type": "string", "format": "cid" },
+						"repoRev": { "type": "string" },
+						"repoBlocks": { "type": "integer" },
+						"indexedRecords": { "type": "integer" },
+						"privateStateValues": { "type": "integer" },
+						"expectedBlobs": { "type": "integer" },
+						"importedBlobs": { "type": "integer" }
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/server/confirmEmail.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.server.confirmEmail",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Confirm an email using a token from com.atproto.server.requestEmailConfirmation.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["email", "token"],
+					"properties": {
+						"email": { "type": "string" },
+						"token": { "type": "string" }
+					}
+				}
+			},
+			"errors": [
+				{ "name": "AccountNotFound" },
+				{ "name": "ExpiredToken" },
+				{ "name": "InvalidToken" },
+				{ "name": "InvalidEmail" }
+			]
+		}
+	}
+}

lexicons/com/atproto/server/createAccount.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.server.createAccount",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Create an account. Implemented by PDS.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["handle"],
+					"properties": {
+						"email": { "type": "string" },
+						"handle": {
+							"type": "string",
+							"format": "handle",
+							"description": "Requested handle for the account."
+						},
+						"did": {
+							"type": "string",
+							"format": "did",
+							"description": "Pre-existing atproto DID, being imported to a new account."
+						},
+						"inviteCode": { "type": "string" },
+						"verificationCode": { "type": "string" },
+						"verificationPhone": { "type": "string" },
+						"password": {
+							"type": "string",
+							"description": "Initial account password. May need to meet instance-specific password strength requirements."
+						},
+						"recoveryKey": {
+							"type": "string",
+							"description": "DID PLC rotation key (aka, recovery key) to be included in PLC creation operation."
+						},
+						"plcOp": {
+							"type": "unknown",
+							"description": "A signed DID PLC operation to be submitted as part of importing an existing account to this instance. NOTE: this optional field may be updated when full account migration is implemented."
+						}
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"description": "Account login session returned on successful account creation.",
+					"required": ["accessJwt", "refreshJwt", "handle", "did"],
+					"properties": {
+						"accessJwt": { "type": "string" },
+						"refreshJwt": { "type": "string" },
+						"handle": { "type": "string", "format": "handle" },
+						"did": {
+							"type": "string",
+							"format": "did",
+							"description": "The DID of the new account."
+						},
+						"didDoc": {
+							"type": "unknown",
+							"description": "Complete DID document."
+						}
+					}
+				}
+			},
+			"errors": [
+				{ "name": "InvalidHandle" },
+				{ "name": "InvalidPassword" },
+				{ "name": "InvalidInviteCode" },
+				{ "name": "HandleNotAvailable" },
+				{ "name": "UnsupportedDomain" },
+				{ "name": "UnresolvableDid" },
+				{ "name": "IncompatibleDidDoc" }
+			]
+		}
+	}
+}

lexicons/com/atproto/server/createAppPassword.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.server.createAppPassword",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Create an App Password.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["name"],
+					"properties": {
+						"name": {
+							"type": "string",
+							"description": "A short name for the App Password, to help distinguish them."
+						},
+						"privileged": {
+							"type": "boolean",
+							"description": "If an app password has 'privileged' access to possibly sensitive account state. Meant for use with trusted clients."
+						}
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "ref",
+					"ref": "#appPassword"
+				}
+			},
+			"errors": [{ "name": "AccountTakedown" }]
+		},
+		"appPassword": {
+			"type": "object",
+			"required": ["name", "password", "createdAt"],
+			"properties": {
+				"name": { "type": "string" },
+				"password": { "type": "string" },
+				"createdAt": { "type": "string", "format": "datetime" },
+				"privileged": { "type": "boolean" }
+			}
+		}
+	}
+}

lexicons/com/atproto/server/createInviteCode.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.server.createInviteCode",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Create an invite code.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["useCount"],
+					"properties": {
+						"useCount": { "type": "integer" },
+						"forAccount": { "type": "string", "format": "did" }
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["code"],
+					"properties": {
+						"code": { "type": "string" }
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/server/createInviteCodes.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.server.createInviteCodes",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Create invite codes.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["codeCount", "useCount"],
+					"properties": {
+						"codeCount": { "type": "integer", "default": 1 },
+						"useCount": { "type": "integer" },
+						"forAccounts": {
+							"type": "array",
+							"items": { "type": "string", "format": "did" }
+						}
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["codes"],
+					"properties": {
+						"codes": {
+							"type": "array",
+							"items": { "type": "ref", "ref": "#accountCodes" }
+						}
+					}
+				}
+			}
+		},
+		"accountCodes": {
+			"type": "object",
+			"required": ["account", "codes"],
+			"properties": {
+				"account": { "type": "string" },
+				"codes": {
+					"type": "array",
+					"items": { "type": "string" }
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/server/createSession.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.server.createSession",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Create an authentication session.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["identifier", "password"],
+					"properties": {
+						"identifier": {
+							"type": "string",
+							"description": "Handle or other identifier supported by the server for the authenticating user."
+						},
+						"password": { "type": "string" },
+						"authFactorToken": { "type": "string" }
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["accessJwt", "refreshJwt", "handle", "did"],
+					"properties": {
+						"accessJwt": { "type": "string" },
+						"refreshJwt": { "type": "string" },
+						"handle": { "type": "string", "format": "handle" },
+						"did": { "type": "string", "format": "did" },
+						"didDoc": { "type": "unknown" },
+						"email": { "type": "string" },
+						"emailConfirmed": { "type": "boolean" },
+						"emailAuthFactor": { "type": "boolean" },
+						"active": { "type": "boolean" },
+						"status": {
+							"type": "string",
+							"description": "If active=false, this optional field indicates a possible reason for why the account is not active. If active=false and no status is supplied, then the host makes no claim for why the repository is no longer being hosted.",
+							"knownValues": ["takendown", "suspended", "deactivated"]
+						}
+					}
+				}
+			},
+			"errors": [{ "name": "AccountTakedown" }, { "name": "AuthFactorTokenRequired" }]
+		}
+	}
+}

lexicons/com/atproto/server/deactivateAccount.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.server.deactivateAccount",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Deactivates a currently active account. Stops serving of repo, and future writes to repo until reactivated. Used to finalize account migration with the old host after the account has been activated on the new host.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"properties": {
+						"deleteAfter": {
+							"type": "string",
+							"format": "datetime",
+							"description": "A recommendation to server as to how long they should hold onto the deactivated account before deleting."
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/server/defs.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.server.defs",
+	"defs": {
+		"inviteCode": {
+			"type": "object",
+			"required": ["code", "available", "disabled", "forAccount", "createdBy", "createdAt", "uses"],
+			"properties": {
+				"code": { "type": "string" },
+				"available": { "type": "integer" },
+				"disabled": { "type": "boolean" },
+				"forAccount": { "type": "string" },
+				"createdBy": { "type": "string" },
+				"createdAt": { "type": "string", "format": "datetime" },
+				"uses": {
+					"type": "array",
+					"items": { "type": "ref", "ref": "#inviteCodeUse" }
+				}
+			}
+		},
+		"inviteCodeUse": {
+			"type": "object",
+			"required": ["usedBy", "usedAt"],
+			"properties": {
+				"usedBy": { "type": "string", "format": "did" },
+				"usedAt": { "type": "string", "format": "datetime" }
+			}
+		}
+	}
+}

lexicons/com/atproto/server/deleteAccount.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.server.deleteAccount",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Delete an actor's account with a token and password. Can only be called after requesting a deletion token. Requires auth.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["did", "password", "token"],
+					"properties": {
+						"did": { "type": "string", "format": "did" },
+						"password": { "type": "string" },
+						"token": { "type": "string" }
+					}
+				}
+			},
+			"errors": [{ "name": "ExpiredToken" }, { "name": "InvalidToken" }]
+		}
+	}
+}

lexicons/com/atproto/server/deleteSession.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.server.deleteSession",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Delete the current session. Requires auth."
+		}
+	}
+}

lexicons/com/atproto/server/describeServer.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.server.describeServer",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Describes the server's account creation requirements and capabilities. Implemented by PDS.",
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["did", "availableUserDomains"],
+					"properties": {
+						"inviteCodeRequired": {
+							"type": "boolean",
+							"description": "If true, an invite code must be supplied to create an account on this instance."
+						},
+						"phoneVerificationRequired": {
+							"type": "boolean",
+							"description": "If true, a phone verification token must be supplied to create an account on this instance."
+						},
+						"availableUserDomains": {
+							"type": "array",
+							"description": "List of domain suffixes that can be used in account handles.",
+							"items": { "type": "string" }
+						},
+						"links": {
+							"type": "ref",
+							"description": "URLs of service policy documents.",
+							"ref": "#links"
+						},
+						"contact": {
+							"type": "ref",
+							"description": "Contact information",
+							"ref": "#contact"
+						},
+						"did": {
+							"type": "string",
+							"format": "did"
+						}
+					}
+				}
+			}
+		},
+		"links": {
+			"type": "object",
+			"properties": {
+				"privacyPolicy": { "type": "string", "format": "uri" },
+				"termsOfService": { "type": "string", "format": "uri" }
+			}
+		},
+		"contact": {
+			"type": "object",
+			"properties": {
+				"email": { "type": "string" }
+			}
+		}
+	}
+}

lexicons/com/atproto/server/getAccountInviteCodes.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.server.getAccountInviteCodes",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get all invite codes for the current account. Requires auth.",
+			"parameters": {
+				"type": "params",
+				"properties": {
+					"includeUsed": { "type": "boolean", "default": true },
+					"createAvailable": {
+						"type": "boolean",
+						"default": true,
+						"description": "Controls whether any new 'earned' but not 'created' invites should be created."
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["codes"],
+					"properties": {
+						"codes": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "com.atproto.server.defs#inviteCode"
+							}
+						}
+					}
+				}
+			},
+			"errors": [{ "name": "DuplicateCreate" }]
+		}
+	}
+}

lexicons/com/atproto/server/getServiceAuth.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.server.getServiceAuth",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get a signed token on behalf of the requesting DID for the requested service.",
+			"parameters": {
+				"type": "params",
+				"required": ["aud"],
+				"properties": {
+					"aud": {
+						"type": "string",
+						"format": "did",
+						"description": "The DID of the service that the token will be used to authenticate with"
+					},
+					"exp": {
+						"type": "integer",
+						"description": "The time in Unix Epoch seconds that the JWT expires. Defaults to 60 seconds in the future. The service may enforce certain time bounds on tokens depending on the requested scope."
+					},
+					"lxm": {
+						"type": "string",
+						"format": "nsid",
+						"description": "Lexicon (XRPC) method to bind the requested token to"
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["token"],
+					"properties": {
+						"token": {
+							"type": "string"
+						}
+					}
+				}
+			},
+			"errors": [
+				{
+					"name": "BadExpiration",
+					"description": "Indicates that the requested expiration date is not a valid. May be in the past or may be reliant on the requested scopes."
+				}
+			]
+		}
+	}
+}

lexicons/com/atproto/server/getSession.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.server.getSession",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get information about the current auth session. Requires auth.",
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["handle", "did"],
+					"properties": {
+						"handle": { "type": "string", "format": "handle" },
+						"did": { "type": "string", "format": "did" },
+						"email": { "type": "string" },
+						"emailConfirmed": { "type": "boolean" },
+						"emailAuthFactor": { "type": "boolean" },
+						"didDoc": { "type": "unknown" },
+						"active": { "type": "boolean" },
+						"status": {
+							"type": "string",
+							"description": "If active=false, this optional field indicates a possible reason for why the account is not active. If active=false and no status is supplied, then the host makes no claim for why the repository is no longer being hosted.",
+							"knownValues": ["takendown", "suspended", "deactivated"]
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/server/listAppPasswords.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.server.listAppPasswords",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "List all App Passwords.",
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["passwords"],
+					"properties": {
+						"passwords": {
+							"type": "array",
+							"items": { "type": "ref", "ref": "#appPassword" }
+						}
+					}
+				}
+			},
+			"errors": [{ "name": "AccountTakedown" }]
+		},
+		"appPassword": {
+			"type": "object",
+			"required": ["name", "createdAt"],
+			"properties": {
+				"name": { "type": "string" },
+				"createdAt": { "type": "string", "format": "datetime" },
+				"privileged": { "type": "boolean" }
+			}
+		}
+	}
+}

lexicons/com/atproto/server/refreshSession.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.server.refreshSession",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Refresh an authentication session. Requires auth using the 'refreshJwt' (not the 'accessJwt').",
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["accessJwt", "refreshJwt", "handle", "did"],
+					"properties": {
+						"accessJwt": { "type": "string" },
+						"refreshJwt": { "type": "string" },
+						"handle": { "type": "string", "format": "handle" },
+						"did": { "type": "string", "format": "did" },
+						"didDoc": { "type": "unknown" },
+						"active": { "type": "boolean" },
+						"status": {
+							"type": "string",
+							"description": "Hosting status of the account. If not specified, then assume 'active'.",
+							"knownValues": ["takendown", "suspended", "deactivated"]
+						}
+					}
+				}
+			},
+			"errors": [{ "name": "AccountTakedown" }]
+		}
+	}
+}

lexicons/com/atproto/server/requestAccountDelete.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.server.requestAccountDelete",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Initiate a user account deletion via email."
+		}
+	}
+}

lexicons/com/atproto/server/requestEmailConfirmation.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.server.requestEmailConfirmation",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Request an email with a code to confirm ownership of email."
+		}
+	}
+}

lexicons/com/atproto/server/requestEmailUpdate.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.server.requestEmailUpdate",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Request a token in order to update email.",
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["tokenRequired"],
+					"properties": {
+						"tokenRequired": { "type": "boolean" }
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/server/requestPasswordReset.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.server.requestPasswordReset",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Initiate a user account password reset via email.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["email"],
+					"properties": {
+						"email": { "type": "string" }
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/server/reserveSigningKey.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.server.reserveSigningKey",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Reserve a repo signing key, for use with account creation. Necessary so that a DID PLC update operation can be constructed during an account migraiton. Public and does not require auth; implemented by PDS. NOTE: this endpoint may change when full account migration is implemented.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"properties": {
+						"did": {
+							"type": "string",
+							"format": "did",
+							"description": "The DID to reserve a key for."
+						}
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["signingKey"],
+					"properties": {
+						"signingKey": {
+							"type": "string",
+							"description": "The public key for the reserved signing key, in did:key serialization."
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/server/resetPassword.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.server.resetPassword",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Reset a user account password using a token.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["token", "password"],
+					"properties": {
+						"token": { "type": "string" },
+						"password": { "type": "string" }
+					}
+				}
+			},
+			"errors": [{ "name": "ExpiredToken" }, { "name": "InvalidToken" }]
+		}
+	}
+}

lexicons/com/atproto/server/revokeAppPassword.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.server.revokeAppPassword",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Revoke an App Password by name.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["name"],
+					"properties": {
+						"name": { "type": "string" }
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/server/updateEmail.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.server.updateEmail",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Update an account's email.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["email"],
+					"properties": {
+						"email": { "type": "string" },
+						"emailAuthFactor": { "type": "boolean" },
+						"token": {
+							"type": "string",
+							"description": "Requires a token from com.atproto.sever.requestEmailUpdate if the account's email has been confirmed."
+						}
+					}
+				}
+			},
+			"errors": [{ "name": "ExpiredToken" }, { "name": "InvalidToken" }, { "name": "TokenRequired" }]
+		}
+	}
+}

lexicons/com/atproto/sync/getBlob.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.sync.getBlob",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get a blob associated with a given account. Returns the full blob as originally uploaded. Does not require auth; implemented by PDS.",
+			"parameters": {
+				"type": "params",
+				"required": ["did", "cid"],
+				"properties": {
+					"did": {
+						"type": "string",
+						"format": "did",
+						"description": "The DID of the account."
+					},
+					"cid": {
+						"type": "string",
+						"format": "cid",
+						"description": "The CID of the blob to fetch"
+					}
+				}
+			},
+			"output": {
+				"encoding": "*/*"
+			},
+			"errors": [
+				{ "name": "BlobNotFound" },
+				{ "name": "RepoNotFound" },
+				{ "name": "RepoTakendown" },
+				{ "name": "RepoSuspended" },
+				{ "name": "RepoDeactivated" }
+			]
+		}
+	}
+}

lexicons/com/atproto/sync/getBlocks.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.sync.getBlocks",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get data blocks from a given repo, by CID. For example, intermediate MST nodes, or records. Does not require auth; implemented by PDS.",
+			"parameters": {
+				"type": "params",
+				"required": ["did", "cids"],
+				"properties": {
+					"did": {
+						"type": "string",
+						"format": "did",
+						"description": "The DID of the repo."
+					},
+					"cids": {
+						"type": "array",
+						"items": { "type": "string", "format": "cid" }
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/vnd.ipld.car"
+			},
+			"errors": [
+				{ "name": "BlockNotFound" },
+				{ "name": "RepoNotFound" },
+				{ "name": "RepoTakendown" },
+				{ "name": "RepoSuspended" },
+				{ "name": "RepoDeactivated" }
+			]
+		}
+	}
+}

lexicons/com/atproto/sync/getCheckout.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.sync.getCheckout",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "DEPRECATED - please use com.atproto.sync.getRepo instead",
+			"parameters": {
+				"type": "params",
+				"required": ["did"],
+				"properties": {
+					"did": {
+						"type": "string",
+						"format": "did",
+						"description": "The DID of the repo."
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/vnd.ipld.car"
+			}
+		}
+	}
+}

lexicons/com/atproto/sync/getHead.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.sync.getHead",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "DEPRECATED - please use com.atproto.sync.getLatestCommit instead",
+			"parameters": {
+				"type": "params",
+				"required": ["did"],
+				"properties": {
+					"did": {
+						"type": "string",
+						"format": "did",
+						"description": "The DID of the repo."
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["root"],
+					"properties": {
+						"root": { "type": "string", "format": "cid" }
+					}
+				}
+			},
+			"errors": [{ "name": "HeadNotFound" }]
+		}
+	}
+}

lexicons/com/atproto/sync/getLatestCommit.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.sync.getLatestCommit",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get the current commit CID & revision of the specified repo. Does not require auth.",
+			"parameters": {
+				"type": "params",
+				"required": ["did"],
+				"properties": {
+					"did": {
+						"type": "string",
+						"format": "did",
+						"description": "The DID of the repo."
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["cid", "rev"],
+					"properties": {
+						"cid": { "type": "string", "format": "cid" },
+						"rev": { "type": "string" }
+					}
+				}
+			},
+			"errors": [
+				{ "name": "RepoNotFound" },
+				{ "name": "RepoTakendown" },
+				{ "name": "RepoSuspended" },
+				{ "name": "RepoDeactivated" }
+			]
+		}
+	}
+}

lexicons/com/atproto/sync/getRecord.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.sync.getRecord",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get data blocks needed to prove the existence or non-existence of record in the current version of repo. Does not require auth.",
+			"parameters": {
+				"type": "params",
+				"required": ["did", "collection", "rkey"],
+				"properties": {
+					"did": {
+						"type": "string",
+						"format": "did",
+						"description": "The DID of the repo."
+					},
+					"collection": { "type": "string", "format": "nsid" },
+					"rkey": { "type": "string", "description": "Record Key" },
+					"commit": {
+						"type": "string",
+						"format": "cid",
+						"description": "DEPRECATED: referenced a repo commit by CID, and retrieved record as of that commit"
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/vnd.ipld.car"
+			},
+			"errors": [
+				{ "name": "RecordNotFound" },
+				{ "name": "RepoNotFound" },
+				{ "name": "RepoTakendown" },
+				{ "name": "RepoSuspended" },
+				{ "name": "RepoDeactivated" }
+			]
+		}
+	}
+}

lexicons/com/atproto/sync/getRepo.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.sync.getRepo",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Download a repository export as CAR file. Optionally only a 'diff' since a previous revision. Does not require auth; implemented by PDS.",
+			"parameters": {
+				"type": "params",
+				"required": ["did"],
+				"properties": {
+					"did": {
+						"type": "string",
+						"format": "did",
+						"description": "The DID of the repo."
+					},
+					"since": {
+						"type": "string",
+						"description": "The revision ('rev') of the repo to create a diff from."
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/vnd.ipld.car"
+			},
+			"errors": [
+				{ "name": "RepoNotFound" },
+				{ "name": "RepoTakendown" },
+				{ "name": "RepoSuspended" },
+				{ "name": "RepoDeactivated" }
+			]
+		}
+	}
+}

lexicons/com/atproto/sync/getRepoStatus.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.sync.getRepoStatus",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get the hosting status for a repository, on this server. Expected to be implemented by PDS and Relay.",
+			"parameters": {
+				"type": "params",
+				"required": ["did"],
+				"properties": {
+					"did": {
+						"type": "string",
+						"format": "did",
+						"description": "The DID of the repo."
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["did", "active"],
+					"properties": {
+						"did": { "type": "string", "format": "did" },
+						"active": { "type": "boolean" },
+						"status": {
+							"type": "string",
+							"description": "If active=false, this optional field indicates a possible reason for why the account is not active. If active=false and no status is supplied, then the host makes no claim for why the repository is no longer being hosted.",
+							"knownValues": ["takendown", "suspended", "deactivated"]
+						},
+						"rev": {
+							"type": "string",
+							"description": "Optional field, the current rev of the repo, if active=true"
+						}
+					}
+				}
+			},
+			"errors": [{ "name": "RepoNotFound" }]
+		}
+	}
+}

lexicons/com/atproto/sync/listBlobs.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.sync.listBlobs",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "List blob CIDs for an account, since some repo revision. Does not require auth; implemented by PDS.",
+			"parameters": {
+				"type": "params",
+				"required": ["did"],
+				"properties": {
+					"did": {
+						"type": "string",
+						"format": "did",
+						"description": "The DID of the repo."
+					},
+					"since": {
+						"type": "string",
+						"description": "Optional revision of the repo to list blobs since."
+					},
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 1000,
+						"default": 500
+					},
+					"cursor": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["cids"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"cids": {
+							"type": "array",
+							"items": { "type": "string", "format": "cid" }
+						}
+					}
+				}
+			},
+			"errors": [
+				{ "name": "RepoNotFound" },
+				{ "name": "RepoTakendown" },
+				{ "name": "RepoSuspended" },
+				{ "name": "RepoDeactivated" }
+			]
+		}
+	}
+}

lexicons/com/atproto/sync/listRepos.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.sync.listRepos",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Enumerates all the DID, rev, and commit CID for all repos hosted by this service. Does not require auth; implemented by PDS and Relay.",
+			"parameters": {
+				"type": "params",
+				"properties": {
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 1000,
+						"default": 500
+					},
+					"cursor": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["repos"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"repos": {
+							"type": "array",
+							"items": { "type": "ref", "ref": "#repo" }
+						}
+					}
+				}
+			}
+		},
+		"repo": {
+			"type": "object",
+			"required": ["did", "head", "rev"],
+			"properties": {
+				"did": { "type": "string", "format": "did" },
+				"head": {
+					"type": "string",
+					"format": "cid",
+					"description": "Current repo commit CID"
+				},
+				"rev": { "type": "string" },
+				"active": { "type": "boolean" },
+				"status": {
+					"type": "string",
+					"description": "If active=false, this optional field indicates a possible reason for why the account is not active. If active=false and no status is supplied, then the host makes no claim for why the repository is no longer being hosted.",
+					"knownValues": ["takendown", "suspended", "deactivated"]
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/sync/notifyOfUpdate.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.sync.notifyOfUpdate",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Notify a crawling service of a recent update, and that crawling should resume. Intended use is after a gap between repo stream events caused the crawling service to disconnect. Does not require auth; implemented by Relay.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["hostname"],
+					"properties": {
+						"hostname": {
+							"type": "string",
+							"description": "Hostname of the current service (usually a PDS) that is notifying of update."
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/sync/requestCrawl.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.sync.requestCrawl",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Request a service to persistently crawl hosted repos. Expected use is new PDS instances declaring their existence to Relays. Does not require auth.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["hostname"],
+					"properties": {
+						"hostname": {
+							"type": "string",
+							"description": "Hostname of the current service (eg, PDS) that is requesting to be crawled."
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/sync/subscribeRepos.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.sync.subscribeRepos",
+	"defs": {
+		"main": {
+			"type": "subscription",
+			"description": "Repository event stream, aka Firehose endpoint. Outputs repo commits with diff data, and identity update events, for all repositories on the current server. See the atproto specifications for details around stream sequencing, repo versioning, CAR diff format, and more. Public and does not require auth; implemented by PDS and Relay.",
+			"parameters": {
+				"type": "params",
+				"properties": {
+					"cursor": {
+						"type": "integer",
+						"description": "The last known event seq number to backfill from."
+					}
+				}
+			},
+			"message": {
+				"schema": {
+					"type": "union",
+					"refs": ["#commit", "#identity", "#account", "#handle", "#migrate", "#tombstone", "#info"]
+				}
+			},
+			"errors": [
+				{ "name": "FutureCursor" },
+				{
+					"name": "ConsumerTooSlow",
+					"description": "If the consumer of the stream can not keep up with events, and a backlog gets too large, the server will drop the connection."
+				}
+			]
+		},
+		"commit": {
+			"type": "object",
+			"description": "Represents an update of repository state. Note that empty commits are allowed, which include no repo data changes, but an update to rev and signature.",
+			"required": [
+				"seq",
+				"rebase",
+				"tooBig",
+				"repo",
+				"commit",
+				"rev",
+				"since",
+				"blocks",
+				"ops",
+				"blobs",
+				"time"
+			],
+			"nullable": ["prev", "since"],
+			"properties": {
+				"seq": {
+					"type": "integer",
+					"description": "The stream sequence number of this message."
+				},
+				"rebase": { "type": "boolean", "description": "DEPRECATED -- unused" },
+				"tooBig": {
+					"type": "boolean",
+					"description": "Indicates that this commit contained too many ops, or data size was too large. Consumers will need to make a separate request to get missing data."
+				},
+				"repo": {
+					"type": "string",
+					"format": "did",
+					"description": "The repo this event comes from."
+				},
+				"commit": {
+					"type": "cid-link",
+					"description": "Repo commit object CID."
+				},
+				"prev": {
+					"type": "cid-link",
+					"description": "DEPRECATED -- unused. WARNING -- nullable and optional; stick with optional to ensure golang interoperability."
+				},
+				"rev": {
+					"type": "string",
+					"description": "The rev of the emitted commit. Note that this information is also in the commit object included in blocks, unless this is a tooBig event."
+				},
+				"since": {
+					"type": "string",
+					"description": "The rev of the last emitted commit from this repo (if any)."
+				},
+				"blocks": {
+					"type": "bytes",
+					"description": "CAR file containing relevant blocks, as a diff since the previous repo state.",
+					"maxLength": 1000000
+				},
+				"ops": {
+					"type": "array",
+					"items": {
+						"type": "ref",
+						"ref": "#repoOp",
+						"description": "List of repo mutation operations in this commit (eg, records created, updated, or deleted)."
+					},
+					"maxLength": 200
+				},
+				"blobs": {
+					"type": "array",
+					"items": {
+						"type": "cid-link",
+						"description": "List of new blobs (by CID) referenced by records in this commit."
+					}
+				},
+				"time": {
+					"type": "string",
+					"format": "datetime",
+					"description": "Timestamp of when this message was originally broadcast."
+				}
+			}
+		},
+		"identity": {
+			"type": "object",
+			"description": "Represents a change to an account's identity. Could be an updated handle, signing key, or pds hosting endpoint. Serves as a prod to all downstream services to refresh their identity cache.",
+			"required": ["seq", "did", "time"],
+			"properties": {
+				"seq": { "type": "integer" },
+				"did": { "type": "string", "format": "did" },
+				"time": { "type": "string", "format": "datetime" },
+				"handle": {
+					"type": "string",
+					"format": "handle",
+					"description": "The current handle for the account, or 'handle.invalid' if validation fails. This field is optional, might have been validated or passed-through from an upstream source. Semantics and behaviors for PDS vs Relay may evolve in the future; see atproto specs for more details."
+				}
+			}
+		},
+		"account": {
+			"type": "object",
+			"description": "Represents a change to an account's status on a host (eg, PDS or Relay). The semantics of this event are that the status is at the host which emitted the event, not necessarily that at the currently active PDS. Eg, a Relay takedown would emit a takedown with active=false, even if the PDS is still active.",
+			"required": ["seq", "did", "time", "active"],
+			"properties": {
+				"seq": { "type": "integer" },
+				"did": { "type": "string", "format": "did" },
+				"time": { "type": "string", "format": "datetime" },
+				"active": {
+					"type": "boolean",
+					"description": "Indicates that the account has a repository which can be fetched from the host that emitted this event."
+				},
+				"status": {
+					"type": "string",
+					"description": "If active=false, this optional field indicates a reason for why the account is not active.",
+					"knownValues": ["takendown", "suspended", "deleted", "deactivated"]
+				}
+			}
+		},
+		"handle": {
+			"type": "object",
+			"description": "DEPRECATED -- Use #identity event instead",
+			"required": ["seq", "did", "handle", "time"],
+			"properties": {
+				"seq": { "type": "integer" },
+				"did": { "type": "string", "format": "did" },
+				"handle": { "type": "string", "format": "handle" },
+				"time": { "type": "string", "format": "datetime" }
+			}
+		},
+		"migrate": {
+			"type": "object",
+			"description": "DEPRECATED -- Use #account event instead",
+			"required": ["seq", "did", "migrateTo", "time"],
+			"nullable": ["migrateTo"],
+			"properties": {
+				"seq": { "type": "integer" },
+				"did": { "type": "string", "format": "did" },
+				"migrateTo": { "type": "string" },
+				"time": { "type": "string", "format": "datetime" }
+			}
+		},
+		"tombstone": {
+			"type": "object",
+			"description": "DEPRECATED -- Use #account event instead",
+			"required": ["seq", "did", "time"],
+			"properties": {
+				"seq": { "type": "integer" },
+				"did": { "type": "string", "format": "did" },
+				"time": { "type": "string", "format": "datetime" }
+			}
+		},
+		"info": {
+			"type": "object",
+			"required": ["name"],
+			"properties": {
+				"name": {
+					"type": "string",
+					"knownValues": ["OutdatedCursor"]
+				},
+				"message": {
+					"type": "string"
+				}
+			}
+		},
+		"repoOp": {
+			"type": "object",
+			"description": "A repo operation, ie a mutation of a single record.",
+			"required": ["action", "path", "cid"],
+			"nullable": ["cid"],
+			"properties": {
+				"action": {
+					"type": "string",
+					"knownValues": ["create", "update", "delete"]
+				},
+				"path": { "type": "string" },
+				"cid": {
+					"type": "cid-link",
+					"description": "For creates and updates, the new record CID. For deletions, null."
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/temp/checkSignupQueue.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.temp.checkSignupQueue",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Check accounts location in signup queue.",
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["activated"],
+					"properties": {
+						"activated": { "type": "boolean" },
+						"placeInQueue": { "type": "integer" },
+						"estimatedTimeMs": { "type": "integer" }
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/temp/fetchLabels.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.temp.fetchLabels",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "DEPRECATED: use queryLabels or subscribeLabels instead -- Fetch all labels from a labeler created after a certain date.",
+			"parameters": {
+				"type": "params",
+				"properties": {
+					"since": { "type": "integer" },
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 250,
+						"default": 50
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["labels"],
+					"properties": {
+						"labels": {
+							"type": "array",
+							"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/com/atproto/temp/requestPhoneVerification.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.temp.requestPhoneVerification",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Request a verification code to be sent to the supplied phone number",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["phoneNumber"],
+					"properties": {
+						"phoneNumber": { "type": "string" }
+					}
+				}
+			}
+		}
+	}
+}

lexicons/tools/ozone/communication/createTemplate.json

···
+{
+	"lexicon": 1,
+	"id": "tools.ozone.communication.createTemplate",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Administrative action to create a new, re-usable communication (email for now) template.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["subject", "contentMarkdown", "name"],
+					"properties": {
+						"name": {
+							"type": "string",
+							"description": "Name of the template."
+						},
+						"contentMarkdown": {
+							"type": "string",
+							"description": "Content of the template, markdown supported, can contain variable placeholders."
+						},
+						"subject": {
+							"type": "string",
+							"description": "Subject of the message, used in emails."
+						},
+						"createdBy": {
+							"type": "string",
+							"format": "did",
+							"description": "DID of the user who is creating the template."
+						}
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "ref",
+					"ref": "tools.ozone.communication.defs#templateView"
+				}
+			}
+		}
+	}
+}

lexicons/tools/ozone/communication/defs.json

···
+{
+	"lexicon": 1,
+	"id": "tools.ozone.communication.defs",
+	"defs": {
+		"templateView": {
+			"type": "object",
+			"required": ["id", "name", "contentMarkdown", "disabled", "lastUpdatedBy", "createdAt", "updatedAt"],
+			"properties": {
+				"id": { "type": "string" },
+				"name": { "type": "string", "description": "Name of the template." },
+				"subject": {
+					"type": "string",
+					"description": "Content of the template, can contain markdown and variable placeholders."
+				},
+				"contentMarkdown": {
+					"type": "string",
+					"description": "Subject of the message, used in emails."
+				},
+				"disabled": { "type": "boolean" },
+				"lastUpdatedBy": {
+					"type": "string",
+					"format": "did",
+					"description": "DID of the user who last updated the template."
+				},
+				"createdAt": { "type": "string", "format": "datetime" },
+				"updatedAt": { "type": "string", "format": "datetime" }
+			}
+		}
+	}
+}

lexicons/tools/ozone/communication/deleteTemplate.json

···
+{
+	"lexicon": 1,
+	"id": "tools.ozone.communication.deleteTemplate",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Delete a communication template.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["id"],
+					"properties": {
+						"id": { "type": "string" }
+					}
+				}
+			}
+		}
+	}
+}

lexicons/tools/ozone/communication/listTemplates.json

···
+{
+	"lexicon": 1,
+	"id": "tools.ozone.communication.listTemplates",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get list of all communication templates.",
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["communicationTemplates"],
+					"properties": {
+						"communicationTemplates": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "tools.ozone.communication.defs#templateView"
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/tools/ozone/communication/updateTemplate.json

···
+{
+	"lexicon": 1,
+	"id": "tools.ozone.communication.updateTemplate",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Administrative action to update an existing communication template. Allows passing partial fields to patch specific fields only.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["id"],
+					"properties": {
+						"id": {
+							"type": "string",
+							"description": "ID of the template to be updated."
+						},
+						"name": {
+							"type": "string",
+							"description": "Name of the template."
+						},
+						"contentMarkdown": {
+							"type": "string",
+							"description": "Content of the template, markdown supported, can contain variable placeholders."
+						},
+						"subject": {
+							"type": "string",
+							"description": "Subject of the message, used in emails."
+						},
+						"updatedBy": {
+							"type": "string",
+							"format": "did",
+							"description": "DID of the user who is updating the template."
+						},
+						"disabled": {
+							"type": "boolean"
+						}
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "ref",
+					"ref": "tools.ozone.communication.defs#templateView"
+				}
+			}
+		}
+	}
+}

lexicons/tools/ozone/moderation/defs.json

···
+{
+	"lexicon": 1,
+	"id": "tools.ozone.moderation.defs",
+	"defs": {
+		"modEventView": {
+			"type": "object",
+			"required": ["id", "event", "subject", "subjectBlobCids", "createdBy", "createdAt"],
+			"properties": {
+				"id": { "type": "integer" },
+				"event": {
+					"type": "union",
+					"refs": [
+						"#modEventTakedown",
+						"#modEventReverseTakedown",
+						"#modEventComment",
+						"#modEventReport",
+						"#modEventLabel",
+						"#modEventAcknowledge",
+						"#modEventEscalate",
+						"#modEventMute",
+						"#modEventUnmute",
+						"#modEventMuteReporter",
+						"#modEventUnmuteReporter",
+						"#modEventEmail",
+						"#modEventResolveAppeal",
+						"#modEventDivert",
+						"#modEventTag"
+					]
+				},
+				"subject": {
+					"type": "union",
+					"refs": [
+						"com.atproto.admin.defs#repoRef",
+						"com.atproto.repo.strongRef",
+						"chat.bsky.convo.defs#messageRef"
+					]
+				},
+				"subjectBlobCids": { "type": "array", "items": { "type": "string" } },
+				"createdBy": { "type": "string", "format": "did" },
+				"createdAt": { "type": "string", "format": "datetime" },
+				"creatorHandle": { "type": "string" },
+				"subjectHandle": { "type": "string" }
+			}
+		},
+		"modEventViewDetail": {
+			"type": "object",
+			"required": ["id", "event", "subject", "subjectBlobs", "createdBy", "createdAt"],
+			"properties": {
+				"id": { "type": "integer" },
+				"event": {
+					"type": "union",
+					"refs": [
+						"#modEventTakedown",
+						"#modEventReverseTakedown",
+						"#modEventComment",
+						"#modEventReport",
+						"#modEventLabel",
+						"#modEventAcknowledge",
+						"#modEventEscalate",
+						"#modEventMute",
+						"#modEventUnmute",
+						"#modEventMuteReporter",
+						"#modEventUnmuteReporter",
+						"#modEventEmail",
+						"#modEventResolveAppeal",
+						"#modEventDivert",
+						"#modEventTag"
+					]
+				},
+				"subject": {
+					"type": "union",
+					"refs": ["#repoView", "#repoViewNotFound", "#recordView", "#recordViewNotFound"]
+				},
+				"subjectBlobs": {
+					"type": "array",
+					"items": { "type": "ref", "ref": "#blobView" }
+				},
+				"createdBy": { "type": "string", "format": "did" },
+				"createdAt": { "type": "string", "format": "datetime" }
+			}
+		},
+		"subjectStatusView": {
+			"type": "object",
+			"required": ["id", "subject", "createdAt", "updatedAt", "reviewState"],
+			"properties": {
+				"id": { "type": "integer" },
+				"subject": {
+					"type": "union",
+					"refs": ["com.atproto.admin.defs#repoRef", "com.atproto.repo.strongRef"]
+				},
+				"subjectBlobCids": {
+					"type": "array",
+					"items": { "type": "string", "format": "cid" }
+				},
+				"subjectRepoHandle": { "type": "string" },
+				"updatedAt": {
+					"type": "string",
+					"format": "datetime",
+					"description": "Timestamp referencing when the last update was made to the moderation status of the subject"
+				},
+				"createdAt": {
+					"type": "string",
+					"format": "datetime",
+					"description": "Timestamp referencing the first moderation status impacting event was emitted on the subject"
+				},
+				"reviewState": {
+					"type": "ref",
+					"ref": "#subjectReviewState"
+				},
+				"comment": {
+					"type": "string",
+					"description": "Sticky comment on the subject."
+				},
+				"muteUntil": {
+					"type": "string",
+					"format": "datetime"
+				},
+				"muteReportingUntil": {
+					"type": "string",
+					"format": "datetime"
+				},
+				"lastReviewedBy": {
+					"type": "string",
+					"format": "did"
+				},
+				"lastReviewedAt": {
+					"type": "string",
+					"format": "datetime"
+				},
+				"lastReportedAt": {
+					"type": "string",
+					"format": "datetime"
+				},
+				"lastAppealedAt": {
+					"type": "string",
+					"format": "datetime",
+					"description": "Timestamp referencing when the author of the subject appealed a moderation action"
+				},
+				"takendown": {
+					"type": "boolean"
+				},
+				"appealed": {
+					"type": "boolean",
+					"description": "True indicates that the a previously taken moderator action was appealed against, by the author of the content. False indicates last appeal was resolved by moderators."
+				},
+				"suspendUntil": {
+					"type": "string",
+					"format": "datetime"
+				},
+				"tags": {
+					"type": "array",
+					"items": { "type": "string" }
+				}
+			}
+		},
+		"subjectReviewState": {
+			"type": "string",
+			"knownValues": ["#reviewOpen", "#reviewEscalated", "#reviewClosed", "#reviewNone"]
+		},
+		"reviewOpen": {
+			"type": "token",
+			"description": "Moderator review status of a subject: Open. Indicates that the subject needs to be reviewed by a moderator"
+		},
+		"reviewEscalated": {
+			"type": "token",
+			"description": "Moderator review status of a subject: Escalated. Indicates that the subject was escalated for review by a moderator"
+		},
+		"reviewClosed": {
+			"type": "token",
+			"description": "Moderator review status of a subject: Closed. Indicates that the subject was already reviewed and resolved by a moderator"
+		},
+		"reviewNone": {
+			"type": "token",
+			"description": "Moderator review status of a subject: Unnecessary. Indicates that the subject does not need a review at the moment but there is probably some moderation related metadata available for it"
+		},
+		"modEventTakedown": {
+			"type": "object",
+			"description": "Take down a subject permanently or temporarily",
+			"properties": {
+				"comment": {
+					"type": "string"
+				},
+				"durationInHours": {
+					"type": "integer",
+					"description": "Indicates how long the takedown should be in effect before automatically expiring."
+				}
+			}
+		},
+		"modEventReverseTakedown": {
+			"type": "object",
+			"description": "Revert take down action on a subject",
+			"properties": {
+				"comment": {
+					"type": "string",
+					"description": "Describe reasoning behind the reversal."
+				}
+			}
+		},
+		"modEventResolveAppeal": {
+			"type": "object",
+			"description": "Resolve appeal on a subject",
+			"properties": {
+				"comment": {
+					"type": "string",
+					"description": "Describe resolution."
+				}
+			}
+		},
+		"modEventComment": {
+			"type": "object",
+			"description": "Add a comment to a subject",
+			"required": ["comment"],
+			"properties": {
+				"comment": {
+					"type": "string"
+				},
+				"sticky": {
+					"type": "boolean",
+					"description": "Make the comment persistent on the subject"
+				}
+			}
+		},
+		"modEventReport": {
+			"type": "object",
+			"description": "Report a subject",
+			"required": ["reportType"],
+			"properties": {
+				"comment": {
+					"type": "string"
+				},
+				"isReporterMuted": {
+					"type": "boolean",
+					"description": "Set to true if the reporter was muted from reporting at the time of the event. These reports won't impact the reviewState of the subject."
+				},
+				"reportType": {
+					"type": "ref",
+					"ref": "com.atproto.moderation.defs#reasonType"
+				}
+			}
+		},
+		"modEventLabel": {
+			"type": "object",
+			"description": "Apply/Negate labels on a subject",
+			"required": ["createLabelVals", "negateLabelVals"],
+			"properties": {
+				"comment": {
+					"type": "string"
+				},
+				"createLabelVals": {
+					"type": "array",
+					"items": { "type": "string" }
+				},
+				"negateLabelVals": {
+					"type": "array",
+					"items": { "type": "string" }
+				}
+			}
+		},
+		"modEventAcknowledge": {
+			"type": "object",
+			"properties": {
+				"comment": { "type": "string" }
+			}
+		},
+		"modEventEscalate": {
+			"type": "object",
+			"properties": {
+				"comment": { "type": "string" }
+			}
+		},
+		"modEventMute": {
+			"type": "object",
+			"description": "Mute incoming reports on a subject",
+			"required": ["durationInHours"],
+			"properties": {
+				"comment": { "type": "string" },
+				"durationInHours": {
+					"type": "integer",
+					"description": "Indicates how long the subject should remain muted."
+				}
+			}
+		},
+		"modEventUnmute": {
+			"type": "object",
+			"description": "Unmute action on a subject",
+			"properties": {
+				"comment": {
+					"type": "string",
+					"description": "Describe reasoning behind the reversal."
+				}
+			}
+		},
+		"modEventMuteReporter": {
+			"type": "object",
+			"description": "Mute incoming reports from an account",
+			"required": ["durationInHours"],
+			"properties": {
+				"comment": { "type": "string" },
+				"durationInHours": {
+					"type": "integer",
+					"description": "Indicates how long the account should remain muted."
+				}
+			}
+		},
+		"modEventUnmuteReporter": {
+			"type": "object",
+			"description": "Unmute incoming reports from an account",
+			"properties": {
+				"comment": {
+					"type": "string",
+					"description": "Describe reasoning behind the reversal."
+				}
+			}
+		},
+		"modEventEmail": {
+			"type": "object",
+			"description": "Keep a log of outgoing email to a user",
+			"required": ["subjectLine"],
+			"properties": {
+				"subjectLine": {
+					"type": "string",
+					"description": "The subject line of the email sent to the user."
+				},
+				"content": {
+					"type": "string",
+					"description": "The content of the email sent to the user."
+				},
+				"comment": {
+					"type": "string",
+					"description": "Additional comment about the outgoing comm."
+				}
+			}
+		},
+		"modEventDivert": {
+			"type": "object",
+			"description": "Divert a record's blobs to a 3rd party service for further scanning/tagging",
+			"properties": {
+				"comment": { "type": "string" }
+			}
+		},
+		"modEventTag": {
+			"type": "object",
+			"description": "Add/Remove a tag on a subject",
+			"required": ["add", "remove"],
+			"properties": {
+				"add": {
+					"type": "array",
+					"items": { "type": "string" },
+					"description": "Tags to be added to the subject. If already exists, won't be duplicated."
+				},
+				"remove": {
+					"type": "array",
+					"items": { "type": "string" },
+					"description": "Tags to be removed to the subject. Ignores a tag If it doesn't exist, won't be duplicated."
+				},
+				"comment": {
+					"type": "string",
+					"description": "Additional comment about added/removed tags."
+				}
+			}
+		},
+		"repoView": {
+			"type": "object",
+			"required": ["did", "handle", "relatedRecords", "indexedAt", "moderation"],
+			"properties": {
+				"did": { "type": "string", "format": "did" },
+				"handle": { "type": "string", "format": "handle" },
+				"email": { "type": "string" },
+				"relatedRecords": { "type": "array", "items": { "type": "unknown" } },
+				"indexedAt": { "type": "string", "format": "datetime" },
+				"moderation": { "type": "ref", "ref": "#moderation" },
+				"invitedBy": {
+					"type": "ref",
+					"ref": "com.atproto.server.defs#inviteCode"
+				},
+				"invitesDisabled": { "type": "boolean" },
+				"inviteNote": { "type": "string" },
+				"deactivatedAt": { "type": "string", "format": "datetime" }
+			}
+		},
+		"repoViewDetail": {
+			"type": "object",
+			"required": ["did", "handle", "relatedRecords", "indexedAt", "moderation"],
+			"properties": {
+				"did": { "type": "string", "format": "did" },
+				"handle": { "type": "string", "format": "handle" },
+				"email": { "type": "string" },
+				"relatedRecords": { "type": "array", "items": { "type": "unknown" } },
+				"indexedAt": { "type": "string", "format": "datetime" },
+				"moderation": { "type": "ref", "ref": "#moderationDetail" },
+				"labels": {
+					"type": "array",
+					"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+				},
+				"invitedBy": {
+					"type": "ref",
+					"ref": "com.atproto.server.defs#inviteCode"
+				},
+				"invites": {
+					"type": "array",
+					"items": {
+						"type": "ref",
+						"ref": "com.atproto.server.defs#inviteCode"
+					}
+				},
+				"invitesDisabled": { "type": "boolean" },
+				"inviteNote": { "type": "string" },
+				"emailConfirmedAt": { "type": "string", "format": "datetime" },
+				"deactivatedAt": { "type": "string", "format": "datetime" }
+			}
+		},
+		"repoViewNotFound": {
+			"type": "object",
+			"required": ["did"],
+			"properties": {
+				"did": { "type": "string", "format": "did" }
+			}
+		},
+		"recordView": {
+			"type": "object",
+			"required": ["uri", "cid", "value", "blobCids", "indexedAt", "moderation", "repo"],
+			"properties": {
+				"uri": { "type": "string", "format": "at-uri" },
+				"cid": { "type": "string", "format": "cid" },
+				"value": { "type": "unknown" },
+				"blobCids": {
+					"type": "array",
+					"items": { "type": "string", "format": "cid" }
+				},
+				"indexedAt": { "type": "string", "format": "datetime" },
+				"moderation": { "type": "ref", "ref": "#moderation" },
+				"repo": { "type": "ref", "ref": "#repoView" }
+			}
+		},
+		"recordViewDetail": {
+			"type": "object",
+			"required": ["uri", "cid", "value", "blobs", "indexedAt", "moderation", "repo"],
+			"properties": {
+				"uri": { "type": "string", "format": "at-uri" },
+				"cid": { "type": "string", "format": "cid" },
+				"value": { "type": "unknown" },
+				"blobs": {
+					"type": "array",
+					"items": { "type": "ref", "ref": "#blobView" }
+				},
+				"labels": {
+					"type": "array",
+					"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+				},
+				"indexedAt": { "type": "string", "format": "datetime" },
+				"moderation": { "type": "ref", "ref": "#moderationDetail" },
+				"repo": { "type": "ref", "ref": "#repoView" }
+			}
+		},
+		"recordViewNotFound": {
+			"type": "object",
+			"required": ["uri"],
+			"properties": {
+				"uri": { "type": "string", "format": "at-uri" }
+			}
+		},
+		"moderation": {
+			"type": "object",
+			"properties": {
+				"subjectStatus": { "type": "ref", "ref": "#subjectStatusView" }
+			}
+		},
+		"moderationDetail": {
+			"type": "object",
+			"properties": {
+				"subjectStatus": {
+					"type": "ref",
+					"ref": "#subjectStatusView"
+				}
+			}
+		},
+		"blobView": {
+			"type": "object",
+			"required": ["cid", "mimeType", "size", "createdAt"],
+			"properties": {
+				"cid": { "type": "string", "format": "cid" },
+				"mimeType": { "type": "string" },
+				"size": { "type": "integer" },
+				"createdAt": { "type": "string", "format": "datetime" },
+				"details": {
+					"type": "union",
+					"refs": ["#imageDetails", "#videoDetails"]
+				},
+				"moderation": { "type": "ref", "ref": "#moderation" }
+			}
+		},
+		"imageDetails": {
+			"type": "object",
+			"required": ["width", "height"],
+			"properties": {
+				"width": { "type": "integer" },
+				"height": { "type": "integer" }
+			}
+		},
+		"videoDetails": {
+			"type": "object",
+			"required": ["width", "height", "length"],
+			"properties": {
+				"width": { "type": "integer" },
+				"height": { "type": "integer" },
+				"length": { "type": "integer" }
+			}
+		}
+	}
+}

lexicons/tools/ozone/moderation/emitEvent.json

···
+{
+	"lexicon": 1,
+	"id": "tools.ozone.moderation.emitEvent",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Take a moderation action on an actor.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["event", "subject", "createdBy"],
+					"properties": {
+						"event": {
+							"type": "union",
+							"refs": [
+								"tools.ozone.moderation.defs#modEventTakedown",
+								"tools.ozone.moderation.defs#modEventAcknowledge",
+								"tools.ozone.moderation.defs#modEventEscalate",
+								"tools.ozone.moderation.defs#modEventComment",
+								"tools.ozone.moderation.defs#modEventLabel",
+								"tools.ozone.moderation.defs#modEventReport",
+								"tools.ozone.moderation.defs#modEventMute",
+								"tools.ozone.moderation.defs#modEventUnmute",
+								"tools.ozone.moderation.defs#modEventMuteReporter",
+								"tools.ozone.moderation.defs#modEventUnmuteReporter",
+								"tools.ozone.moderation.defs#modEventReverseTakedown",
+								"tools.ozone.moderation.defs#modEventEmail",
+								"tools.ozone.moderation.defs#modEventTag"
+							]
+						},
+						"subject": {
+							"type": "union",
+							"refs": ["com.atproto.admin.defs#repoRef", "com.atproto.repo.strongRef"]
+						},
+						"subjectBlobCids": {
+							"type": "array",
+							"items": { "type": "string", "format": "cid" }
+						},
+						"createdBy": { "type": "string", "format": "did" }
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "ref",
+					"ref": "tools.ozone.moderation.defs#modEventView"
+				}
+			},
+			"errors": [{ "name": "SubjectHasAction" }]
+		}
+	}
+}

lexicons/tools/ozone/moderation/getEvent.json

···
+{
+	"lexicon": 1,
+	"id": "tools.ozone.moderation.getEvent",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get details about a moderation event.",
+			"parameters": {
+				"type": "params",
+				"required": ["id"],
+				"properties": {
+					"id": { "type": "integer" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "ref",
+					"ref": "tools.ozone.moderation.defs#modEventViewDetail"
+				}
+			}
+		}
+	}
+}

lexicons/tools/ozone/moderation/getRecord.json

···
+{
+	"lexicon": 1,
+	"id": "tools.ozone.moderation.getRecord",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get details about a record.",
+			"parameters": {
+				"type": "params",
+				"required": ["uri"],
+				"properties": {
+					"uri": { "type": "string", "format": "at-uri" },
+					"cid": { "type": "string", "format": "cid" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "ref",
+					"ref": "tools.ozone.moderation.defs#recordViewDetail"
+				}
+			},
+			"errors": [{ "name": "RecordNotFound" }]
+		}
+	}
+}

lexicons/tools/ozone/moderation/getRepo.json

···
+{
+	"lexicon": 1,
+	"id": "tools.ozone.moderation.getRepo",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get details about a repository.",
+			"parameters": {
+				"type": "params",
+				"required": ["did"],
+				"properties": {
+					"did": { "type": "string", "format": "did" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "ref",
+					"ref": "tools.ozone.moderation.defs#repoViewDetail"
+				}
+			},
+			"errors": [{ "name": "RepoNotFound" }]
+		}
+	}
+}

lexicons/tools/ozone/moderation/queryEvents.json

···
+{
+	"lexicon": 1,
+	"id": "tools.ozone.moderation.queryEvents",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "List moderation events related to a subject.",
+			"parameters": {
+				"type": "params",
+				"properties": {
+					"types": {
+						"type": "array",
+						"items": { "type": "string" },
+						"description": "The types of events (fully qualified string in the format of tools.ozone.moderation.defs#modEvent<name>) to filter by. If not specified, all events are returned."
+					},
+					"createdBy": {
+						"type": "string",
+						"format": "did"
+					},
+					"sortDirection": {
+						"type": "string",
+						"default": "desc",
+						"enum": ["asc", "desc"],
+						"description": "Sort direction for the events. Defaults to descending order of created at timestamp."
+					},
+					"createdAfter": {
+						"type": "string",
+						"format": "datetime",
+						"description": "Retrieve events created after a given timestamp"
+					},
+					"createdBefore": {
+						"type": "string",
+						"format": "datetime",
+						"description": "Retrieve events created before a given timestamp"
+					},
+					"subject": { "type": "string", "format": "uri" },
+					"includeAllUserRecords": {
+						"type": "boolean",
+						"default": false,
+						"description": "If true, events on all record types (posts, lists, profile etc.) owned by the did are returned"
+					},
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 50
+					},
+					"hasComment": {
+						"type": "boolean",
+						"description": "If true, only events with comments are returned"
+					},
+					"comment": {
+						"type": "string",
+						"description": "If specified, only events with comments containing the keyword are returned"
+					},
+					"addedLabels": {
+						"type": "array",
+						"items": { "type": "string" },
+						"description": "If specified, only events where all of these labels were added are returned"
+					},
+					"removedLabels": {
+						"type": "array",
+						"items": { "type": "string" },
+						"description": "If specified, only events where all of these labels were removed are returned"
+					},
+					"addedTags": {
+						"type": "array",
+						"items": { "type": "string" },
+						"description": "If specified, only events where all of these tags were added are returned"
+					},
+					"removedTags": {
+						"type": "array",
+						"items": { "type": "string" },
+						"description": "If specified, only events where all of these tags were removed are returned"
+					},
+					"reportTypes": {
+						"type": "array",
+						"items": {
+							"type": "string"
+						}
+					},
+					"cursor": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["events"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"events": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "tools.ozone.moderation.defs#modEventView"
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/tools/ozone/moderation/queryStatuses.json

···
+{
+	"lexicon": 1,
+	"id": "tools.ozone.moderation.queryStatuses",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "View moderation statuses of subjects (record or repo).",
+			"parameters": {
+				"type": "params",
+				"properties": {
+					"subject": { "type": "string", "format": "uri" },
+					"comment": {
+						"type": "string",
+						"description": "Search subjects by keyword from comments"
+					},
+					"reportedAfter": {
+						"type": "string",
+						"format": "datetime",
+						"description": "Search subjects reported after a given timestamp"
+					},
+					"reportedBefore": {
+						"type": "string",
+						"format": "datetime",
+						"description": "Search subjects reported before a given timestamp"
+					},
+					"reviewedAfter": {
+						"type": "string",
+						"format": "datetime",
+						"description": "Search subjects reviewed after a given timestamp"
+					},
+					"reviewedBefore": {
+						"type": "string",
+						"format": "datetime",
+						"description": "Search subjects reviewed before a given timestamp"
+					},
+					"includeMuted": {
+						"type": "boolean",
+						"description": "By default, we don't include muted subjects in the results. Set this to true to include them."
+					},
+					"onlyMuted": {
+						"type": "boolean",
+						"description": "When set to true, only muted subjects and reporters will be returned."
+					},
+					"reviewState": {
+						"type": "string",
+						"description": "Specify when fetching subjects in a certain state"
+					},
+					"ignoreSubjects": {
+						"type": "array",
+						"items": { "type": "string", "format": "uri" }
+					},
+					"lastReviewedBy": {
+						"type": "string",
+						"format": "did",
+						"description": "Get all subject statuses that were reviewed by a specific moderator"
+					},
+					"sortField": {
+						"type": "string",
+						"default": "lastReportedAt",
+						"enum": ["lastReviewedAt", "lastReportedAt"]
+					},
+					"sortDirection": {
+						"type": "string",
+						"default": "desc",
+						"enum": ["asc", "desc"]
+					},
+					"takendown": {
+						"type": "boolean",
+						"description": "Get subjects that were taken down"
+					},
+					"appealed": {
+						"type": "boolean",
+						"description": "Get subjects in unresolved appealed status"
+					},
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 50
+					},
+					"tags": {
+						"type": "array",
+						"items": { "type": "string" }
+					},
+					"excludeTags": {
+						"type": "array",
+						"items": { "type": "string" }
+					},
+					"cursor": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["subjectStatuses"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"subjectStatuses": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "tools.ozone.moderation.defs#subjectStatusView"
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/tools/ozone/moderation/searchRepos.json

···
+{
+	"lexicon": 1,
+	"id": "tools.ozone.moderation.searchRepos",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Find repositories based on a search term.",
+			"parameters": {
+				"type": "params",
+				"properties": {
+					"term": {
+						"type": "string",
+						"description": "DEPRECATED: use 'q' instead"
+					},
+					"q": { "type": "string" },
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 50
+					},
+					"cursor": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["repos"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"repos": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "tools.ozone.moderation.defs#repoView"
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/tools/ozone/server/getConfig.json

···
+{
+	"lexicon": 1,
+	"id": "tools.ozone.server.getConfig",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get details about ozone's server configuration.",
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"properties": {
+						"appview": {
+							"type": "ref",
+							"ref": "#serviceConfig"
+						},
+						"pds": {
+							"type": "ref",
+							"ref": "#serviceConfig"
+						},
+						"blobDivert": {
+							"type": "ref",
+							"ref": "#serviceConfig"
+						},
+						"chat": {
+							"type": "ref",
+							"ref": "#serviceConfig"
+						},
+						"viewer": {
+							"type": "ref",
+							"ref": "#viewerConfig"
+						}
+					}
+				}
+			}
+		},
+		"serviceConfig": {
+			"type": "object",
+			"properties": {
+				"url": {
+					"type": "string",
+					"format": "uri"
+				}
+			}
+		},
+		"viewerConfig": {
+			"type": "object",
+			"properties": {
+				"role": {
+					"type": "string",
+					"knownValues": [
+						"tools.ozone.team.defs#roleAdmin",
+						"tools.ozone.team.defs#roleModerator",
+						"tools.ozone.team.defs#roleTriage"
+					]
+				}
+			}
+		}
+	}
+}

lexicons/tools/ozone/team/addMember.json

···
+{
+	"lexicon": 1,
+	"id": "tools.ozone.team.addMember",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Add a member to the ozone team. Requires admin role.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["did", "role"],
+					"properties": {
+						"did": { "type": "string", "format": "did" },
+						"role": {
+							"type": "string",
+							"knownValues": [
+								"tools.ozone.team.defs#roleAdmin",
+								"tools.ozone.team.defs#roleModerator",
+								"tools.ozone.team.defs#roleTriage"
+							]
+						}
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "ref",
+					"ref": "tools.ozone.team.defs#member"
+				}
+			},
+			"errors": [
+				{
+					"name": "MemberAlreadyExists",
+					"description": "Member already exists in the team."
+				}
+			]
+		}
+	}
+}

lexicons/tools/ozone/team/defs.json

···
+{
+	"lexicon": 1,
+	"id": "tools.ozone.team.defs",
+	"defs": {
+		"member": {
+			"type": "object",
+			"required": ["did", "role"],
+			"properties": {
+				"did": { "type": "string", "format": "did" },
+				"disabled": { "type": "boolean" },
+				"profile": {
+					"type": "ref",
+					"ref": "app.bsky.actor.defs#profileViewDetailed"
+				},
+				"createdAt": { "type": "string", "format": "datetime" },
+				"updatedAt": { "type": "string", "format": "datetime" },
+				"lastUpdatedBy": { "type": "string" },
+				"role": {
+					"type": "string",
+					"knownValues": ["#roleAdmin", "#roleModerator", "#roleTriage"]
+				}
+			}
+		},
+		"roleAdmin": {
+			"type": "token",
+			"description": "Admin role. Highest level of access, can perform all actions."
+		},
+		"roleModerator": {
+			"type": "token",
+			"description": "Moderator role. Can perform most actions."
+		},
+		"roleTriage": {
+			"type": "token",
+			"description": "Triage role. Mostly intended for monitoring and escalating issues."
+		}
+	}
+}

lexicons/tools/ozone/team/deleteMember.json

···
+{
+	"lexicon": 1,
+	"id": "tools.ozone.team.deleteMember",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Delete a member from ozone team. Requires admin role.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["did"],
+					"properties": {
+						"did": { "type": "string", "format": "did" }
+					}
+				}
+			},
+			"errors": [
+				{
+					"name": "MemberNotFound",
+					"description": "The member being deleted does not exist"
+				},
+				{
+					"name": "CannotDeleteSelf",
+					"description": "You can not delete yourself from the team"
+				}
+			]
+		}
+	}
+}

lexicons/tools/ozone/team/listMembers.json

···
+{
+	"lexicon": 1,
+	"id": "tools.ozone.team.listMembers",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "List all members with access to the ozone service.",
+			"parameters": {
+				"type": "params",
+				"properties": {
+					"limit": {
+						"type": "integer",
+						"minimum": 1,
+						"maximum": 100,
+						"default": 50
+					},
+					"cursor": { "type": "string" }
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["members"],
+					"properties": {
+						"cursor": { "type": "string" },
+						"members": {
+							"type": "array",
+							"items": {
+								"type": "ref",
+								"ref": "tools.ozone.team.defs#member"
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

lexicons/tools/ozone/team/updateMember.json

···
+{
+	"lexicon": 1,
+	"id": "tools.ozone.team.updateMember",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Update a member in the ozone service. Requires admin role.",
+			"input": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["did"],
+					"properties": {
+						"did": { "type": "string", "format": "did" },
+						"disabled": { "type": "boolean" },
+						"role": {
+							"type": "string",
+							"knownValues": [
+								"tools.ozone.team.defs#roleAdmin",
+								"tools.ozone.team.defs#roleModerator",
+								"tools.ozone.team.defs#roleTriage"
+							]
+						}
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "ref",
+					"ref": "tools.ozone.team.defs#member"
+				}
+			},
+			"errors": [
+				{
+					"name": "MemberNotFound",
+					"description": "The member being updated does not exist in the team"
+				}
+			]
+		}
+	}
+}

package.json

···
+{
+	"type": "module",
+	"scripts": {
+		"pull": "node ./scripts/pull-lexicons.js",
+		"fmt": "prettier --cache --write ."
+	},
+	"devDependencies": {
+		"@mary/tar": "npm:@jsr/mary__tar@^0.2.4",
+		"prettier": "^3.3.3",
+		"typescript": "5.6.0-beta"
+	}
+}

packages/client/lib/index.ts

···
+/**
+ * @module
+ * Handles the actual XRPC client functionalities.
+ */
+
+import type { At, Procedures, Queries } from './lexicons.ts';
+
+export type Headers = Record<string, string>;
+
+/** Possible response status from an XRPC service, status <100 is used for the library itself. */
+export const enum ResponseType {
+	/** Unknown error from the library */
+	Unknown = 1,
+	/** The server returned an invalid response */
+	InvalidResponse = 2,
+
+	/** Successful response from the service */
+	Success = 200,
+	/** Request was considered invalid by the service */
+	InvalidRequest = 400,
+	/** Service requires an authentication token */
+	AuthRequired = 401,
+	/** Request is forbidden by the service */
+	Forbidden = 403,
+	/** Not a XRPC service */
+	XRPCNotSupported = 404,
+	/** Payload is considered too large by the service */
+	PayloadTooLarge = 413,
+	/** Ratelimit was exceeded */
+	RateLimitExceeded = 429,
+	/** Internal server error */
+	InternalServerError = 500,
+	/** Method hasn't been implemented */
+	MethodNotImplemented = 501,
+	/** Failure by an upstream service */
+	UpstreamFailure = 502,
+	/** Not enough resources */
+	NotEnoughResouces = 503,
+	/** Timeout from upstream service */
+	UpstreamTimeout = 504,
+}
+
+/** XRPC response status which are recoverable (network error) */
+export const RECOVERABLE_RESPONSE_STATUS: number[] = [1, 408, 425, 429, 500, 502, 503, 504, 522, 524];
+
+/** Request type, either query (GET) or procedure (POST) */
+export type RequestType = 'get' | 'post';
+
+/** XRPC that gets passed around middlewares and eventually to the service. */
+export interface XRPCRequest {
+	service: string;
+	type: RequestType;
+	nsid: string;
+	headers: Headers;
+	params: Record<string, unknown>;
+	encoding?: string;
+	data?: FormData | Blob | ArrayBufferView | Record<string, unknown>;
+	signal?: AbortSignal;
+}
+
+/** Response from XRPC service */
+export interface XRPCResponse<T = any> {
+	data: T;
+	headers: Headers;
+}
+
+/** Options for constructing an XRPC error */
+export interface XRPCErrorOptions {
+	kind?: string;
+	message?: string;
+	headers?: Headers;
+	cause?: unknown;
+}
+
+/** Error coming from the XRPC service */
+export class XRPCError extends Error {
+	override name = 'XRPCError';
+
+	/** Response status */
+	status: number;
+	/** Response headers */
+	headers: Headers;
+	/** Error kind */
+	kind?: string;
+
+	constructor(status: number, { kind, message, headers, cause }: XRPCErrorOptions = {}) {
+		super(message || `Unspecified error message`, { cause });
+
+		this.status = status;
+		this.kind = kind;
+		this.headers = headers || {};
+	}
+}
+
+/** Response returned from middlewares and XRPC service */
+export interface XRPCFetchReturn {
+	status: number;
+	headers: Headers;
+	body: unknown;
+}
+
+/** Fetch function */
+export type XRPCFetch = (req: XRPCRequest) => Promise<XRPCFetchReturn>;
+/** Function that constructs a middleware */
+export type XRPCHook = (next: XRPCFetch) => XRPCFetch;
+
+/** Options for constructing an XRPC class */
+export interface XRPCOptions {
+	service: string;
+}
+
+/** Base options for the query/procedure request */
+interface BaseRPCOptions {
+	/** `Content-Type` encoding for the input, defaults to `application/json` if passing a JSON object */
+	encoding?: string;
+	/** Request headers to make */
+	headers?: Headers;
+	/** Signal for aborting the request */
+	signal?: AbortSignal;
+}
+
+/** Options for the query/procedure request */
+export type RPCOptions<T> = BaseRPCOptions &
+	(T extends { params: any } ? { params: T['params'] } : {}) &
+	(T extends { input: any } ? { data: T['input'] } : {});
+
+type OutputOf<T> = T extends { output: any } ? T['output'] : never;
+type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+
+/** The client that sends out requests. */
+export class XRPC {
+	/** The service it should connect to */
+	service: string;
+	/** XRPC fetch handler */
+	fetch: XRPCFetch = fetchHandler;
+
+	constructor(options: XRPCOptions) {
+		this.service = options.service;
+	}
+
+	/**
+	 * Adds a hook to intercept XRPC requests.
+	 * Hooks are executed from last-registered to first-registered
+	 * @param fn Hook function
+	 */
+	hook(fn: XRPCHook) {
+		this.fetch = fn(this.fetch);
+	}
+
+	/**
+	 * Makes a query (GET) request
+	 * @param nsid Namespace ID of a query endpoint
+	 * @param options Options to include like parameters
+	 * @returns The response of the request
+	 */
+	get<K extends keyof Queries>(
+		nsid: K,
+		options: RPCOptions<Queries[K]>,
+	): Promise<XRPCResponse<OutputOf<Queries[K]>>> {
+		return this.#call({ type: 'get', nsid: nsid as any, ...(options as any) });
+	}
+
+	/**
+	 * Makes a procedure (POST) request
+	 * @param nsid Namespace ID of a procedure endpoint
+	 * @param options Options to include like input body or parameters
+	 * @returns The response of the request
+	 */
+	call<K extends keyof Procedures>(
+		nsid: K,
+		options: RPCOptions<Procedures[K]>,
+	): Promise<XRPCResponse<OutputOf<Procedures[K]>>> {
+		return this.#call({ type: 'post', nsid: nsid as any, ...(options as any) });
+	}
+
+	async #call(request: PartialBy<Omit<XRPCRequest, 'service'>, 'headers' | 'params'>): Promise<XRPCResponse> {
+		const { status, headers, body } = await this.fetch({
+			...request,
+			service: this.service,
+			headers: request.headers === undefined ? {} : request.headers,
+			params: request.params === undefined ? {} : request.params,
+		});
+
+		if (status === ResponseType.Success) {
+			return { data: body, headers: headers };
+		} else if (isErrorResponse(body)) {
+			throw new XRPCError(status, { kind: body.error, message: body.message, headers });
+		} else {
+			throw new XRPCError(status, { headers });
+		}
+	}
+}
+
+/**
+ * Clones an XRPC instance
+ * @param rpc Base instance
+ * @returns The cloned instance
+ */
+export const clone = (rpc: XRPC): XRPC => {
+	const cloned = new XRPC({ service: rpc.service });
+	cloned.fetch = rpc.fetch;
+
+	return cloned;
+};
+
+/**
+ * Clones an existing XRPC instance, with a proxy on top.
+ * @param rpc Base instance
+ * @param opts Proxying options
+ * @returns Cloned instance with a proxy added
+ */
+export const withProxy = (rpc: XRPC, opts: ProxyOptions): XRPC => {
+	const cloned = clone(rpc);
+
+	cloned.hook((next) => (request) => {
+		return next({
+			...request,
+			headers: {
+				...request.headers,
+				'atproto-proxy': `${opts.service}#${opts.type}`,
+			},
+		});
+	});
+
+	return cloned;
+};
+
+/** Known endpoint types for proxying */
+export type ProxyType = 'atproto_labeler' | 'bsky_fg';
+
+/** Options for proxying a request */
+export interface ProxyOptions {
+	/** Service it should proxy requests to */
+	service: At.DID;
+	/** The endpoint to connect */
+	type: ProxyType | (string & {});
+}
+
+/** Default fetch handler */
+export const fetchHandler: XRPCFetch = async ({
+	service,
+	type,
+	nsid,
+	headers,
+	params,
+	encoding,
+	data: input,
+	signal,
+}) => {
+	const uri = new URL(`/xrpc/${nsid}`, service);
+	const searchParams = uri.searchParams;
+
+	for (const key in params) {
+		const value = params[key];
+
+		if (value !== undefined) {
+			if (Array.isArray(value)) {
+				for (let idx = 0, len = value.length; idx < len; idx++) {
+					const val = value[idx];
+					searchParams.append(key, val);
+				}
+			} else {
+				searchParams.set(key, value as any);
+			}
+		}
+	}
+
+	const isProcedure = type === 'post';
+	const isJson =
+		typeof input === 'object' &&
+		!(input instanceof FormData || input instanceof Blob || ArrayBuffer.isView(input));
+
+	const response = await fetch(uri, {
+		signal: signal,
+		method: isProcedure ? 'POST' : 'GET',
+		headers: encoding || isJson ? { ...headers, 'Content-Type': encoding || 'application/json' } : headers,
+		body: isJson ? JSON.stringify(input) : (input as FormData | Blob | ArrayBufferView | undefined),
+	});
+
+	const responseHeaders = response.headers;
+	const responseType = responseHeaders.get('Content-Type');
+
+	let promise: Promise<unknown> | undefined;
+	let data: unknown;
+
+	if (responseType) {
+		if (responseType.startsWith('application/json')) {
+			promise = response.json();
+		} else if (responseType.startsWith('text/')) {
+			promise = response.text();
+		}
+	}
+
+	try {
+		data = await (promise || response.arrayBuffer().then((buffer) => new Uint8Array(buffer)));
+	} catch (err) {
+		throw new XRPCError(ResponseType.InvalidResponse, {
+			cause: err,
+			message: `Failed to parse response body`,
+		});
+	}
+
+	return {
+		status: response.status,
+		headers: Object.fromEntries(responseHeaders),
+		body: data,
+	};
+};
+
+/**
+ * Check if provided value is an error object
+ * @param value Response value
+ * @param names If provided, also checks if the error name matches what you expect
+ * @returns A boolean on the check
+ */
+export const isErrorResponse = (value: any, names?: string[]): value is ErrorResponseBody => {
+	if (typeof value !== 'object' || !value) {
+		return false;
+	}
+
+	const kindType = typeof value.error;
+	const messageType = typeof value.message;
+
+	return (
+		(kindType === 'undefined' || kindType === 'string') &&
+		(messageType === 'undefined' || messageType === 'string') &&
+		(!names || names.includes(value.error))
+	);
+};
+
+/** Response body from a thrown query/procedure */
+export interface ErrorResponseBody {
+	error?: string;
+	message?: string;
+}

packages/client/lib/lexicons.ts

···
+/* eslint-disable */
+// This file is automatically generated, do not edit!
+
+/**
+ * @module
+ * Contains type declarations for AT Protocol lexicons
+ */
+
+type ObjectOmit<T, K extends keyof any> = Omit<T, K>;
+
+/** Handles type branding in objects */
+export declare namespace Brand {
+	/** Symbol used to brand objects, this does not actually exist in runtime */
+	const Type: unique symbol;
+
+	/** Get the intended `$type` field */
+	type GetType<T extends { [Type]?: string }> = NonNullable<T[typeof Type]>;
+
+	/** Creates a union of objects where it's discriminated by `$type` field. */
+	type Union<T extends { [Type]?: string }> = T extends any ? T & { $type: GetType<T> } : never;
+
+	/** Omits the type branding from object */
+	type Omit<T extends { [Type]?: string }> = ObjectOmit<T, typeof Type>;
+}
+
+/** Base AT Protocol schema types */
+export declare namespace At {
+	/** CID string */
+	type CID = string;
+
+	/** DID of a user */
+	type DID = `did:${string}`;
+
+	/** User handle */
+	type Handle = string;
+
+	/** URI string */
+	type Uri = string;
+
+	/** Object containing a CID string */
+	interface CIDLink {
+		$link: CID;
+	}
+
+	/** Object containing a base64-encoded bytes */
+	interface Bytes {
+		$bytes: string;
+	}
+
+	/** Blob interface */
+	interface Blob<T extends string = string> {
+		$type: 'blob';
+		mimeType: T;
+		ref: {
+			$link: string;
+		};
+		size: number;
+	}
+}
+export declare namespace ComAtprotoAdminDefs {
+	interface AccountView {
+		[Brand.Type]?: 'com.atproto.admin.defs#accountView';
+		did: At.DID;
+		handle: At.Handle;
+		indexedAt: string;
+		deactivatedAt?: string;
+		email?: string;
+		emailConfirmedAt?: string;
+		invitedBy?: ComAtprotoServerDefs.InviteCode;
+		inviteNote?: string;
+		invites?: ComAtprotoServerDefs.InviteCode[];
+		invitesDisabled?: boolean;
+		relatedRecords?: unknown[];
+	}
+	interface RepoBlobRef {
+		[Brand.Type]?: 'com.atproto.admin.defs#repoBlobRef';
+		cid: At.CID;
+		did: At.DID;
+		recordUri?: At.Uri;
+	}
+	interface RepoRef {
+		[Brand.Type]?: 'com.atproto.admin.defs#repoRef';
+		did: At.DID;
+	}
+	interface StatusAttr {
+		[Brand.Type]?: 'com.atproto.admin.defs#statusAttr';
+		applied: boolean;
+		ref?: string;
+	}
+}
+
+/** Delete a user account as an administrator. */
+export declare namespace ComAtprotoAdminDeleteAccount {
+	interface Params {}
+	interface Input {
+		did: At.DID;
+	}
+	type Output = undefined;
+}
+
+/** Disable an account from receiving new invite codes, but does not invalidate existing codes. */
+export declare namespace ComAtprotoAdminDisableAccountInvites {
+	interface Params {}
+	interface Input {
+		account: At.DID;
+		/** Optional reason for disabled invites. */
+		note?: string;
+	}
+	type Output = undefined;
+}
+
+/** Disable some set of codes and/or all codes associated with a set of users. */
+export declare namespace ComAtprotoAdminDisableInviteCodes {
+	interface Params {}
+	interface Input {
+		accounts?: string[];
+		codes?: string[];
+	}
+	type Output = undefined;
+}
+
+/** Re-enable an account's ability to receive invite codes. */
+export declare namespace ComAtprotoAdminEnableAccountInvites {
+	interface Params {}
+	interface Input {
+		account: At.DID;
+		/** Optional reason for enabled invites. */
+		note?: string;
+	}
+	type Output = undefined;
+}
+
+/** Get details about an account. */
+export declare namespace ComAtprotoAdminGetAccountInfo {
+	interface Params {
+		did: At.DID;
+	}
+	type Input = undefined;
+	type Output = ComAtprotoAdminDefs.AccountView;
+}
+
+/** Get details about some accounts. */
+export declare namespace ComAtprotoAdminGetAccountInfos {
+	interface Params {
+		dids: At.DID[];
+	}
+	type Input = undefined;
+	interface Output {
+		infos: ComAtprotoAdminDefs.AccountView[];
+	}
+}
+
+/** Get an admin view of invite codes. */
+export declare namespace ComAtprotoAdminGetInviteCodes {
+	interface Params {
+		cursor?: string;
+		/**
+		 * Minimum: 1 \
+		 * Maximum: 500
+		 * @default 100
+		 */
+		limit?: number;
+		/** @default "recent" */
+		sort?: 'recent' | 'usage' | (string & {});
+	}
+	type Input = undefined;
+	interface Output {
+		codes: ComAtprotoServerDefs.InviteCode[];
+		cursor?: string;
+	}
+}
+
+/** Get the service-specific admin status of a subject (account, record, or blob). */
+export declare namespace ComAtprotoAdminGetSubjectStatus {
+	interface Params {
+		blob?: At.CID;
+		did?: At.DID;
+		uri?: At.Uri;
+	}
+	type Input = undefined;
+	interface Output {
+		subject: Brand.Union<
+			ComAtprotoAdminDefs.RepoBlobRef | ComAtprotoAdminDefs.RepoRef | ComAtprotoRepoStrongRef.Main
+		>;
+		deactivated?: ComAtprotoAdminDefs.StatusAttr;
+		takedown?: ComAtprotoAdminDefs.StatusAttr;
+	}
+}
+
+/** Get list of accounts that matches your search query. */
+export declare namespace ComAtprotoAdminSearchAccounts {
+	interface Params {
+		cursor?: string;
+		email?: string;
+		/**
+		 * Minimum: 1 \
+		 * Maximum: 100
+		 * @default 50
+		 */
+		limit?: number;
+	}
+	type Input = undefined;
+	interface Output {
+		accounts: ComAtprotoAdminDefs.AccountView[];
+		cursor?: string;
+	}
+}
+
+/** Send email to a user's account email address. */
+export declare namespace ComAtprotoAdminSendEmail {
+	interface Params {}
+	interface Input {
+		content: string;
+		recipientDid: At.DID;
+		senderDid: At.DID;
+		/** Additional comment by the sender that won't be used in the email itself but helpful to provide more context for moderators/reviewers */
+		comment?: string;
+		subject?: string;
+	}
+	interface Output {
+		sent: boolean;
+	}
+}
+
+/** Administrative action to update an account's email. */
+export declare namespace ComAtprotoAdminUpdateAccountEmail {
+	interface Params {}
+	interface Input {
+		/** The handle or DID of the repo. */
+		account: string;
+		email: string;
+	}
+	type Output = undefined;
+}
+
+/** Administrative action to update an account's handle. */
+export declare namespace ComAtprotoAdminUpdateAccountHandle {
+	interface Params {}
+	interface Input {
+		did: At.DID;
+		handle: At.Handle;
+	}
+	type Output = undefined;
+}
+
+/** Update the password for a user account as an administrator. */
+export declare namespace ComAtprotoAdminUpdateAccountPassword {
+	interface Params {}
+	interface Input {
+		did: At.DID;
+		password: string;
+	}
+	type Output = undefined;
+}
+
+/** Update the service-specific admin status of a subject (account, record, or blob). */
+export declare namespace ComAtprotoAdminUpdateSubjectStatus {
+	interface Params {}
+	interface Input {
+		subject: Brand.Union<
+			ComAtprotoAdminDefs.RepoBlobRef | ComAtprotoAdminDefs.RepoRef | ComAtprotoRepoStrongRef.Main
+		>;
+		deactivated?: ComAtprotoAdminDefs.StatusAttr;
+		takedown?: ComAtprotoAdminDefs.StatusAttr;
+	}
+	interface Output {
+		subject: Brand.Union<
+			ComAtprotoAdminDefs.RepoBlobRef | ComAtprotoAdminDefs.RepoRef | ComAtprotoRepoStrongRef.Main
+		>;
+		takedown?: ComAtprotoAdminDefs.StatusAttr;
+	}
+}
+
+/** Describe the credentials that should be included in the DID doc of an account that is migrating to this service. */
+export declare namespace ComAtprotoIdentityGetRecommendedDidCredentials {
+	interface Params {}
+	type Input = undefined;
+	interface Output {
+		alsoKnownAs?: string[];
+		/** Recommended rotation keys for PLC dids. Should be undefined (or ignored) for did:webs. */
+		rotationKeys?: string[];
+		services?: unknown;
+		verificationMethods?: unknown;
+	}
+}
+
+/** Request an email with a code to in order to request a signed PLC operation. Requires Auth. */
+export declare namespace ComAtprotoIdentityRequestPlcOperationSignature {
+	interface Params {}
+	type Input = undefined;
+	type Output = undefined;
+}
+
+/** Resolves a handle (domain name) to a DID. */
+export declare namespace ComAtprotoIdentityResolveHandle {
+	interface Params {
+		/** The handle to resolve. */
+		handle: At.Handle;
+	}
+	type Input = undefined;
+	interface Output {
+		did: At.DID;
+	}
+}
+
+/** Signs a PLC operation to update some value(s) in the requesting DID's document. */
+export declare namespace ComAtprotoIdentitySignPlcOperation {
+	interface Params {}
+	interface Input {
+		alsoKnownAs?: string[];
+		rotationKeys?: string[];
+		services?: unknown;
+		/** A token received through com.atproto.identity.requestPlcOperationSignature */
+		token?: string;
+		verificationMethods?: unknown;
+	}
+	interface Output {
+		/** A signed DID PLC operation. */
+		operation: unknown;
+	}
+}
+
+/** Validates a PLC operation to ensure that it doesn't violate a service's constraints or get the identity into a bad state, then submits it to the PLC registry */
+export declare namespace ComAtprotoIdentitySubmitPlcOperation {
+	interface Params {}
+	interface Input {
+		operation: unknown;
+	}
+	type Output = undefined;
+}
+
+/** Updates the current account's handle. Verifies handle validity, and updates did:plc document if necessary. Implemented by PDS, and requires auth. */
+export declare namespace ComAtprotoIdentityUpdateHandle {
+	interface Params {}
+	interface Input {
+		/** The new handle. */
+		handle: At.Handle;
+	}
+	type Output = undefined;
+}
+
+export declare namespace ComAtprotoLabelDefs {
+	/** Metadata tag on an atproto resource (eg, repo or record). */
+	interface Label {
+		[Brand.Type]?: 'com.atproto.label.defs#label';
+		/** Timestamp when this label was created. */
+		cts: string;
+		/** DID of the actor who created this label. */
+		src: At.DID;
+		/** AT URI of the record, repository (account), or other resource that this label applies to. */
+		uri: string;
+		/**
+		 * The short string name of the value or type of this label. \
+		 * Maximum string length: 128
+		 */
+		val: string;
+		/** Optionally, CID specifying the specific version of 'uri' resource this label applies to. */
+		cid?: At.CID;
+		/** Timestamp at which this label expires (no longer applies). */
+		exp?: string;
+		/** If true, this is a negation label, overwriting a previous label. */
+		neg?: boolean;
+		/** Signature of dag-cbor encoded label. */
+		sig?: At.Bytes;
+		/** The AT Protocol version of the label object. */
+		ver?: number;
+	}
+	type LabelValue =
+		| '!hide'
+		| '!no-promote'
+		| '!no-unauthenticated'
+		| '!warn'
+		| 'dmca-violation'
+		| 'doxxing'
+		| 'gore'
+		| 'nsfl'
+		| 'nudity'
+		| 'porn'
+		| 'sexual'
+		| (string & {});
+	/** Declares a label value and its expected interpretations and behaviors. */
+	interface LabelValueDefinition {
+		[Brand.Type]?: 'com.atproto.label.defs#labelValueDefinition';
+		/** What should this label hide in the UI, if applied? 'content' hides all of the target; 'media' hides the images/video/audio; 'none' hides nothing. */
+		blurs: 'content' | 'media' | 'none' | (string & {});
+		/**
+		 * The value of the label being defined. Must only include lowercase ascii and the '-' character ([a-z-]+). \
+		 * Maximum string length: 100 \
+		 * Maximum grapheme length: 100
+		 */
+		identifier: string;
+		locales: LabelValueDefinitionStrings[];
+		/** How should a client visually convey this label? 'inform' means neutral and informational; 'alert' means negative and warning; 'none' means show nothing. */
+		severity: 'alert' | 'inform' | 'none' | (string & {});
+		/** Does the user need to have adult content enabled in order to configure this label? */
+		adultOnly?: boolean;
+		/**
+		 * The default setting for this label.
+		 * @default "warn"
+		 */
+		defaultSetting?: 'hide' | 'ignore' | 'warn' | (string & {});
+	}
+	/** Strings which describe the label in the UI, localized into a specific language. */
+	interface LabelValueDefinitionStrings {
+		[Brand.Type]?: 'com.atproto.label.defs#labelValueDefinitionStrings';
+		/**
+		 * A longer description of what the label means and why it might be applied. \
+		 * Maximum string length: 100000 \
+		 * Maximum grapheme length: 10000
+		 */
+		description: string;
+		/** The code of the language these strings are written in. */
+		lang: string;
+		/**
+		 * A short human-readable name for the label. \
+		 * Maximum string length: 640 \
+		 * Maximum grapheme length: 64
+		 */
+		name: string;
+	}
+	/** Metadata tag on an atproto record, published by the author within the record. Note that schemas should use #selfLabels, not #selfLabel. */
+	interface SelfLabel {
+		[Brand.Type]?: 'com.atproto.label.defs#selfLabel';
+		/**
+		 * The short string name of the value or type of this label. \
+		 * Maximum string length: 128
+		 */
+		val: string;
+	}
+	/** Metadata tags on an atproto record, published by the author within the record. */
+	interface SelfLabels {
+		[Brand.Type]?: 'com.atproto.label.defs#selfLabels';
+		/** Maximum array length: 10 */
+		values: SelfLabel[];
+	}
+}
+
+/** Find labels relevant to the provided AT-URI patterns. Public endpoint for moderation services, though may return different or additional results with auth. */
+export declare namespace ComAtprotoLabelQueryLabels {
+	interface Params {
+		/** List of AT URI patterns to match (boolean 'OR'). Each may be a prefix (ending with '*'; will match inclusive of the string leading to '*'), or a full URI. */
+		uriPatterns: string[];
+		cursor?: string;
+		/**
+		 * Minimum: 1 \
+		 * Maximum: 250
+		 * @default 50
+		 */
+		limit?: number;
+		/** Optional list of label sources (DIDs) to filter on. */
+		sources?: At.DID[];
+	}
+	type Input = undefined;
+	interface Output {
+		labels: ComAtprotoLabelDefs.Label[];
+		cursor?: string;
+	}
+}
+
+export declare namespace ComAtprotoLabelSubscribeLabels {
+	interface Info {
+		[Brand.Type]?: 'com.atproto.label.subscribeLabels#info';
+		name: 'OutdatedCursor' | (string & {});
+		message?: string;
+	}
+	interface Labels {
+		[Brand.Type]?: 'com.atproto.label.subscribeLabels#labels';
+		labels: ComAtprotoLabelDefs.Label[];
+		seq: number;
+	}
+}
+
+/** Submit a moderation report regarding an atproto account or record. Implemented by moderation services (with PDS proxying), and requires auth. */
+export declare namespace ComAtprotoModerationCreateReport {
+	interface Params {}
+	interface Input {
+		/** Indicates the broad category of violation the report is for. */
+		reasonType: ComAtprotoModerationDefs.ReasonType;
+		subject: Brand.Union<ComAtprotoAdminDefs.RepoRef | ComAtprotoRepoStrongRef.Main>;
+		/**
+		 * Additional context about the content and violation. \
+		 * Maximum string length: 20000 \
+		 * Maximum grapheme length: 2000
+		 */
+		reason?: string;
+	}
+	interface Output {
+		createdAt: string;
+		id: number;
+		reasonType: ComAtprotoModerationDefs.ReasonType;
+		reportedBy: At.DID;
+		subject: Brand.Union<ComAtprotoAdminDefs.RepoRef | ComAtprotoRepoStrongRef.Main>;
+		/**
+		 * Maximum string length: 20000 \
+		 * Maximum grapheme length: 2000
+		 */
+		reason?: string;
+	}
+}
+
+export declare namespace ComAtprotoModerationDefs {
+	type ReasonAppeal = 'com.atproto.moderation.defs#reasonAppeal';
+	type ReasonMisleading = 'com.atproto.moderation.defs#reasonMisleading';
+	type ReasonOther = 'com.atproto.moderation.defs#reasonOther';
+	type ReasonRude = 'com.atproto.moderation.defs#reasonRude';
+	type ReasonSexual = 'com.atproto.moderation.defs#reasonSexual';
+	type ReasonSpam = 'com.atproto.moderation.defs#reasonSpam';
+	type ReasonType =
+		| 'com.atproto.moderation.defs#reasonAppeal'
+		| 'com.atproto.moderation.defs#reasonMisleading'
+		| 'com.atproto.moderation.defs#reasonOther'
+		| 'com.atproto.moderation.defs#reasonRude'
+		| 'com.atproto.moderation.defs#reasonSexual'
+		| 'com.atproto.moderation.defs#reasonSpam'
+		| 'com.atproto.moderation.defs#reasonViolation'
+		| (string & {});
+	type ReasonViolation = 'com.atproto.moderation.defs#reasonViolation';
+}
+
+/** Apply a batch transaction of repository creates, updates, and deletes. Requires auth, implemented by PDS. */
+export declare namespace ComAtprotoRepoApplyWrites {
+	interface Params {}
+	interface Input {
+		/** The handle or DID of the repo (aka, current account). */
+		repo: string;
+		writes: Brand.Union<Create | Delete | Update>[];
+		/** If provided, the entire operation will fail if the current repo commit CID does not match this value. Used to prevent conflicting repo mutations. */
+		swapCommit?: At.CID;
+		/**
+		 * Can be set to 'false' to skip Lexicon schema validation of record data, for all operations.
+		 * @default true
+		 */
+		validate?: boolean;
+	}
+	type Output = undefined;
+	interface Errors {
+		InvalidSwap: {};
+	}
+	/** Operation which creates a new record. */
+	interface Create {
+		[Brand.Type]?: 'com.atproto.repo.applyWrites#create';
+		collection: string;
+		value: unknown;
+		/** Maximum string length: 15 */
+		rkey?: string;
+	}
+	/** Operation which deletes an existing record. */
+	interface Delete {
+		[Brand.Type]?: 'com.atproto.repo.applyWrites#delete';
+		collection: string;
+		rkey: string;
+	}
+	/** Operation which updates an existing record. */
+	interface Update {
+		[Brand.Type]?: 'com.atproto.repo.applyWrites#update';
+		collection: string;
+		rkey: string;
+		value: unknown;
+	}
+}
+
+/** Create a single new repository record. Requires auth, implemented by PDS. */
+export declare namespace ComAtprotoRepoCreateRecord {
+	interface Params {}
+	interface Input {
+		/** The NSID of the record collection. */
+		collection: string;
+		/** The record itself. Must contain a $type field. */
+		record: unknown;
+		/** The handle or DID of the repo (aka, current account). */
+		repo: string;
+		/**
+		 * The Record Key. \
+		 * Maximum string length: 15
+		 */
+		rkey?: string;
+		/** Compare and swap with the previous commit by CID. */
+		swapCommit?: At.CID;
+		/**
+		 * Can be set to 'false' to skip Lexicon schema validation of record data.
+		 * @default true
+		 */
+		validate?: boolean;
+	}
+	interface Output {
+		cid: At.CID;
+		uri: At.Uri;
+	}
+	interface Errors {
+		InvalidSwap: {};
+	}
+}
+
+/** Delete a repository record, or ensure it doesn't exist. Requires auth, implemented by PDS. */
+export declare namespace ComAtprotoRepoDeleteRecord {
+	interface Params {}
+	interface Input {
+		/** The NSID of the record collection. */
+		collection: string;
+		/** The handle or DID of the repo (aka, current account). */
+		repo: string;
+		/** The Record Key. */
+		rkey: string;
+		/** Compare and swap with the previous commit by CID. */
+		swapCommit?: At.CID;
+		/** Compare and swap with the previous record by CID. */
+		swapRecord?: At.CID;
+	}
+	type Output = undefined;
+	interface Errors {
+		InvalidSwap: {};
+	}
+}
+
+/** Get information about an account and repository, including the list of collections. Does not require auth. */
+export declare namespace ComAtprotoRepoDescribeRepo {
+	interface Params {
+		/** The handle or DID of the repo. */
+		repo: string;
+	}
+	type Input = undefined;
+	interface Output {
+		/** List of all the collections (NSIDs) for which this repo contains at least one record. */
+		collections: string[];
+		did: At.DID;
+		/** The complete DID document for this account. */
+		didDoc: unknown;
+		handle: At.Handle;
+		/** Indicates if handle is currently valid (resolves bi-directionally) */
+		handleIsCorrect: boolean;
+	}
+}
+
+/** Get a single record from a repository. Does not require auth. */
+export declare namespace ComAtprotoRepoGetRecord {
+	interface Params {
+		/** The NSID of the record collection. */
+		collection: string;
+		/** The handle or DID of the repo. */
+		repo: string;
+		/** The Record Key. */
+		rkey: string;
+		/** The CID of the version of the record. If not specified, then return the most recent version. */
+		cid?: At.CID;
+	}
+	type Input = undefined;
+	interface Output {
+		uri: At.Uri;
+		value: unknown;
+		cid?: At.CID;
+	}
+}
+
+/** Import a repo in the form of a CAR file. Requires Content-Length HTTP header to be set. */
+export declare namespace ComAtprotoRepoImportRepo {
+	interface Params {}
+	type Input = Blob | ArrayBufferView;
+	type Output = undefined;
+}
+
+/** Returns a list of missing blobs for the requesting account. Intended to be used in the account migration flow. */
+export declare namespace ComAtprotoRepoListMissingBlobs {
+	interface Params {
+		cursor?: string;
+		/**
+		 * Minimum: 1 \
+		 * Maximum: 1000
+		 * @default 500
+		 */
+		limit?: number;
+	}
+	type Input = undefined;
+	interface Output {
+		blobs: RecordBlob[];
+		cursor?: string;
+	}
+	interface RecordBlob {
+		[Brand.Type]?: 'com.atproto.repo.listMissingBlobs#recordBlob';
+		cid: At.CID;
+		recordUri: At.Uri;
+	}
+}
+
+/** List a range of records in a repository, matching a specific collection. Does not require auth. */
+export declare namespace ComAtprotoRepoListRecords {
+	interface Params {
+		/** The NSID of the record type. */
+		collection: string;
+		/** The handle or DID of the repo. */
+		repo: string;
+		cursor?: string;
+		/**
+		 * The number of records to return. \
+		 * Minimum: 1 \
+		 * Maximum: 100
+		 * @default 50
+		 */
+		limit?: number;
+		/** Flag to reverse the order of the returned records. */
+		reverse?: boolean;
+		/**
+		 * DEPRECATED: The highest sort-ordered rkey to stop at (exclusive)
+		 * @deprecated
+		 */
+		rkeyEnd?: string;
+		/**
+		 * DEPRECATED: The lowest sort-ordered rkey to start from (exclusive)
+		 * @deprecated
+		 */
+		rkeyStart?: string;
+	}
+	type Input = undefined;
+	interface Output {
+		records: Record[];
+		cursor?: string;
+	}
+	interface Record {
+		[Brand.Type]?: 'com.atproto.repo.listRecords#record';
+		cid: At.CID;
+		uri: At.Uri;
+		value: unknown;
+	}
+}
+
+/** Write a repository record, creating or updating it as needed. Requires auth, implemented by PDS. */
+export declare namespace ComAtprotoRepoPutRecord {
+	interface Params {}
+	interface Input {
+		/** The NSID of the record collection. */
+		collection: string;
+		/** The record to write. */
+		record: unknown;
+		/** The handle or DID of the repo (aka, current account). */
+		repo: string;
+		/**
+		 * The Record Key. \
+		 * Maximum string length: 15
+		 */
+		rkey: string;
+		/** Compare and swap with the previous commit by CID. */
+		swapCommit?: At.CID;
+		/** Compare and swap with the previous record by CID. WARNING: nullable and optional field; may cause problems with golang implementation */
+		swapRecord?: At.CID | null;
+		/**
+		 * Can be set to 'false' to skip Lexicon schema validation of record data.
+		 * @default true
+		 */
+		validate?: boolean;
+	}
+	interface Output {
+		cid: At.CID;
+		uri: At.Uri;
+	}
+	interface Errors {
+		InvalidSwap: {};
+	}
+}
+
+export declare namespace ComAtprotoRepoStrongRef {
+	interface Main {
+		[Brand.Type]?: 'com.atproto.repo.strongRef';
+		cid: At.CID;
+		uri: At.Uri;
+	}
+}
+
+/** Upload a new blob, to be referenced from a repository record. The blob will be deleted if it is not referenced within a time window (eg, minutes). Blob restrictions (mimetype, size, etc) are enforced when the reference is created. Requires auth, implemented by PDS. */
+export declare namespace ComAtprotoRepoUploadBlob {
+	interface Params {}
+	type Input = Blob | ArrayBufferView;
+	interface Output {
+		blob: At.Blob;
+	}
+}
+
+/** Activates a currently deactivated account. Used to finalize account migration after the account's repo is imported and identity is setup. */
+export declare namespace ComAtprotoServerActivateAccount {
+	interface Params {}
+	type Input = undefined;
+	type Output = undefined;
+}
+
+/** Returns the status of an account, especially as pertaining to import or recovery. Can be called many times over the course of an account migration. Requires auth and can only be called pertaining to oneself. */
+export declare namespace ComAtprotoServerCheckAccountStatus {
+	interface Params {}
+	type Input = undefined;
+	interface Output {
+		activated: boolean;
+		expectedBlobs: number;
+		importedBlobs: number;
+		indexedRecords: number;
+		privateStateValues: number;
+		repoBlocks: number;
+		repoCommit: At.CID;
+		repoRev: string;
+		validDid: boolean;
+	}
+}
+
+/** Confirm an email using a token from com.atproto.server.requestEmailConfirmation. */
+export declare namespace ComAtprotoServerConfirmEmail {
+	interface Params {}
+	interface Input {
+		email: string;
+		token: string;
+	}
+	type Output = undefined;
+	interface Errors {
+		AccountNotFound: {};
+		ExpiredToken: {};
+		InvalidToken: {};
+		InvalidEmail: {};
+	}
+}
+
+/** Create an account. Implemented by PDS. */
+export declare namespace ComAtprotoServerCreateAccount {
+	interface Params {}
+	interface Input {
+		/** Requested handle for the account. */
+		handle: At.Handle;
+		/** Pre-existing atproto DID, being imported to a new account. */
+		did?: At.DID;
+		email?: string;
+		inviteCode?: string;
+		/** Initial account password. May need to meet instance-specific password strength requirements. */
+		password?: string;
+		/** A signed DID PLC operation to be submitted as part of importing an existing account to this instance. NOTE: this optional field may be updated when full account migration is implemented. */
+		plcOp?: unknown;
+		/** DID PLC rotation key (aka, recovery key) to be included in PLC creation operation. */
+		recoveryKey?: string;
+		verificationCode?: string;
+		verificationPhone?: string;
+	}
+	/** Account login session returned on successful account creation. */
+	interface Output {
+		accessJwt: string;
+		/** The DID of the new account. */
+		did: At.DID;
+		handle: At.Handle;
+		refreshJwt: string;
+		/** Complete DID document. */
+		didDoc?: unknown;
+	}
+	interface Errors {
+		InvalidHandle: {};
+		InvalidPassword: {};
+		InvalidInviteCode: {};
+		HandleNotAvailable: {};
+		UnsupportedDomain: {};
+		UnresolvableDid: {};
+		IncompatibleDidDoc: {};
+	}
+}
+
+/** Create an App Password. */
+export declare namespace ComAtprotoServerCreateAppPassword {
+	interface Params {}
+	interface Input {
+		/** A short name for the App Password, to help distinguish them. */
+		name: string;
+		/** If an app password has 'privileged' access to possibly sensitive account state. Meant for use with trusted clients. */
+		privileged?: boolean;
+	}
+	type Output = AppPassword;
+	interface Errors {
+		AccountTakedown: {};
+	}
+	interface AppPassword {
+		[Brand.Type]?: 'com.atproto.server.createAppPassword#appPassword';
+		createdAt: string;
+		name: string;
+		password: string;
+		privileged?: boolean;
+	}
+}
+
+/** Create an invite code. */
+export declare namespace ComAtprotoServerCreateInviteCode {
+	interface Params {}
+	interface Input {
+		useCount: number;
+		forAccount?: At.DID;
+	}
+	interface Output {
+		code: string;
+	}
+}
+
+/** Create invite codes. */
+export declare namespace ComAtprotoServerCreateInviteCodes {
+	interface Params {}
+	interface Input {
+		/** @default 1 */
+		codeCount: number;
+		useCount: number;
+		forAccounts?: At.DID[];
+	}
+	interface Output {
+		codes: AccountCodes[];
+	}
+	interface AccountCodes {
+		[Brand.Type]?: 'com.atproto.server.createInviteCodes#accountCodes';
+		account: string;
+		codes: string[];
+	}
+}
+
+/** Create an authentication session. */
+export declare namespace ComAtprotoServerCreateSession {
+	interface Params {}
+	interface Input {
+		/** Handle or other identifier supported by the server for the authenticating user. */
+		identifier: string;
+		password: string;
+		authFactorToken?: string;
+	}
+	interface Output {
+		accessJwt: string;
+		did: At.DID;
+		handle: At.Handle;
+		refreshJwt: string;
+		active?: boolean;
+		didDoc?: unknown;
+		email?: string;
+		emailAuthFactor?: boolean;
+		emailConfirmed?: boolean;
+		/** If active=false, this optional field indicates a possible reason for why the account is not active. If active=false and no status is supplied, then the host makes no claim for why the repository is no longer being hosted. */
+		status?: 'deactivated' | 'suspended' | 'takendown' | (string & {});
+	}
+	interface Errors {
+		AccountTakedown: {};
+		AuthFactorTokenRequired: {};
+	}
+}
+
+/** Deactivates a currently active account. Stops serving of repo, and future writes to repo until reactivated. Used to finalize account migration with the old host after the account has been activated on the new host. */
+export declare namespace ComAtprotoServerDeactivateAccount {
+	interface Params {}
+	interface Input {
+		/** A recommendation to server as to how long they should hold onto the deactivated account before deleting. */
+		deleteAfter?: string;
+	}
+	type Output = undefined;
+}
+
+export declare namespace ComAtprotoServerDefs {
+	interface InviteCode {
+		[Brand.Type]?: 'com.atproto.server.defs#inviteCode';
+		available: number;
+		code: string;
+		createdAt: string;
+		createdBy: string;
+		disabled: boolean;
+		forAccount: string;
+		uses: InviteCodeUse[];
+	}
+	interface InviteCodeUse {
+		[Brand.Type]?: 'com.atproto.server.defs#inviteCodeUse';
+		usedAt: string;
+		usedBy: At.DID;
+	}
+}
+
+/** Delete an actor's account with a token and password. Can only be called after requesting a deletion token. Requires auth. */
+export declare namespace ComAtprotoServerDeleteAccount {
+	interface Params {}
+	interface Input {
+		did: At.DID;
+		password: string;
+		token: string;
+	}
+	type Output = undefined;
+	interface Errors {
+		ExpiredToken: {};
+		InvalidToken: {};
+	}
+}
+
+/** Delete the current session. Requires auth. */
+export declare namespace ComAtprotoServerDeleteSession {
+	interface Params {}
+	type Input = undefined;
+	type Output = undefined;
+}
+
+/** Describes the server's account creation requirements and capabilities. Implemented by PDS. */
+export declare namespace ComAtprotoServerDescribeServer {
+	interface Params {}
+	type Input = undefined;
+	interface Output {
+		/** List of domain suffixes that can be used in account handles. */
+		availableUserDomains: string[];
+		did: At.DID;
+		/** Contact information */
+		contact?: Contact;
+		/** If true, an invite code must be supplied to create an account on this instance. */
+		inviteCodeRequired?: boolean;
+		/** URLs of service policy documents. */
+		links?: Links;
+		/** If true, a phone verification token must be supplied to create an account on this instance. */
+		phoneVerificationRequired?: boolean;
+	}
+	interface Contact {
+		[Brand.Type]?: 'com.atproto.server.describeServer#contact';
+		email?: string;
+	}
+	interface Links {
+		[Brand.Type]?: 'com.atproto.server.describeServer#links';
+		privacyPolicy?: string;
+		termsOfService?: string;
+	}
+}
+
+/** Get all invite codes for the current account. Requires auth. */
+export declare namespace ComAtprotoServerGetAccountInviteCodes {
+	interface Params {
+		/**
+		 * Controls whether any new 'earned' but not 'created' invites should be created.
+		 * @default true
+		 */
+		createAvailable?: boolean;
+		/** @default true */
+		includeUsed?: boolean;
+	}
+	type Input = undefined;
+	interface Output {
+		codes: ComAtprotoServerDefs.InviteCode[];
+	}
+	interface Errors {
+		DuplicateCreate: {};
+	}
+}
+
+/** Get a signed token on behalf of the requesting DID for the requested service. */
+export declare namespace ComAtprotoServerGetServiceAuth {
+	interface Params {
+		/** The DID of the service that the token will be used to authenticate with */
+		aud: At.DID;
+		/** The time in Unix Epoch seconds that the JWT expires. Defaults to 60 seconds in the future. The service may enforce certain time bounds on tokens depending on the requested scope. */
+		exp?: number;
+		/** Lexicon (XRPC) method to bind the requested token to */
+		lxm?: string;
+	}
+	type Input = undefined;
+	interface Output {
+		token: string;
+	}
+	interface Errors {
+		BadExpiration: {};
+	}
+}
+
+/** Get information about the current auth session. Requires auth. */
+export declare namespace ComAtprotoServerGetSession {
+	interface Params {}
+	type Input = undefined;
+	interface Output {
+		did: At.DID;
+		handle: At.Handle;
+		active?: boolean;
+		didDoc?: unknown;
+		email?: string;
+		emailAuthFactor?: boolean;
+		emailConfirmed?: boolean;
+		/** If active=false, this optional field indicates a possible reason for why the account is not active. If active=false and no status is supplied, then the host makes no claim for why the repository is no longer being hosted. */
+		status?: 'deactivated' | 'suspended' | 'takendown' | (string & {});
+	}
+}
+
+/** List all App Passwords. */
+export declare namespace ComAtprotoServerListAppPasswords {
+	interface Params {}
+	type Input = undefined;
+	interface Output {
+		passwords: AppPassword[];
+	}
+	interface Errors {
+		AccountTakedown: {};
+	}
+	interface AppPassword {
+		[Brand.Type]?: 'com.atproto.server.listAppPasswords#appPassword';
+		createdAt: string;
+		name: string;
+		privileged?: boolean;
+	}
+}
+
+/** Refresh an authentication session. Requires auth using the 'refreshJwt' (not the 'accessJwt'). */
+export declare namespace ComAtprotoServerRefreshSession {
+	interface Params {}
+	type Input = undefined;
+	interface Output {
+		accessJwt: string;
+		did: At.DID;
+		handle: At.Handle;
+		refreshJwt: string;
+		active?: boolean;
+		didDoc?: unknown;
+		/** Hosting status of the account. If not specified, then assume 'active'. */
+		status?: 'deactivated' | 'suspended' | 'takendown' | (string & {});
+	}
+	interface Errors {
+		AccountTakedown: {};
+	}
+}
+
+/** Initiate a user account deletion via email. */
+export declare namespace ComAtprotoServerRequestAccountDelete {
+	interface Params {}
+	type Input = undefined;
+	type Output = undefined;
+}
+
+/** Request an email with a code to confirm ownership of email. */
+export declare namespace ComAtprotoServerRequestEmailConfirmation {
+	interface Params {}
+	type Input = undefined;
+	type Output = undefined;
+}
+
+/** Request a token in order to update email. */
+export declare namespace ComAtprotoServerRequestEmailUpdate {
+	interface Params {}
+	type Input = undefined;
+	interface Output {
+		tokenRequired: boolean;
+	}
+}
+
+/** Initiate a user account password reset via email. */
+export declare namespace ComAtprotoServerRequestPasswordReset {
+	interface Params {}
+	interface Input {
+		email: string;
+	}
+	type Output = undefined;
+}
+
+/** Reserve a repo signing key, for use with account creation. Necessary so that a DID PLC update operation can be constructed during an account migraiton. Public and does not require auth; implemented by PDS. NOTE: this endpoint may change when full account migration is implemented. */
+export declare namespace ComAtprotoServerReserveSigningKey {
+	interface Params {}
+	interface Input {
+		/** The DID to reserve a key for. */
+		did?: At.DID;
+	}
+	interface Output {
+		/** The public key for the reserved signing key, in did:key serialization. */
+		signingKey: string;
+	}
+}
+
+/** Reset a user account password using a token. */
+export declare namespace ComAtprotoServerResetPassword {
+	interface Params {}
+	interface Input {
+		password: string;
+		token: string;
+	}
+	type Output = undefined;
+	interface Errors {
+		ExpiredToken: {};
+		InvalidToken: {};
+	}
+}
+
+/** Revoke an App Password by name. */
+export declare namespace ComAtprotoServerRevokeAppPassword {
+	interface Params {}
+	interface Input {
+		name: string;
+	}
+	type Output = undefined;
+}
+
+/** Update an account's email. */
+export declare namespace ComAtprotoServerUpdateEmail {
+	interface Params {}
+	interface Input {
+		email: string;
+		emailAuthFactor?: boolean;
+		/** Requires a token from com.atproto.sever.requestEmailUpdate if the account's email has been confirmed. */
+		token?: string;
+	}
+	type Output = undefined;
+	interface Errors {
+		ExpiredToken: {};
+		InvalidToken: {};
+		TokenRequired: {};
+	}
+}
+
+/** Get a blob associated with a given account. Returns the full blob as originally uploaded. Does not require auth; implemented by PDS. */
+export declare namespace ComAtprotoSyncGetBlob {
+	interface Params {
+		/** The CID of the blob to fetch */
+		cid: At.CID;
+		/** The DID of the account. */
+		did: At.DID;
+	}
+	type Input = undefined;
+	type Output = Uint8Array;
+	interface Errors {
+		BlobNotFound: {};
+		RepoNotFound: {};
+		RepoTakendown: {};
+		RepoSuspended: {};
+		RepoDeactivated: {};
+	}
+}
+
+/** Get data blocks from a given repo, by CID. For example, intermediate MST nodes, or records. Does not require auth; implemented by PDS. */
+export declare namespace ComAtprotoSyncGetBlocks {
+	interface Params {
+		cids: At.CID[];
+		/** The DID of the repo. */
+		did: At.DID;
+	}
+	type Input = undefined;
+	type Output = Uint8Array;
+	interface Errors {
+		BlockNotFound: {};
+		RepoNotFound: {};
+		RepoTakendown: {};
+		RepoSuspended: {};
+		RepoDeactivated: {};
+	}
+}
+
+/**
+ * DEPRECATED - please use com.atproto.sync.getRepo instead
+ * @deprecated
+ */
+export declare namespace ComAtprotoSyncGetCheckout {
+	interface Params {
+		/** The DID of the repo. */
+		did: At.DID;
+	}
+	type Input = undefined;
+	type Output = Uint8Array;
+}
+
+/**
+ * DEPRECATED - please use com.atproto.sync.getLatestCommit instead
+ * @deprecated
+ */
+export declare namespace ComAtprotoSyncGetHead {
+	interface Params {
+		/** The DID of the repo. */
+		did: At.DID;
+	}
+	type Input = undefined;
+	interface Output {
+		root: At.CID;
+	}
+	interface Errors {
+		HeadNotFound: {};
+	}
+}
+
+/** Get the current commit CID & revision of the specified repo. Does not require auth. */
+export declare namespace ComAtprotoSyncGetLatestCommit {
+	interface Params {
+		/** The DID of the repo. */
+		did: At.DID;
+	}
+	type Input = undefined;
+	interface Output {
+		cid: At.CID;
+		rev: string;
+	}
+	interface Errors {
+		RepoNotFound: {};
+		RepoTakendown: {};
+		RepoSuspended: {};
+		RepoDeactivated: {};
+	}
+}
+
+/** Get data blocks needed to prove the existence or non-existence of record in the current version of repo. Does not require auth. */
+export declare namespace ComAtprotoSyncGetRecord {
+	interface Params {
+		collection: string;
+		/** The DID of the repo. */
+		did: At.DID;
+		/** Record Key */
+		rkey: string;
+		/**
+		 * DEPRECATED: referenced a repo commit by CID, and retrieved record as of that commit
+		 * @deprecated
+		 */
+		commit?: At.CID;
+	}
+	type Input = undefined;
+	type Output = Uint8Array;
+	interface Errors {
+		RecordNotFound: {};
+		RepoNotFound: {};
+		RepoTakendown: {};
+		RepoSuspended: {};
+		RepoDeactivated: {};
+	}
+}
+
+/** Download a repository export as CAR file. Optionally only a 'diff' since a previous revision. Does not require auth; implemented by PDS. */
+export declare namespace ComAtprotoSyncGetRepo {
+	interface Params {
+		/** The DID of the repo. */
+		did: At.DID;
+		/** The revision ('rev') of the repo to create a diff from. */
+		since?: string;
+	}
+	type Input = undefined;
+	type Output = Uint8Array;
+	interface Errors {
+		RepoNotFound: {};
+		RepoTakendown: {};
+		RepoSuspended: {};
+		RepoDeactivated: {};
+	}
+}
+
+/** Get the hosting status for a repository, on this server. Expected to be implemented by PDS and Relay. */
+export declare namespace ComAtprotoSyncGetRepoStatus {
+	interface Params {
+		/** The DID of the repo. */
+		did: At.DID;
+	}
+	type Input = undefined;
+	interface Output {
+		active: boolean;
+		did: At.DID;
+		/** Optional field, the current rev of the repo, if active=true */
+		rev?: string;
+		/** If active=false, this optional field indicates a possible reason for why the account is not active. If active=false and no status is supplied, then the host makes no claim for why the repository is no longer being hosted. */
+		status?: 'deactivated' | 'suspended' | 'takendown' | (string & {});
+	}
+	interface Errors {
+		RepoNotFound: {};
+	}
+}
+
+/** List blob CIDs for an account, since some repo revision. Does not require auth; implemented by PDS. */
+export declare namespace ComAtprotoSyncListBlobs {
+	interface Params {
+		/** The DID of the repo. */
+		did: At.DID;
+		cursor?: string;
+		/**
+		 * Minimum: 1 \
+		 * Maximum: 1000
+		 * @default 500
+		 */
+		limit?: number;
+		/** Optional revision of the repo to list blobs since. */
+		since?: string;
+	}
+	type Input = undefined;
+	interface Output {
+		cids: At.CID[];
+		cursor?: string;
+	}
+	interface Errors {
+		RepoNotFound: {};
+		RepoTakendown: {};
+		RepoSuspended: {};
+		RepoDeactivated: {};
+	}
+}
+
+/** Enumerates all the DID, rev, and commit CID for all repos hosted by this service. Does not require auth; implemented by PDS and Relay. */
+export declare namespace ComAtprotoSyncListRepos {
+	interface Params {
+		cursor?: string;
+		/**
+		 * Minimum: 1 \
+		 * Maximum: 1000
+		 * @default 500
+		 */
+		limit?: number;
+	}
+	type Input = undefined;
+	interface Output {
+		repos: Repo[];
+		cursor?: string;
+	}
+	interface Repo {
+		[Brand.Type]?: 'com.atproto.sync.listRepos#repo';
+		did: At.DID;
+		/** Current repo commit CID */
+		head: At.CID;
+		rev: string;
+		active?: boolean;
+		/** If active=false, this optional field indicates a possible reason for why the account is not active. If active=false and no status is supplied, then the host makes no claim for why the repository is no longer being hosted. */
+		status?: 'deactivated' | 'suspended' | 'takendown' | (string & {});
+	}
+}
+
+/** Notify a crawling service of a recent update, and that crawling should resume. Intended use is after a gap between repo stream events caused the crawling service to disconnect. Does not require auth; implemented by Relay. */
+export declare namespace ComAtprotoSyncNotifyOfUpdate {
+	interface Params {}
+	interface Input {
+		/** Hostname of the current service (usually a PDS) that is notifying of update. */
+		hostname: string;
+	}
+	type Output = undefined;
+}
+
+/** Request a service to persistently crawl hosted repos. Expected use is new PDS instances declaring their existence to Relays. Does not require auth. */
+export declare namespace ComAtprotoSyncRequestCrawl {
+	interface Params {}
+	interface Input {
+		/** Hostname of the current service (eg, PDS) that is requesting to be crawled. */
+		hostname: string;
+	}
+	type Output = undefined;
+}
+
+export declare namespace ComAtprotoSyncSubscribeRepos {
+	/** Represents a change to an account's status on a host (eg, PDS or Relay). The semantics of this event are that the status is at the host which emitted the event, not necessarily that at the currently active PDS. Eg, a Relay takedown would emit a takedown with active=false, even if the PDS is still active. */
+	interface Account {
+		[Brand.Type]?: 'com.atproto.sync.subscribeRepos#account';
+		/** Indicates that the account has a repository which can be fetched from the host that emitted this event. */
+		active: boolean;
+		did: At.DID;
+		seq: number;
+		time: string;
+		/** If active=false, this optional field indicates a reason for why the account is not active. */
+		status?: 'deactivated' | 'deleted' | 'suspended' | 'takendown' | (string & {});
+	}
+	/** Represents an update of repository state. Note that empty commits are allowed, which include no repo data changes, but an update to rev and signature. */
+	interface Commit {
+		[Brand.Type]?: 'com.atproto.sync.subscribeRepos#commit';
+		/** List of new blobs (by CID) referenced by records in this commit. */
+		blobs: At.CIDLink[];
+		/** CAR file containing relevant blocks, as a diff since the previous repo state. */
+		blocks: At.Bytes;
+		/** Repo commit object CID. */
+		commit: At.CIDLink;
+		/**
+		 * Maximum array length: 200 \
+		 * List of repo mutation operations in this commit (eg, records created, updated, or deleted).
+		 */
+		ops: RepoOp[];
+		/**
+		 * DEPRECATED -- unused
+		 * @deprecated
+		 */
+		rebase: boolean;
+		/** The repo this event comes from. */
+		repo: At.DID;
+		/** The rev of the emitted commit. Note that this information is also in the commit object included in blocks, unless this is a tooBig event. */
+		rev: string;
+		/** The stream sequence number of this message. */
+		seq: number;
+		/** The rev of the last emitted commit from this repo (if any). */
+		since: string | null;
+		/** Timestamp of when this message was originally broadcast. */
+		time: string;
+		/** Indicates that this commit contained too many ops, or data size was too large. Consumers will need to make a separate request to get missing data. */
+		tooBig: boolean;
+		/**
+		 * DEPRECATED -- unused. WARNING -- nullable and optional; stick with optional to ensure golang interoperability.
+		 * @deprecated
+		 */
+		prev?: At.CIDLink | null;
+	}
+	/**
+	 * DEPRECATED -- Use #identity event instead
+	 * @deprecated
+	 */
+	interface Handle {
+		[Brand.Type]?: 'com.atproto.sync.subscribeRepos#handle';
+		did: At.DID;
+		handle: At.Handle;
+		seq: number;
+		time: string;
+	}
+	/** Represents a change to an account's identity. Could be an updated handle, signing key, or pds hosting endpoint. Serves as a prod to all downstream services to refresh their identity cache. */
+	interface Identity {
+		[Brand.Type]?: 'com.atproto.sync.subscribeRepos#identity';
+		did: At.DID;
+		seq: number;
+		time: string;
+		/** The current handle for the account, or 'handle.invalid' if validation fails. This field is optional, might have been validated or passed-through from an upstream source. Semantics and behaviors for PDS vs Relay may evolve in the future; see atproto specs for more details. */
+		handle?: At.Handle;
+	}
+	interface Info {
+		[Brand.Type]?: 'com.atproto.sync.subscribeRepos#info';
+		name: 'OutdatedCursor' | (string & {});
+		message?: string;
+	}
+	/**
+	 * DEPRECATED -- Use #account event instead
+	 * @deprecated
+	 */
+	interface Migrate {
+		[Brand.Type]?: 'com.atproto.sync.subscribeRepos#migrate';
+		did: At.DID;
+		migrateTo: string | null;
+		seq: number;
+		time: string;
+	}
+	/** A repo operation, ie a mutation of a single record. */
+	interface RepoOp {
+		[Brand.Type]?: 'com.atproto.sync.subscribeRepos#repoOp';
+		action: 'create' | 'delete' | 'update' | (string & {});
+		/** For creates and updates, the new record CID. For deletions, null. */
+		cid: At.CIDLink | null;
+		path: string;
+	}
+	/**
+	 * DEPRECATED -- Use #account event instead
+	 * @deprecated
+	 */
+	interface Tombstone {
+		[Brand.Type]?: 'com.atproto.sync.subscribeRepos#tombstone';
+		did: At.DID;
+		seq: number;
+		time: string;
+	}
+}
+
+/** Check accounts location in signup queue. */
+export declare namespace ComAtprotoTempCheckSignupQueue {
+	interface Params {}
+	type Input = undefined;
+	interface Output {
+		activated: boolean;
+		estimatedTimeMs?: number;
+		placeInQueue?: number;
+	}
+}
+
+/**
+ * DEPRECATED: use queryLabels or subscribeLabels instead -- Fetch all labels from a labeler created after a certain date.
+ * @deprecated
+ */
+export declare namespace ComAtprotoTempFetchLabels {
+	interface Params {
+		/**
+		 * Minimum: 1 \
+		 * Maximum: 250
+		 * @default 50
+		 */
+		limit?: number;
+		since?: number;
+	}
+	type Input = undefined;
+	interface Output {
+		labels: ComAtprotoLabelDefs.Label[];
+	}
+}
+
+/** Request a verification code to be sent to the supplied phone number */
+export declare namespace ComAtprotoTempRequestPhoneVerification {
+	interface Params {}
+	interface Input {
+		phoneNumber: string;
+	}
+	type Output = undefined;
+}
+
+export declare interface Records {}
+
+export declare interface Queries {
+	'com.atproto.admin.getAccountInfo': {
+		params: ComAtprotoAdminGetAccountInfo.Params;
+		output: ComAtprotoAdminGetAccountInfo.Output;
+	};
+	'com.atproto.admin.getAccountInfos': {
+		params: ComAtprotoAdminGetAccountInfos.Params;
+		output: ComAtprotoAdminGetAccountInfos.Output;
+	};
+	'com.atproto.admin.getInviteCodes': {
+		params: ComAtprotoAdminGetInviteCodes.Params;
+		output: ComAtprotoAdminGetInviteCodes.Output;
+	};
+	'com.atproto.admin.getSubjectStatus': {
+		params: ComAtprotoAdminGetSubjectStatus.Params;
+		output: ComAtprotoAdminGetSubjectStatus.Output;
+	};
+	'com.atproto.admin.searchAccounts': {
+		params: ComAtprotoAdminSearchAccounts.Params;
+		output: ComAtprotoAdminSearchAccounts.Output;
+	};
+	'com.atproto.identity.getRecommendedDidCredentials': {
+		output: ComAtprotoIdentityGetRecommendedDidCredentials.Output;
+	};
+	'com.atproto.identity.resolveHandle': {
+		params: ComAtprotoIdentityResolveHandle.Params;
+		output: ComAtprotoIdentityResolveHandle.Output;
+	};
+	'com.atproto.label.queryLabels': {
+		params: ComAtprotoLabelQueryLabels.Params;
+		output: ComAtprotoLabelQueryLabels.Output;
+	};
+	'com.atproto.repo.describeRepo': {
+		params: ComAtprotoRepoDescribeRepo.Params;
+		output: ComAtprotoRepoDescribeRepo.Output;
+	};
+	'com.atproto.repo.getRecord': {
+		params: ComAtprotoRepoGetRecord.Params;
+		output: ComAtprotoRepoGetRecord.Output;
+	};
+	'com.atproto.repo.listMissingBlobs': {
+		params: ComAtprotoRepoListMissingBlobs.Params;
+		output: ComAtprotoRepoListMissingBlobs.Output;
+	};
+	'com.atproto.repo.listRecords': {
+		params: ComAtprotoRepoListRecords.Params;
+		output: ComAtprotoRepoListRecords.Output;
+	};
+	'com.atproto.server.checkAccountStatus': {
+		output: ComAtprotoServerCheckAccountStatus.Output;
+	};
+	'com.atproto.server.describeServer': {
+		output: ComAtprotoServerDescribeServer.Output;
+	};
+	'com.atproto.server.getAccountInviteCodes': {
+		params: ComAtprotoServerGetAccountInviteCodes.Params;
+		output: ComAtprotoServerGetAccountInviteCodes.Output;
+	};
+	'com.atproto.server.getServiceAuth': {
+		params: ComAtprotoServerGetServiceAuth.Params;
+		output: ComAtprotoServerGetServiceAuth.Output;
+	};
+	'com.atproto.server.getSession': {
+		output: ComAtprotoServerGetSession.Output;
+	};
+	'com.atproto.server.listAppPasswords': {
+		output: ComAtprotoServerListAppPasswords.Output;
+	};
+	'com.atproto.sync.getBlob': {
+		params: ComAtprotoSyncGetBlob.Params;
+		output: ComAtprotoSyncGetBlob.Output;
+	};
+	'com.atproto.sync.getBlocks': {
+		params: ComAtprotoSyncGetBlocks.Params;
+		output: ComAtprotoSyncGetBlocks.Output;
+	};
+	'com.atproto.sync.getCheckout': {
+		params: ComAtprotoSyncGetCheckout.Params;
+		output: ComAtprotoSyncGetCheckout.Output;
+	};
+	'com.atproto.sync.getHead': {
+		params: ComAtprotoSyncGetHead.Params;
+		output: ComAtprotoSyncGetHead.Output;
+	};
+	'com.atproto.sync.getLatestCommit': {
+		params: ComAtprotoSyncGetLatestCommit.Params;
+		output: ComAtprotoSyncGetLatestCommit.Output;
+	};
+	'com.atproto.sync.getRecord': {
+		params: ComAtprotoSyncGetRecord.Params;
+		output: ComAtprotoSyncGetRecord.Output;
+	};
+	'com.atproto.sync.getRepo': {
+		params: ComAtprotoSyncGetRepo.Params;
+		output: ComAtprotoSyncGetRepo.Output;
+	};
+	'com.atproto.sync.getRepoStatus': {
+		params: ComAtprotoSyncGetRepoStatus.Params;
+		output: ComAtprotoSyncGetRepoStatus.Output;
+	};
+	'com.atproto.sync.listBlobs': {
+		params: ComAtprotoSyncListBlobs.Params;
+		output: ComAtprotoSyncListBlobs.Output;
+	};
+	'com.atproto.sync.listRepos': {
+		params: ComAtprotoSyncListRepos.Params;
+		output: ComAtprotoSyncListRepos.Output;
+	};
+	'com.atproto.temp.checkSignupQueue': {
+		output: ComAtprotoTempCheckSignupQueue.Output;
+	};
+	'com.atproto.temp.fetchLabels': {
+		params: ComAtprotoTempFetchLabels.Params;
+		output: ComAtprotoTempFetchLabels.Output;
+	};
+}
+
+export declare interface Procedures {
+	'com.atproto.admin.deleteAccount': {
+		input: ComAtprotoAdminDeleteAccount.Input;
+	};
+	'com.atproto.admin.disableAccountInvites': {
+		input: ComAtprotoAdminDisableAccountInvites.Input;
+	};
+	'com.atproto.admin.disableInviteCodes': {
+		input: ComAtprotoAdminDisableInviteCodes.Input;
+	};
+	'com.atproto.admin.enableAccountInvites': {
+		input: ComAtprotoAdminEnableAccountInvites.Input;
+	};
+	'com.atproto.admin.sendEmail': {
+		input: ComAtprotoAdminSendEmail.Input;
+		output: ComAtprotoAdminSendEmail.Output;
+	};
+	'com.atproto.admin.updateAccountEmail': {
+		input: ComAtprotoAdminUpdateAccountEmail.Input;
+	};
+	'com.atproto.admin.updateAccountHandle': {
+		input: ComAtprotoAdminUpdateAccountHandle.Input;
+	};
+	'com.atproto.admin.updateAccountPassword': {
+		input: ComAtprotoAdminUpdateAccountPassword.Input;
+	};
+	'com.atproto.admin.updateSubjectStatus': {
+		input: ComAtprotoAdminUpdateSubjectStatus.Input;
+		output: ComAtprotoAdminUpdateSubjectStatus.Output;
+	};
+	'com.atproto.identity.requestPlcOperationSignature': {};
+	'com.atproto.identity.signPlcOperation': {
+		input: ComAtprotoIdentitySignPlcOperation.Input;
+		output: ComAtprotoIdentitySignPlcOperation.Output;
+	};
+	'com.atproto.identity.submitPlcOperation': {
+		input: ComAtprotoIdentitySubmitPlcOperation.Input;
+	};
+	'com.atproto.identity.updateHandle': {
+		input: ComAtprotoIdentityUpdateHandle.Input;
+	};
+	'com.atproto.moderation.createReport': {
+		input: ComAtprotoModerationCreateReport.Input;
+		output: ComAtprotoModerationCreateReport.Output;
+	};
+	'com.atproto.repo.applyWrites': {
+		input: ComAtprotoRepoApplyWrites.Input;
+	};
+	'com.atproto.repo.createRecord': {
+		input: ComAtprotoRepoCreateRecord.Input;
+		output: ComAtprotoRepoCreateRecord.Output;
+	};
+	'com.atproto.repo.deleteRecord': {
+		input: ComAtprotoRepoDeleteRecord.Input;
+	};
+	'com.atproto.repo.importRepo': {
+		input: ComAtprotoRepoImportRepo.Input;
+	};
+	'com.atproto.repo.putRecord': {
+		input: ComAtprotoRepoPutRecord.Input;
+		output: ComAtprotoRepoPutRecord.Output;
+	};
+	'com.atproto.repo.uploadBlob': {
+		input: ComAtprotoRepoUploadBlob.Input;
+		output: ComAtprotoRepoUploadBlob.Output;
+	};
+	'com.atproto.server.activateAccount': {};
+	'com.atproto.server.confirmEmail': {
+		input: ComAtprotoServerConfirmEmail.Input;
+	};
+	'com.atproto.server.createAccount': {
+		input: ComAtprotoServerCreateAccount.Input;
+		output: ComAtprotoServerCreateAccount.Output;
+	};
+	'com.atproto.server.createAppPassword': {
+		input: ComAtprotoServerCreateAppPassword.Input;
+		output: ComAtprotoServerCreateAppPassword.Output;
+	};
+	'com.atproto.server.createInviteCode': {
+		input: ComAtprotoServerCreateInviteCode.Input;
+		output: ComAtprotoServerCreateInviteCode.Output;
+	};
+	'com.atproto.server.createInviteCodes': {
+		input: ComAtprotoServerCreateInviteCodes.Input;
+		output: ComAtprotoServerCreateInviteCodes.Output;
+	};
+	'com.atproto.server.createSession': {
+		input: ComAtprotoServerCreateSession.Input;
+		output: ComAtprotoServerCreateSession.Output;
+	};
+	'com.atproto.server.deactivateAccount': {
+		input: ComAtprotoServerDeactivateAccount.Input;
+	};
+	'com.atproto.server.deleteAccount': {
+		input: ComAtprotoServerDeleteAccount.Input;
+	};
+	'com.atproto.server.deleteSession': {};
+	'com.atproto.server.refreshSession': {
+		output: ComAtprotoServerRefreshSession.Output;
+	};
+	'com.atproto.server.requestAccountDelete': {};
+	'com.atproto.server.requestEmailConfirmation': {};
+	'com.atproto.server.requestEmailUpdate': {
+		output: ComAtprotoServerRequestEmailUpdate.Output;
+	};
+	'com.atproto.server.requestPasswordReset': {
+		input: ComAtprotoServerRequestPasswordReset.Input;
+	};
+	'com.atproto.server.reserveSigningKey': {
+		input: ComAtprotoServerReserveSigningKey.Input;
+		output: ComAtprotoServerReserveSigningKey.Output;
+	};
+	'com.atproto.server.resetPassword': {
+		input: ComAtprotoServerResetPassword.Input;
+	};
+	'com.atproto.server.revokeAppPassword': {
+		input: ComAtprotoServerRevokeAppPassword.Input;
+	};
+	'com.atproto.server.updateEmail': {
+		input: ComAtprotoServerUpdateEmail.Input;
+	};
+	'com.atproto.sync.notifyOfUpdate': {
+		input: ComAtprotoSyncNotifyOfUpdate.Input;
+	};
+	'com.atproto.sync.requestCrawl': {
+		input: ComAtprotoSyncRequestCrawl.Input;
+	};
+	'com.atproto.temp.requestPhoneVerification': {
+		input: ComAtprotoTempRequestPhoneVerification.Input;
+	};
+}

packages/client/package.json

···
+{
+	"type": "module",
+	"name": "@atcute/client",
+	"version": "1.0.0",
+	"description": "lightweight and cute API client for AT Protocol",
+	"license": "MIT",
+	"repository": {
+		"url": "https://codeberg.org/mary-ext/atcute"
+	},
+	"files": [
+		"dist/"
+	],
+	"exports": {
+		".": "./dist/index.js",
+		"./lexicons": "./dist/lexicons.js"
+	},
+	"scripts": {
+		"build": "tsc",
+		"generate": "./scripts/generate-lexicons.sh",
+		"prepublish": "rm -rf dist; pnpm run build"
+	},
+	"devDependencies": {
+		"@atcute/lex-cli": "workspace:^"
+	}
+}

packages/client/scripts/generate-lexicons.sh

···
+#/usr/bin/env bash
+
+pnpm exec lex-cli generate-main \
+	../../lexicons/com/atproto/**/*.json \
+	-o lib/lexicons.ts \
+	--description "Contains type declarations for AT Protocol lexicons"

packages/client/tsconfig.json

···
+{
+	"compilerOptions": {
+		"outDir": "dist/",
+		"esModuleInterop": true,
+		"skipLibCheck": true,
+		"target": "ESNext",
+		"allowJs": true,
+		"resolveJsonModule": true,
+		"moduleDetection": "force",
+		"isolatedModules": true,
+		"verbatimModuleSyntax": true,
+		"strict": true,
+		"noImplicitOverride": true,
+		"noUnusedLocals": true,
+		"noUnusedParameters": true,
+		"noFallthroughCasesInSwitch": true,
+		"module": "NodeNext",
+		"sourceMap": true,
+		"declaration": true,
+	},
+	"include": ["lib"],
+}

packages/lex-cli/cli.mjs

···
+import './dist/index.js';

packages/lex-cli/package.json

···
+{
+	"type": "module",
+	"name": "@atcute/lex-cli",
+	"version": "1.0.0",
+	"description": "cli tool to generate type definitions for atcute",
+	"license": "MIT",
+	"repository": {
+		"url": "https://codeberg.org/mary-ext/atcute"
+	},
+	"files": [
+		"dist/",
+		"cli.mjs"
+	],
+	"bin": "./cli.mjs",
+	"scripts": {
+		"build": "tsc",
+		"prepublish": "rm -rf dist; pnpm run build"
+	},
+	"dependencies": {
+		"@badrap/valita": "^0.3.9",
+		"@externdefs/collider": "^0.1.0",
+		"picocolors": "^1.0.1",
+		"prettier": "^3.3.3"
+	},
+	"devDependencies": {
+		"@types/node": "^22.3.0"
+	}
+}

packages/lex-cli/src/generator.ts

···
+import { readFile } from 'node:fs/promises';
+
+import {
+	documentSchema,
+	type DocumentSchema,
+	type RefVariantSchema,
+	type UserTypeSchema,
+	type XrpcParametersSchema,
+} from './schema.js';
+
+const toUpperCache: Record<string, string> = Object.create(null);
+const toNamespaceCache: Record<string, string> = Object.create(null);
+
+const toUpper = (s: string) => {
+	return (toUpperCache[s] ??= s[0].toUpperCase() + s.slice(1));
+};
+const toNamespace = (s: string) => {
+	return (toNamespaceCache[s] ??= s.replace(/^\w|\.\w/g, (m) => m[m.length === 1 ? 0 : 1].toUpperCase()));
+};
+
+const sortName: (a: string, b: string) => number = (() => {
+	const collator = new Intl.Collator('en-US');
+	return (a, b) => collator.compare(a, b);
+})();
+
+const sortDefinition = (a: string, b: string) => {
+	const aIsMain = a === 'main';
+	const bIsMain = b === 'main';
+
+	if (aIsMain === bIsMain) {
+		return sortName(a, b);
+	}
+
+	return +bIsMain - +aIsMain;
+};
+
+const writeJsdoc = (descriptions: string[]) => {
+	const len = descriptions.length;
+
+	if (len === 0) {
+		return '';
+	}
+
+	if (len === 1) {
+		return `\n/** ${descriptions[0]} */\n`;
+	}
+
+	let jsdoc = '\n/**';
+
+	for (let idx = 0; idx < len; idx++) {
+		const suffix = idx !== len - 1 && descriptions[idx + 1][0] !== '@';
+		jsdoc += `\n * ${descriptions[idx]}${suffix ? ` \\` : ''}`;
+	}
+
+	jsdoc += `\n */\n`;
+	return jsdoc;
+};
+
+const resolveType = (
+	nsid: string,
+	def: UserTypeSchema | RefVariantSchema | XrpcParametersSchema,
+): { value: string; descriptions: string[] } => {
+	const type = def.type;
+
+	/** @type {string[]} */
+	let descs = [];
+	let val = 'unknown';
+
+	if (def.description) {
+		descs.push(def.description);
+
+		if (def.description.toLowerCase().startsWith('deprecated')) {
+			descs.push(`@deprecated`);
+		}
+	}
+
+	if (type === 'unknown') {
+		val = 'unknown';
+	} else if (type === 'cid-link') {
+		val = 'At.CIDLink';
+	} else if (type === 'integer') {
+		val = 'number';
+
+		if (def.minimum !== undefined) {
+			descs.push(`Minimum: ${def.minimum}`);
+		}
+
+		if (def.maximum !== undefined) {
+			descs.push(`Maximum: ${def.maximum}`);
+		}
+
+		if (def.default !== undefined) {
+			descs.push(`@default ${def.default}`);
+		}
+	} else if (type === 'boolean') {
+		val = 'boolean';
+
+		if (def.default !== undefined) {
+			descs.push(`@default ${def.default}`);
+		}
+	} else if (type === 'string') {
+		const enums = def.enum;
+		const known = def.knownValues;
+		const format = def.format;
+
+		if (format !== undefined) {
+			if (format === 'did') {
+				val = 'At.DID';
+			} else if (format === 'cid') {
+				val = 'At.CID';
+			} else if (format === 'handle') {
+				val = 'At.Handle';
+			} else if (format === 'at-uri') {
+				val = 'At.Uri';
+			} else if (
+				format === 'at-identifier' ||
+				format === 'datetime' ||
+				format === 'language' ||
+				format === 'nsid' ||
+				format === 'uri'
+			) {
+				// deliberately ignored
+				val = 'string';
+			} else {
+				console.warn(`${nsid}: unknown format ${format}`);
+				val = 'string';
+			}
+		} else {
+			if (def.minLength !== undefined) {
+				descs.push(`Minimum string length: ${def.minLength}`);
+			}
+
+			if (def.maxLength !== undefined) {
+				descs.push(`Maximum string length: ${def.maxLength}`);
+			}
+
+			if (def.maxGraphemes !== undefined) {
+				descs.push(`Maximum grapheme length: ${def.maxGraphemes}`);
+			}
+
+			if (def.default !== undefined) {
+				descs.push(`@default ${JSON.stringify(def.default)}`);
+			}
+
+			if (enums) {
+				val = enums.map((val) => JSON.stringify(val)).join('|');
+			} else if (known) {
+				val = `${known
+					.toSorted(sortName)
+					.map((val) => JSON.stringify(val))
+					.join('|')} | (string & {})`;
+			} else {
+				val = 'string';
+			}
+		}
+	} else if (type === 'array') {
+		const { value, descriptions } = resolveType(`${nsid}/0`, def.items);
+
+		if (def.minLength !== undefined) {
+			descs.push(`Minimum array length: ${def.minLength}`);
+		}
+
+		if (def.maxLength !== undefined) {
+			descs.push(`Maximum array length: ${def.maxLength}`);
+		}
+
+		val = `(${value})[]`;
+		descs = descs.concat(descriptions);
+	} else if (type === 'blob') {
+		// const accept = def.accept?.map((mime) => `\`${mime.replaceAll('*', '${string}')}\``);
+		// val = `At.Blob${accept ? `<${accept.join('|')}>` : ''}`;
+
+		val = `At.Blob`;
+	} else if (type === 'ref') {
+		const [ns, ref] = def.ref.split('#');
+		val = (ns ? toNamespace(ns) + '.' : '') + (ref ? toUpper(ref) : 'Main');
+	} else if (type === 'union') {
+		const refs = def.refs.toSorted(sortName).map((raw) => {
+			const [ns, ref] = raw.split('#');
+			return (ns ? toNamespace(ns) + '.' : '') + (ref ? toUpper(ref) : 'Main');
+		});
+
+		val = `Brand.Union<${refs.join('|')}>`;
+	} else if (type === 'object' || type === 'params') {
+		const required = def.required;
+		const nullable = type === 'object' ? def.nullable : [];
+		const properties = def.properties;
+
+		const propKeys = Object.keys(properties).sort((a, b) => {
+			const aIsOptional = !required || !required.includes(a);
+			const bIsOptional = !required || !required.includes(b);
+
+			if (aIsOptional === bIsOptional) {
+				return sortName(a, b);
+			}
+
+			return +aIsOptional - +bIsOptional;
+		});
+
+		let chunk = '{';
+
+		for (const prop of propKeys) {
+			const isOptional = !required || !required.includes(prop);
+			const isNullable = nullable !== undefined && nullable.includes(prop);
+			const { value, descriptions } = resolveType(`${nsid}/${prop}`, properties[prop]);
+
+			chunk += writeJsdoc(descriptions);
+			chunk += `${prop}${isOptional ? `?` : ``}:${value}${isNullable ? `| null` : ``};`;
+		}
+
+		chunk += '}';
+		val = chunk;
+	} else if (type === 'bytes') {
+		val = `At.Bytes`;
+	} else {
+		console.log(`${nsid}: unknown type ${type}`);
+	}
+
+	return { value: val, descriptions: descs };
+};
+
+export interface GenerateDefinitionsOptions {
+	files: string[];
+	main: boolean;
+	banner?: string;
+	description?: string;
+}
+
+const mainPrelude = `type ObjectOmit<T, K extends keyof any> = Omit<T, K>;
+
+/** Handles type branding in objects */
+export declare namespace Brand {
+	/** Symbol used to brand objects, this does not actually exist in runtime */
+	const Type: unique symbol;
+
+	/** Get the intended \`$type\` field */
+	type GetType<T extends { [Type]?: string }> = NonNullable<T[typeof Type]>;
+
+	/** Creates a union of objects where it's discriminated by \`$type\` field. */
+	type Union<T extends { [Type]?: string }> = T extends any ? T & { $type: GetType<T> } : never;
+
+	/** Omits the type branding from object */
+	type Omit<T extends { [Type]?: string }> = ObjectOmit<T, typeof Type>;
+}
+
+/** Base AT Protocol schema types */
+export declare namespace At {
+	/** CID string */
+	type CID = string;
+
+	/** DID of a user */
+	type DID = \`did:\${string}\`;
+
+	/** User handle */
+	type Handle = string;
+
+	/** URI string */
+	type Uri = string;
+
+	/** Object containing a CID string */
+	interface CIDLink {
+		$link: CID;
+	}
+
+	/** Object containing a base64-encoded bytes */
+	interface Bytes {
+		$bytes: string;
+	}
+
+	/** Blob interface */
+	interface Blob<T extends string = string> {
+		$type: 'blob';
+		mimeType: T;
+		ref: {
+			$link: string;
+		};
+		size: number;
+	}
+}`;
+
+export const generateDefinitions = async (opts: GenerateDefinitionsOptions) => {
+	const { files, main, banner, description } = opts;
+
+	let queries = '';
+	let procedures = '';
+	let records = '';
+
+	let code = `/* eslint-disable */
+// This file is automatically generated, do not edit!`;
+
+	if (description) {
+		code += `\n\n/**
+ * @module
+ * ${description}
+ */`;
+	}
+
+	if (main) {
+		code += `\n\n${banner ?? ''}\n${mainPrelude}`;
+	} else {
+		code += `\n\nimport "@atcute/client/lexicons";${banner ?? ''}
+
+declare module "@atcute/client/lexicons" {`;
+	}
+
+	for await (const filename of files.sort(sortName)) {
+		let document: DocumentSchema;
+
+		try {
+			const jsonString = await readFile(filename, 'utf8');
+			document = documentSchema.parse(JSON.parse(jsonString));
+		} catch (err) {
+			throw new Error(`failed to read ${filename}`, { cause: err });
+		}
+
+		const ns = document.id;
+		const tsNamespace = toNamespace(ns);
+
+		const descs = [];
+
+		let chunk = '';
+
+		const definitions = document.defs;
+		const keys = Object.keys(definitions).sort(sortDefinition);
+
+		for (const key of keys) {
+			const def = definitions[key];
+			const type = def.type;
+
+			const nsid = `${ns}${key !== 'main' ? `#${key}` : ''}`;
+			const typeName = key[0].toUpperCase() + key.slice(1);
+
+			if (type === 'string') {
+				const { value, descriptions } = resolveType(nsid, def);
+
+				chunk += writeJsdoc(descriptions);
+				chunk += `type ${typeName} = ${value};`;
+			} else if (type === 'token') {
+				chunk += `type ${typeName} = '${nsid}';`;
+			} else if (type === 'object') {
+				const required = def.required;
+				const nullable = def.nullable;
+				const properties = def.properties;
+
+				const propKeys = Object.keys(properties).sort((a, b) => {
+					const aIsOptional = !required || !required.includes(a);
+					const bIsOptional = !required || !required.includes(b);
+
+					if (aIsOptional === bIsOptional) {
+						return sortName(a, b);
+					}
+
+					return +aIsOptional - +bIsOptional;
+				});
+
+				const descs = [];
+
+				if (def.description) {
+					descs.push(def.description);
+
+					if (def.description.toLowerCase().startsWith('deprecated')) {
+						descs.push(`@deprecated`);
+					}
+				}
+
+				chunk += writeJsdoc(descs);
+				chunk += `interface ${typeName} {`;
+				chunk += `[Brand.Type]?: '${nsid}';`;
+
+				for (const prop of propKeys) {
+					const isOptional = !required || !required.includes(prop);
+					const isNullable = nullable !== undefined && nullable.includes(prop);
+					const { value, descriptions } = resolveType(`${nsid}/${prop}`, properties[prop]);
+
+					chunk += writeJsdoc(descriptions);
+					chunk += `${prop}${isOptional ? `?` : ``}:${value}${isNullable ? `| null` : ``};`;
+				}
+
+				chunk += '}';
+			} else if (type === 'array') {
+				const { value, descriptions } = resolveType(nsid, def.items);
+				const descs = [];
+
+				if (def.maxLength !== undefined) {
+					descs.push(`Maximum array length: ${def.maxLength}`);
+				}
+
+				if (def.minLength !== undefined) {
+					descs.push(`Minimum array length: ${def.minLength}`);
+				}
+
+				chunk += writeJsdoc(descs.concat(descriptions));
+				chunk += `type ${typeName} = (${value})[];`;
+			} else if (type === 'record') {
+				const { value, descriptions } = resolveType(nsid, def.record);
+
+				chunk += writeJsdoc(descriptions);
+				chunk += `interface Record`;
+				chunk += value;
+
+				records += `\n'${nsid}': ${tsNamespace}.Record;`;
+			} else if (type === 'query' || type === 'procedure') {
+				let parameters = def.parameters;
+
+				const input = type === 'procedure' ? def.input : undefined;
+				const output = def.output;
+				const errors = def.errors;
+
+				if (def.description) {
+					descs.push(def.description);
+
+					if (def.description.toLowerCase().startsWith('deprecated')) {
+						descs.push(`@deprecated`);
+					}
+				}
+
+				if (parameters) {
+					if (Object.values(parameters.properties).length === 0) {
+						parameters = undefined;
+					} else {
+						const { value, descriptions } = resolveType(nsid, parameters);
+
+						chunk += writeJsdoc(descriptions);
+						chunk += `interface Params ${value}`;
+					}
+				} else {
+					chunk += `interface Params {}`;
+				}
+
+				if (input) {
+					if (input.encoding === 'application/json') {
+						const { value, descriptions } = resolveType(nsid, input.schema!);
+
+						chunk += writeJsdoc(descriptions);
+
+						if (input.schema!.type === 'object') {
+							chunk += `interface Input ${value}`;
+						} else {
+							chunk += `type Input = ${value};`;
+						}
+					} else {
+						chunk += `type Input = Blob | ArrayBufferView;`;
+					}
+				} else {
+					chunk += `type Input = undefined;`;
+				}
+
+				if (output) {
+					if (output.encoding === 'application/json') {
+						const { value, descriptions } = resolveType(nsid, output.schema!);
+
+						chunk += writeJsdoc(descriptions);
+
+						if (output.schema!.type === 'object') {
+							chunk += `interface Output ${value}`;
+						} else {
+							chunk += `type Output = ${value};`;
+						}
+					} else {
+						chunk += `type Output = Uint8Array;`;
+					}
+				} else {
+					chunk += `type Output = undefined;`;
+				}
+
+				if (errors) {
+					chunk += `interface Errors {`;
+
+					for (const error of errors) {
+						chunk += `${error.name}: {};`;
+					}
+
+					chunk += '}';
+				}
+
+				{
+					let rc = `'${ns}':{\n`;
+
+					if (parameters) {
+						rc += `params: ${tsNamespace}.Params;`;
+					}
+					if (input) {
+						rc += `input: ${tsNamespace}.Input;`;
+					}
+					if (output) {
+						rc += `output: ${tsNamespace}.Output;`;
+					}
+
+					rc += '};';
+
+					if (type === 'query') {
+						queries += rc;
+					} else if (type === 'procedure') {
+						procedures += rc;
+					}
+				}
+			} else if (type === 'blob') {
+				const { value, descriptions } = resolveType(nsid, def);
+
+				chunk += writeJsdoc(descriptions);
+				chunk += `type ${typeName} = ${value};`;
+			} else if (type === 'bytes') {
+				const { value, descriptions } = resolveType(nsid, def);
+
+				chunk += writeJsdoc(descriptions);
+				chunk += `type ${typeName} = ${value};`;
+			} else {
+				console.log(`${nsid}: unhandled type ${type}`);
+			}
+		}
+
+		code += writeJsdoc(descs);
+
+		if (main) {
+			code += `export declare namespace ${tsNamespace} {`;
+		} else {
+			code += `namespace ${tsNamespace} {`;
+		}
+
+		code += chunk;
+		code += `}\n\n`;
+	}
+
+	if (main) {
+		code += `export declare interface Records {${records}}\n\n`;
+		code += `export declare interface Queries {${queries}}\n\n`;
+		code += `export declare interface Procedures {${procedures}}\n\n`;
+	} else {
+		code += `interface Records {${records}}\n\n`;
+		code += `interface Queries {${queries}}\n\n`;
+		code += `interface Procedures {${procedures}}\n\n`;
+		code += '}';
+	}
+
+	return code;
+};

packages/lex-cli/src/index.ts

···
+import { writeFile } from 'node:fs/promises';
+import { basename } from 'node:path';
+
+import * as v from '@badrap/valita';
+import { Builtins, Command, Option, Program } from '@externdefs/collider';
+import pc from 'picocolors';
+import prettier from 'prettier';
+
+import { generateDefinitions } from './generator.js';
+
+const program = new Program({ binaryName: 'lex-cli' });
+
+program.register(Builtins.HelpCommand);
+
+program.register(
+	class GenerateMainLexicons extends Command {
+		static override paths = [['generate-main']];
+
+		static override usage = Command.Usage({
+			description: `Generates the main type definition file`,
+		});
+
+		output = Option.String(['-o', '--output'], {
+			required: false,
+			description: 'Where to save the resulting type definition file, defaults to stdout if not passed',
+			validator: v
+				.string()
+				.assert((v) => basename(v).endsWith('.ts'), `expected output file to end with .ts extension`),
+		});
+
+		desc = Option.String(['--description'], {
+			required: false,
+			description: 'Module description',
+		});
+
+		banner = Option.String(['--banner'], {
+			required: false,
+			description: 'Insert an arbitrary string at the beginning of the module',
+		});
+
+		files = Option.Rest({
+			required: 1,
+			name: 'files',
+		});
+
+		async execute(): Promise<number | void> {
+			let code: string;
+
+			try {
+				code = await generateDefinitions({
+					files: this.files,
+					main: true,
+					banner: this.banner,
+					description: this.desc,
+				});
+			} catch (err) {
+				if (err instanceof Error) {
+					console.error(pc.bold(`${pc.red(`error: `)}: ${err.message}`));
+
+					if (err.cause instanceof Error) {
+						console.error(`  ${pc.gray(`caused by:`)}: ${err.cause.message}`);
+					}
+				} else {
+					console.error(pc.bold(pc.red(`unknown error occured:`)));
+					console.error(err);
+				}
+
+				return 1;
+			}
+
+			const config = await prettier.resolveConfig(this.output || process.cwd(), { editorconfig: true });
+			const formatted = await prettier.format(code, { ...config, parser: 'typescript' });
+
+			if (this.output) {
+				await writeFile(this.output, formatted);
+			} else {
+				console.log(formatted);
+			}
+		}
+	},
+);
+
+program.register(
+	class GenerateLexicons extends Command {
+		static override paths = [['generate']];
+
+		static override usage = Command.Usage({
+			description: `Generates a type definition file`,
+		});
+
+		output = Option.String(['-o', '--output'], {
+			required: false,
+			description: 'Where to save the resulting type definition file, defaults to stdout if not passed',
+			validator: v
+				.string()
+				.assert((v) => basename(v).endsWith('.ts'), `expected output file to end with .ts extension`),
+		});
+
+		desc = Option.String(['--description'], {
+			required: false,
+			description: 'Module description',
+		});
+
+		banner = Option.String(['--banner'], {
+			required: false,
+			description: 'Insert an arbitrary string at the beginning of the module',
+		});
+
+		files = Option.Rest({
+			required: 1,
+			name: 'files',
+		});
+
+		async execute(): Promise<number | void> {
+			let code: string;
+
+			try {
+				code = await generateDefinitions({
+					files: this.files,
+					main: false,
+					banner: this.banner,
+					description: this.desc,
+				});
+			} catch (err) {
+				if (err instanceof Error) {
+					console.error(pc.bold(`${pc.red(`error: `)}: ${err.message}`));
+
+					if (err.cause instanceof Error) {
+						console.error(`  ${pc.gray(`caused by:`)}: ${err.cause.message}`);
+					}
+				} else {
+					console.error(pc.bold(pc.red(`unknown error occured:`)));
+					console.error(err);
+				}
+
+				return 1;
+			}
+
+			const config = await prettier.resolveConfig(this.output || process.cwd(), { editorconfig: true });
+			const formatted = await prettier.format(code, { ...config, parser: 'typescript' });
+
+			if (this.output) {
+				await writeFile(this.output, formatted);
+			} else {
+				console.log(formatted);
+			}
+		}
+	},
+);
+
+const exitCode = await program.run(process.argv.slice(2));
+process.exitCode = exitCode;

packages/lex-cli/src/schema.ts

···
+import * as v from '@badrap/valita';
+
+const integerType = v
+	.number()
+	.assert((v) => Number.isInteger(v) && v >= 0, 'Number is expected to be a positive integer');
+
+export const booleanSchema = v.object({
+	type: v.literal('boolean'),
+	description: v.string().optional(),
+	default: v.boolean().optional(),
+	const: v.boolean().optional(),
+});
+
+export type BooleanSchema = v.Infer<typeof booleanSchema>;
+
+export const integerSchema = v.object({
+	type: v.literal('integer'),
+	description: v.string().optional(),
+	default: integerType.optional(),
+	const: integerType.optional(),
+	enum: v.array(v.number()).optional(),
+	maximum: integerType.optional(),
+	minimum: integerType.optional(),
+});
+
+export type IntegerSchema = v.Infer<typeof integerSchema>;
+
+export const stringSchema = v.object({
+	type: v.literal('string'),
+	description: v.string().optional(),
+	format: v
+		.union(
+			v.literal('at-identifier'),
+			v.literal('at-uri'),
+			v.literal('cid'),
+			v.literal('datetime'),
+			v.literal('did'),
+			v.literal('handle'),
+			v.literal('language'),
+			v.literal('nsid'),
+			v.literal('record-key'),
+			v.literal('tid'),
+			v.literal('uri'),
+		)
+		.optional(),
+	default: v.string().optional(),
+	const: v.string().optional(),
+	enum: v.array(v.string()).optional(),
+	knownValues: v.array(v.string()).optional(),
+	maxLength: integerType.optional(),
+	minLength: integerType.optional(),
+	maxGraphemes: integerType.optional(),
+	minGraphemes: integerType.optional(),
+});
+
+export type StringSchema = v.Infer<typeof stringSchema>;
+
+export const unknownSchema = v.object({
+	type: v.literal('unknown'),
+	description: v.string().optional(),
+});
+
+export type UnknownSchema = v.Infer<typeof unknownSchema>;
+
+export const primitiveSchema = v.union(booleanSchema, integerSchema, stringSchema, unknownSchema);
+
+export type PrimitiveSchema = v.Infer<typeof primitiveSchema>;
+
+export const bytesSchema = v.object({
+	type: v.literal('bytes'),
+	description: v.string().optional(),
+	maxLength: integerType.optional(),
+	minLength: integerType.optional(),
+});
+
+export type BytesSchema = v.Infer<typeof bytesSchema>;
+
+export const cidLinkSchema = v.object({
+	type: v.literal('cid-link'),
+	description: v.string().optional(),
+});
+
+export type CidLinkSchema = v.Infer<typeof cidLinkSchema>;
+
+export const ipldTypeSchema = v.union(bytesSchema, cidLinkSchema);
+
+export type IpldTypeSchema = v.Infer<typeof ipldTypeSchema>;
+
+export const refSchema = v.object({
+	type: v.literal('ref'),
+	description: v.string().optional(),
+	ref: v.string(),
+});
+
+export type RefSchema = v.Infer<typeof refSchema>;
+
+export const refUnionSchema = v.object({
+	type: v.literal('union'),
+	description: v.string().optional(),
+	refs: v.array(v.string()),
+	closed: v.boolean().default(false),
+});
+
+export type RefUnionSchema = v.Infer<typeof refUnionSchema>;
+
+export const refVariantSchema = v.union(refSchema, refUnionSchema);
+
+export type RefVariantSchema = v.Infer<typeof refVariantSchema>;
+
+export const blobSchema = v.object({
+	type: v.literal('blob'),
+	description: v.string().optional(),
+	accept: v.array(v.string()).optional(),
+	maxSize: integerType.optional(),
+});
+
+export type BlobSchema = v.Infer<typeof blobSchema>;
+
+export const arraySchema = v.object({
+	type: v.literal('array'),
+	description: v.string().optional(),
+	items: v.union(primitiveSchema, ipldTypeSchema, blobSchema, blobSchema, refVariantSchema),
+	maxLength: integerType.optional(),
+	minLength: integerType.optional(),
+});
+
+export type ArraySchema = v.Infer<typeof arraySchema>;
+
+export const primitiveArraySchema = arraySchema.extend({
+	items: primitiveSchema,
+});
+
+export type PrimitiveArraySchema = v.Infer<typeof primitiveArraySchema>;
+
+export const tokenSchema = v.object({
+	type: v.literal('token'),
+	description: v.string().optional(),
+});
+
+export type TokenSchema = v.Infer<typeof tokenSchema>;
+
+const refineRequiredProperties = <T extends { required: string[]; properties: Record<string, unknown> }>(
+	obj: T,
+): v.ValitaResult<T> => {
+	for (const field of obj.required) {
+		if (obj.properties[field] === undefined) {
+			return v.err(`Required field "${field}" not defined`);
+		}
+	}
+
+	return v.ok(obj);
+};
+
+export const objectSchema = v
+	.object({
+		type: v.literal('object'),
+		description: v.string().optional(),
+		required: v.array(v.string()).default<string[]>([]),
+		nullable: v.array(v.string()).default<string[]>([]),
+		properties: v.record(v.union(refVariantSchema, ipldTypeSchema, arraySchema, blobSchema, primitiveSchema)),
+	})
+	.chain(refineRequiredProperties);
+
+export type ObjectSchema = v.Infer<typeof objectSchema>;
+
+export const xrpcParametersSchema = v
+	.object({
+		type: v.literal('params'),
+		description: v.string().optional(),
+		required: v.array(v.string()).default<string[]>([]),
+		properties: v.record(v.union(primitiveSchema, primitiveArraySchema)),
+	})
+	.chain(refineRequiredProperties);
+
+export type XrpcParametersSchema = v.Infer<typeof xrpcParametersSchema>;
+
+export const xrpcBodySchema = v.object({
+	description: v.string().optional(),
+	encoding: v.string(),
+	schema: v.union(refVariantSchema, objectSchema).optional(),
+});
+
+export type XrpcBodySchema = v.Infer<typeof xrpcBodySchema>;
+
+export const xrpcSubscriptionMessageSchema = v.object({
+	description: v.string().optional(),
+	schema: v.union(refVariantSchema, objectSchema).optional(),
+});
+
+export type XrpcSubscriptionMessageSchema = v.Infer<typeof xrpcSubscriptionMessageSchema>;
+
+export const xrpcErrorSchema = v.object({
+	name: v.string(),
+	description: v.string().optional(),
+});
+
+export type XrpcErrorSchema = v.Infer<typeof xrpcErrorSchema>;
+
+export const xrpcQuerySchema = v.object({
+	type: v.literal('query'),
+	description: v.string().optional(),
+	parameters: xrpcParametersSchema.optional(),
+	output: xrpcBodySchema.optional(),
+	errors: v.array(xrpcErrorSchema).optional(),
+});
+
+export type XrpcQuerySchema = v.Infer<typeof xrpcQuerySchema>;
+
+export const xrpcProcedureSchema = v.object({
+	type: v.literal('procedure'),
+	description: v.string().optional(),
+	parameters: xrpcParametersSchema.optional(),
+	input: xrpcBodySchema.optional(),
+	output: xrpcBodySchema.optional(),
+	errors: v.array(xrpcErrorSchema).optional(),
+});
+
+export type XrpcProcedureSchema = v.Infer<typeof xrpcProcedureSchema>;
+
+export const xrpcSubscriptionSchema = v.object({
+	type: v.literal('subscription'),
+	description: v.string().optional(),
+	parameters: xrpcParametersSchema.optional(),
+	message: xrpcSubscriptionMessageSchema.optional(),
+	errors: v.array(xrpcErrorSchema).optional(),
+});
+
+export type XrpcSubscriptionSchema = v.Infer<typeof xrpcSubscriptionSchema>;
+
+export const recordSchema = v.object({
+	type: v.literal('record'),
+	description: v.string().optional(),
+	key: v.string().optional(),
+	record: objectSchema,
+});
+
+export type RecordSchema = v.Infer<typeof objectSchema>;
+
+export const userTypeSchema = v.union(
+	recordSchema,
+	xrpcQuerySchema,
+	xrpcProcedureSchema,
+	xrpcSubscriptionSchema,
+	blobSchema,
+	arraySchema,
+	tokenSchema,
+	objectSchema,
+	booleanSchema,
+	integerSchema,
+	stringSchema,
+	bytesSchema,
+	cidLinkSchema,
+	unknownSchema,
+);
+
+export type UserTypeSchema = v.Infer<typeof userTypeSchema>;
+
+const NSID_RE =
+	/^[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(\.[a-zA-Z]([a-zA-Z]{0,61}[a-zA-Z])?)$/;
+const nsidType = v.string().assert((v) => NSID_RE.test(v), `string doesn't match nsid format`);
+
+export const documentSchema = v
+	.object({
+		lexicon: v.literal(1),
+		id: nsidType,
+		revision: v.number().optional(),
+		description: v.string().optional(),
+		defs: v.record(userTypeSchema),
+	})
+	.chain((doc) => {
+		const defs = doc.defs;
+
+		for (const id in defs) {
+			const def = defs[id];
+			const type = def.type;
+
+			if (
+				id !== 'main' &&
+				(type === 'record' || type === 'query' || type === 'procedure' || type === 'subscription')
+			) {
+				return v.err({ message: `${type} must be the \`main\` definition`, path: ['defs', id] });
+			}
+		}
+
+		return v.ok(doc);
+	});
+
+export type DocumentSchema = v.Infer<typeof documentSchema>;

packages/lex-cli/tsconfig.json

···
+{
+	"compilerOptions": {
+		"outDir": "dist/",
+		"esModuleInterop": true,
+		"skipLibCheck": true,
+		"target": "ESNext",
+		"allowJs": true,
+		"resolveJsonModule": true,
+		"moduleDetection": "force",
+		"isolatedModules": true,
+		"verbatimModuleSyntax": true,
+		"strict": true,
+		"noImplicitOverride": true,
+		"noUnusedLocals": true,
+		"noUnusedParameters": true,
+		"noFallthroughCasesInSwitch": true,
+		"module": "NodeNext",
+		"sourceMap": true,
+		"declaration": true,
+	},
+	"include": ["src"],
+}

pnpm-lock.yaml

···
+lockfileVersion: '9.0'
+
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false
+
+importers:
+
+  .:
+    devDependencies:
+      '@mary/tar':
+        specifier: npm:@jsr/mary__tar@^0.2.4
+        version: '@jsr/mary__tar@0.2.4'
+      prettier:
+        specifier: ^3.3.3
+        version: 3.3.3
+      typescript:
+        specifier: 5.6.0-beta
+        version: 5.6.0-beta
+
+  packages/client:
+    devDependencies:
+      '@atcute/lex-cli':
+        specifier: workspace:^
+        version: link:../lex-cli
+
+  packages/lex-cli:
+    dependencies:
+      '@badrap/valita':
+        specifier: ^0.3.9
+        version: 0.3.9
+      '@externdefs/collider':
+        specifier: ^0.1.0
+        version: 0.1.0(@badrap/valita@0.3.9)
+      picocolors:
+        specifier: ^1.0.1
+        version: 1.0.1
+      prettier:
+        specifier: ^3.3.3
+        version: 3.3.3
+    devDependencies:
+      '@types/node':
+        specifier: ^22.3.0
+        version: 22.3.0
+
+packages:
+
+  '@badrap/valita@0.3.9':
+    resolution: {integrity: sha512-keFt5iCwI6H5lbvhg2ZJCWa1xRffdpk6/LHCaayubaRM2zhnRIIBE1d+2NEzXLSk4Fe/aklGNXVPt7hNkvBH6g==}
+    engines: {node: '>= 16'}
+
+  '@externdefs/collider@0.1.0':
+    resolution: {integrity: sha512-vmFJEKHhftREiuhhK3WIMKk6bGfm7kM9c5HeVElFCbtqajXqCfwY/GR3f1G0qYWCvbtcoBhIZ2O8ia3A2/pjkw==}
+    peerDependencies:
+      '@badrap/valita': ^0.3.9
+
+  '@jsr/mary__tar@0.2.4':
+    resolution: {integrity: sha512-jFjPcZj8DRSukPLZOt6+h74cVFdfdTMG9gzbW67YByCJTD52PEpe2sNcfCSw4mQ8hZBNgwiufCPyYL8hR9yicA==, tarball: https://npm.jsr.io/~/11/@jsr/mary__tar/0.2.4.tgz}
+
+  '@types/node@22.3.0':
+    resolution: {integrity: sha512-nrWpWVaDZuaVc5X84xJ0vNrLvomM205oQyLsRt7OHNZbSHslcWsvgFR7O7hire2ZonjLrWBbedmotmIlJDVd6g==}
+
+  picocolors@1.0.1:
+    resolution: {integrity: sha512-anP1Z8qwhkbmu7MFP5iTt+wQKXgwzf7zTyGlcdzabySa9vd0Xt392U0rVmz9poOaBj0uHJKyyo9/upk0HrEQew==}
+
+  prettier@3.3.3:
+    resolution: {integrity: sha512-i2tDNA0O5IrMO757lfrdQZCc2jPNDVntV0m/+4whiDfWaTKfMNgR7Qz0NAeGz/nRqF4m5/6CLzbP4/liHt12Ew==}
+    engines: {node: '>=14'}
+    hasBin: true
+
+  typescript@5.6.0-beta:
+    resolution: {integrity: sha512-wqVumY25SwHmCJvZPHqbWfjSyWdAqTTUM+LqaPpFccOnln54EZoPr8Ra7qJV8HMEdFYcDc+S5xro0RyvaHvIvw==}
+    engines: {node: '>=14.17'}
+    hasBin: true
+
+  undici-types@6.18.2:
+    resolution: {integrity: sha512-5ruQbENj95yDYJNS3TvcaxPMshV7aizdv/hWYjGIKoANWKjhWNBsr2YEuYZKodQulB1b8l7ILOuDQep3afowQQ==}
+
+snapshots:
+
+  '@badrap/valita@0.3.9': {}
+
+  '@externdefs/collider@0.1.0(@badrap/valita@0.3.9)':
+    dependencies:
+      '@badrap/valita': 0.3.9
+
+  '@jsr/mary__tar@0.2.4': {}
+
+  '@types/node@22.3.0':
+    dependencies:
+      undici-types: 6.18.2
+
+  picocolors@1.0.1: {}
+
+  prettier@3.3.3: {}
+
+  typescript@5.6.0-beta: {}
+
+  undici-types@6.18.2: {}

pnpm-workspace.yaml

···
+packages:
+  - packages/*

scripts/pull-lexicons.js

···
+import * as path from 'node:path';
+import * as fs from 'node:fs/promises';
+
+import { untar } from '@mary/tar';
+import prettier from 'prettier';
+
+const repo = `bluesky-social/atproto`;
+
+async function main() {
+	const config = await prettier.resolveConfig(process.cwd() + '/foo', { editorconfig: true });
+
+	let sha;
+	{
+		console.log(`retrieving latest commit`);
+		const response = await fetch(`https://api.github.com/repos/${repo}/commits?path=lexicons/`);
+
+		if (!response.ok) {
+			console.log(`  response error ${response.status}`);
+			return;
+		}
+
+		const json = await response.json();
+		const latest = json[0];
+
+		if (!latest) {
+			console.log(`  latest commit missing?`);
+			return;
+		}
+
+		sha = latest.sha;
+		console.log(`  got ${sha}`);
+	}
+
+	const tmpdir = `lexicons-tmp/`;
+
+	{
+		console.log(`retrieving zip file`);
+		const response = await fetch(`https://github.com/${repo}/archive/${sha}.tar.gz`);
+
+		if (!response.ok) {
+			console.log(`  response error ${response.status}`);
+			return;
+		}
+
+		const basename = `atproto-${sha}/lexicons/`;
+
+		const ds = new DecompressionStream('gzip');
+		const stream = response.body.pipeThrough(ds);
+
+		const promises = [];
+
+		console.log(`  reading`);
+		for await (const entry of untar(stream)) {
+			if (entry.type === 'file' && entry.name.startsWith(basename)) {
+				const name = entry.name.slice(basename.length);
+				const basedir = tmpdir + path.dirname(name);
+
+				const code = await entry.text();
+
+				const promise = (async () => {
+					const formatted = await prettier.format(code, { ...config, parser: 'json' });
+
+					await fs.mkdir(basedir, { recursive: true });
+					await fs.writeFile(tmpdir + name, formatted);
+				})();
+
+				promises.push(promise);
+			}
+		}
+
+		console.log(`  flushing writes`);
+		await Promise.all(promises);
+	}
+
+	{
+		const source = `https://github.com/${repo}/tree/${sha}/lexicons\n`;
+
+		console.log(`writing readme file`);
+
+		await fs.writeFile(tmpdir + `README.md`, source);
+	}
+
+	{
+		const dest = `lexicons/`;
+
+		console.log(`moving folder`);
+
+		await fs.rm(dest, { recursive: true, force: true });
+		await fs.rename(tmpdir, dest);
+	}
+}
+
+await main();