@atproto/lex-document 0.0.12 → 0.0.14

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @atproto/lex-document
 
+## 0.0.14
+
+### Patch Changes
+
+- [#4660](https://github.com/bluesky-social/atproto/pull/4660) [`ea5df64`](https://github.com/bluesky-social/atproto/commit/ea5df64db9e408d2b320f5f75eb2878aef6bc6df) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Improve validation of `encoding` payload fields in lexicon documents
+
+- Updated dependencies [[`39dea03`](https://github.com/bluesky-social/atproto/commit/39dea03c417a1da069962560505427a7aa25ad7a), [`ea5df64`](https://github.com/bluesky-social/atproto/commit/ea5df64db9e408d2b320f5f75eb2878aef6bc6df), [`ea5df64`](https://github.com/bluesky-social/atproto/commit/ea5df64db9e408d2b320f5f75eb2878aef6bc6df), [`39dea03`](https://github.com/bluesky-social/atproto/commit/39dea03c417a1da069962560505427a7aa25ad7a), [`39dea03`](https://github.com/bluesky-social/atproto/commit/39dea03c417a1da069962560505427a7aa25ad7a), [`ea5df64`](https://github.com/bluesky-social/atproto/commit/ea5df64db9e408d2b320f5f75eb2878aef6bc6df), [`39dea03`](https://github.com/bluesky-social/atproto/commit/39dea03c417a1da069962560505427a7aa25ad7a), [`ea5df64`](https://github.com/bluesky-social/atproto/commit/ea5df64db9e408d2b320f5f75eb2878aef6bc6df), [`ea5df64`](https://github.com/bluesky-social/atproto/commit/ea5df64db9e408d2b320f5f75eb2878aef6bc6df), [`ea5df64`](https://github.com/bluesky-social/atproto/commit/ea5df64db9e408d2b320f5f75eb2878aef6bc6df), [`ea5df64`](https://github.com/bluesky-social/atproto/commit/ea5df64db9e408d2b320f5f75eb2878aef6bc6df), [`ea5df64`](https://github.com/bluesky-social/atproto/commit/ea5df64db9e408d2b320f5f75eb2878aef6bc6df), [`ea5df64`](https://github.com/bluesky-social/atproto/commit/ea5df64db9e408d2b320f5f75eb2878aef6bc6df), [`ea5df64`](https://github.com/bluesky-social/atproto/commit/ea5df64db9e408d2b320f5f75eb2878aef6bc6df)]:
+  - @atproto/lex-schema@0.0.13
+
+## 0.0.13
+
+### Patch Changes
+
+- [#4603](https://github.com/bluesky-social/atproto/pull/4603) [`7b9a98a`](https://github.com/bluesky-social/atproto/commit/7b9a98a763636c5f66a06da11fe6013f29dd9157) Thanks [@matthieusieben](https://github.com/matthieusieben)! - `LexiconSchemaBuilder` returns and more accurately typed `Schema`
+
+- [#4603](https://github.com/bluesky-social/atproto/pull/4603) [`7b9a98a`](https://github.com/bluesky-social/atproto/commit/7b9a98a763636c5f66a06da11fe6013f29dd9157) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Fix validation of `unknown` schema defs (used to allow any value, now requires `LexMap`)
+
+- [#4601](https://github.com/bluesky-social/atproto/pull/4601) [`ed61c62`](https://github.com/bluesky-social/atproto/commit/ed61c62f3161fcde85ee9a93f8ed339c7e06c015) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Fix `exports` field in package.json
+
+- [#4601](https://github.com/bluesky-social/atproto/pull/4601) [`ed61c62`](https://github.com/bluesky-social/atproto/commit/ed61c62f3161fcde85ee9a93f8ed339c7e06c015) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Add JSDoc
+
+- Updated dependencies [[`7b9a98a`](https://github.com/bluesky-social/atproto/commit/7b9a98a763636c5f66a06da11fe6013f29dd9157), [`7b9a98a`](https://github.com/bluesky-social/atproto/commit/7b9a98a763636c5f66a06da11fe6013f29dd9157), [`ed61c62`](https://github.com/bluesky-social/atproto/commit/ed61c62f3161fcde85ee9a93f8ed339c7e06c015), [`7b9a98a`](https://github.com/bluesky-social/atproto/commit/7b9a98a763636c5f66a06da11fe6013f29dd9157), [`7b9a98a`](https://github.com/bluesky-social/atproto/commit/7b9a98a763636c5f66a06da11fe6013f29dd9157), [`ed61c62`](https://github.com/bluesky-social/atproto/commit/ed61c62f3161fcde85ee9a93f8ed339c7e06c015)]:
+  - @atproto/lex-schema@0.0.12
+
 ## 0.0.12
 
 ### Patch Changes

package/dist/lexicon-document.d.ts

@@ -1,11 +1,31 @@
 import { l } from '@atproto/lex-schema';
+/**
+ * Schema for validating Lexicon boolean type definitions.
+ *
+ * Validates boolean field definitions that may include a default value,
+ * a constant value, and an optional description.
+ */
 export declare const lexiconBooleanSchema: l.ObjectSchema<{
     readonly type: l.LiteralSchema<"boolean">;
     readonly default: l.OptionalSchema<l.BooleanSchema>;
     readonly const: l.OptionalSchema<l.BooleanSchema>;
     readonly description: l.OptionalSchema<l.StringSchema<{}>>;
 }>;
+/**
+ * TypeScript type for a Lexicon boolean definition.
+ *
+ * Represents the structure of a boolean field in a Lexicon document,
+ * including optional default, const, and description properties.
+ *
+ * @see {@link lexiconBooleanSchema} for the schema definition
+ */
 export type LexiconBoolean = l.Infer<typeof lexiconBooleanSchema>;
+/**
+ * Schema for validating Lexicon integer type definitions.
+ *
+ * Validates integer field definitions with support for default values,
+ * minimum/maximum constraints, enumerated values, and constant values.
+ */
 export declare const lexiconIntegerSchema: l.ObjectSchema<{
     readonly type: l.LiteralSchema<"integer">;
     readonly default: l.OptionalSchema<l.IntegerSchema>;
@@ -15,7 +35,22 @@ export declare const lexiconIntegerSchema: l.ObjectSchema<{
     readonly const: l.OptionalSchema<l.IntegerSchema>;
     readonly description: l.OptionalSchema<l.StringSchema<{}>>;
 }>;
+/**
+ * TypeScript type for a Lexicon integer definition.
+ *
+ * Represents the structure of an integer field in a Lexicon document,
+ * including optional constraints like minimum, maximum, enum, and const.
+ *
+ * @see {@link lexiconIntegerSchema} for the schema definition
+ */
 export type LexiconInteger = l.Infer<typeof lexiconIntegerSchema>;
+/**
+ * Schema for validating Lexicon string type definitions.
+ *
+ * Validates string field definitions with support for format validation,
+ * length constraints (both character and grapheme-based), enumerated values,
+ * known values, and constant values.
+ */
 export declare const lexiconStringSchema: l.ObjectSchema<{
     readonly type: l.LiteralSchema<"string">;
     readonly format: l.OptionalSchema<l.EnumSchema<l.StringFormat>>;
@@ -29,48 +64,154 @@ export declare const lexiconStringSchema: l.ObjectSchema<{
     readonly knownValues: l.OptionalSchema<l.ArraySchema<l.StringSchema<{}>>>;
     readonly description: l.OptionalSchema<l.StringSchema<{}>>;
 }>;
+/**
+ * TypeScript type for a Lexicon string definition.
+ *
+ * Represents the structure of a string field in a Lexicon document,
+ * including optional format, length constraints, enum, const, and knownValues.
+ *
+ * @see {@link lexiconStringSchema} for the schema definition
+ */
 export type LexiconString = l.Infer<typeof lexiconStringSchema>;
+/**
+ * Schema for validating Lexicon bytes type definitions.
+ *
+ * Validates binary data field definitions with optional length constraints.
+ * Used for raw byte arrays in DAG-CBOR encoding.
+ */
 export declare const lexiconBytesSchema: l.ObjectSchema<{
     readonly type: l.LiteralSchema<"bytes">;
     readonly maxLength: l.OptionalSchema<l.IntegerSchema>;
     readonly minLength: l.OptionalSchema<l.IntegerSchema>;
     readonly description: l.OptionalSchema<l.StringSchema<{}>>;
 }>;
+/**
+ * TypeScript type for a Lexicon bytes definition.
+ *
+ * Represents the structure of a binary data field in a Lexicon document,
+ * including optional minLength and maxLength constraints.
+ *
+ * @see {@link lexiconBytesSchema} for the schema definition
+ */
 export type LexiconBytes = l.Infer<typeof lexiconBytesSchema>;
+/**
+ * Schema for validating Lexicon CID link type definitions.
+ *
+ * Validates Content Identifier (CID) link field definitions.
+ * CIDs are used to reference content-addressed data in IPFS/IPLD.
+ */
 export declare const lexiconCidLinkSchema: l.ObjectSchema<{
     readonly type: l.LiteralSchema<"cid-link">;
     readonly description: l.OptionalSchema<l.StringSchema<{}>>;
 }>;
+/**
+ * TypeScript type for a Lexicon CID link definition.
+ *
+ * Represents the structure of a CID link field in a Lexicon document.
+ *
+ * @see {@link lexiconCidLinkSchema} for the schema definition
+ */
 export type LexiconCid = l.Infer<typeof lexiconCidLinkSchema>;
+/**
+ * Schema for validating Lexicon blob type definitions.
+ *
+ * Validates blob field definitions with optional MIME type acceptance list
+ * and maximum size constraints. Blobs represent uploaded file references.
+ */
 export declare const lexiconBlobSchema: l.ObjectSchema<{
     readonly type: l.LiteralSchema<"blob">;
     readonly accept: l.OptionalSchema<l.ArraySchema<l.StringSchema<{}>>>;
     readonly maxSize: l.OptionalSchema<l.IntegerSchema>;
     readonly description: l.OptionalSchema<l.StringSchema<{}>>;
 }>;
+/**
+ * TypeScript type for a Lexicon blob definition.
+ *
+ * Represents the structure of a blob field in a Lexicon document,
+ * including optional accept list and maxSize constraints.
+ *
+ * @see {@link lexiconBlobSchema} for the schema definition
+ */
 export type LexiconBlob = l.Infer<typeof lexiconBlobSchema>;
+/**
+ * Schema for validating Lexicon unknown type definitions.
+ *
+ * Validates unknown field definitions which accept any valid data.
+ * Used when the schema cannot determine the type ahead of time.
+ */
 export declare const lexiconUnknownSchema: l.ObjectSchema<{
     readonly type: l.LiteralSchema<"unknown">;
     readonly description: l.OptionalSchema<l.StringSchema<{}>>;
 }>;
+/**
+ * TypeScript type for a Lexicon unknown definition.
+ *
+ * Represents the structure of an unknown field in a Lexicon document.
+ *
+ * @see {@link lexiconUnknownSchema} for the schema definition
+ */
 export type LexiconUnknown = l.Infer<typeof lexiconUnknownSchema>;
+/**
+ * Schema for validating Lexicon token type definitions.
+ *
+ * Validates token definitions which represent symbolic constants.
+ * Tokens are used to define enumeration-like values that can be
+ * referenced across different lexicons.
+ */
 export declare const lexiconTokenSchema: l.ObjectSchema<{
     readonly type: l.LiteralSchema<"token">;
     readonly description: l.OptionalSchema<l.StringSchema<{}>>;
 }>;
+/**
+ * TypeScript type for a Lexicon token definition.
+ *
+ * Represents the structure of a token in a Lexicon document.
+ *
+ * @see {@link lexiconTokenSchema} for the schema definition
+ */
 export type LexiconToken = l.Infer<typeof lexiconTokenSchema>;
+/**
+ * Schema for validating Lexicon reference type definitions.
+ *
+ * Validates reference definitions which point to other type definitions
+ * within the same or different Lexicon documents. References use the
+ * format "nsid#defName" for cross-document refs or "#defName" for local refs.
+ */
 export declare const lexiconRefSchema: l.ObjectSchema<{
     readonly type: l.LiteralSchema<"ref">;
     readonly ref: l.StringSchema<{}>;
     readonly description: l.OptionalSchema<l.StringSchema<{}>>;
 }>;
+/**
+ * TypeScript type for a Lexicon reference definition.
+ *
+ * Represents the structure of a reference field in a Lexicon document,
+ * including the ref string pointing to another definition.
+ *
+ * @see {@link lexiconRefSchema} for the schema definition
+ */
 export type LexiconRef = l.Infer<typeof lexiconRefSchema>;
+/**
+ * Schema for validating Lexicon union reference type definitions.
+ *
+ * Validates union definitions which can reference multiple possible types.
+ * The union can be closed (only listed types allowed) or open (allows
+ * additional unlisted types).
+ */
 export declare const lexiconRefUnionSchema: l.ObjectSchema<{
     readonly type: l.LiteralSchema<"union">;
     readonly refs: l.ArraySchema<l.StringSchema<{}>>;
     readonly closed: l.OptionalSchema<l.BooleanSchema>;
     readonly description: l.OptionalSchema<l.StringSchema<{}>>;
 }>;
+/**
+ * TypeScript type for a Lexicon union reference definition.
+ *
+ * Represents the structure of a union field in a Lexicon document,
+ * including an array of reference strings and optional closed flag.
+ *
+ * @see {@link lexiconRefUnionSchema} for the schema definition
+ */
 export type LexiconRefUnion = l.Infer<typeof lexiconRefUnionSchema>;
 declare const ARRAY_ITEMS_SCHEMAS: readonly [l.ObjectSchema<{
     readonly type: l.LiteralSchema<"boolean">;
@@ -123,7 +264,18 @@ declare const ARRAY_ITEMS_SCHEMAS: readonly [l.ObjectSchema<{
     readonly closed: l.OptionalSchema<l.BooleanSchema>;
     readonly description: l.OptionalSchema<l.StringSchema<{}>>;
 }>];
+/**
+ * TypeScript type representing valid item types for Lexicon arrays.
+ *
+ * Union of all types that can appear as items within a Lexicon array definition.
+ */
 export type LexiconArrayItems = l.Infer<(typeof ARRAY_ITEMS_SCHEMAS)[number]>;
+/**
+ * Schema for validating Lexicon array type definitions.
+ *
+ * Validates array field definitions with specified item type and
+ * optional length constraints.
+ */
 export declare const lexiconArraySchema: l.ObjectSchema<{
     readonly type: l.LiteralSchema<"array">;
     readonly items: l.DiscriminatedUnionSchema<"type", readonly [l.ObjectSchema<{
@@ -181,7 +333,22 @@ export declare const lexiconArraySchema: l.ObjectSchema<{
     readonly maxLength: l.OptionalSchema<l.IntegerSchema>;
     readonly description: l.OptionalSchema<l.StringSchema<{}>>;
 }>;
+/**
+ * TypeScript type for a Lexicon array definition.
+ *
+ * Represents the structure of an array field in a Lexicon document,
+ * including the items schema and optional length constraints.
+ *
+ * @see {@link lexiconArraySchema} for the schema definition
+ */
 export type LexiconArray = l.Infer<typeof lexiconArraySchema>;
+/**
+ * Schema for validating Lexicon object type definitions.
+ *
+ * Validates object definitions with named properties, required field lists,
+ * and nullable field lists. Includes refinement to ensure all required
+ * properties are defined in the properties map.
+ */
 export declare const lexiconObjectSchema: l.ObjectSchema<{
     readonly type: l.LiteralSchema<"object">;
     readonly properties: l.DictSchema<l.StringSchema<{}>, l.DiscriminatedUnionSchema<"type", readonly [l.ObjectSchema<{
@@ -295,9 +462,40 @@ export declare const lexiconObjectSchema: l.ObjectSchema<{
     readonly nullable: l.OptionalSchema<l.ArraySchema<l.StringSchema<{}>>>;
     readonly description: l.OptionalSchema<l.StringSchema<{}>>;
 }>;
+/**
+ * TypeScript type for a Lexicon object definition.
+ *
+ * Represents the structure of an object type in a Lexicon document,
+ * including properties map, required array, and nullable array.
+ *
+ * @see {@link lexiconObjectSchema} for the schema definition
+ */
 export type LexiconObject = l.Infer<typeof lexiconObjectSchema>;
+/**
+ * Schema for validating Lexicon record key definitions.
+ *
+ * Validates record key type specifications. Valid values are:
+ * - "any": Any valid record key
+ * - "nsid": Namespaced identifier
+ * - "tid": Timestamp identifier
+ * - "literal:<string>": A specific literal string value
+ */
 export declare const lexiconRecordKeySchema: l.CustomSchema<l.LexiconRecordKey>;
+/**
+ * TypeScript type for valid Lexicon record key values.
+ *
+ * Can be "any", "nsid", "tid", or "literal:<string>".
+ *
+ * @see {@link lexiconRecordKeySchema} for the schema definition
+ */
 export type LexiconRecordKey = l.LexiconRecordKey;
+/**
+ * Schema for validating Lexicon record type definitions.
+ *
+ * Validates record definitions which define the structure of data
+ * stored in AT Protocol repositories. Records have a key type
+ * and an object schema defining the record's data structure.
+ */
 export declare const lexiconRecordSchema: l.ObjectSchema<{
     readonly type: l.LiteralSchema<"record">;
     readonly record: l.ObjectSchema<{
@@ -416,7 +614,22 @@ export declare const lexiconRecordSchema: l.ObjectSchema<{
     readonly description: l.OptionalSchema<l.StringSchema<{}>>;
     readonly key: l.CustomSchema<l.LexiconRecordKey>;
 }>;
+/**
+ * TypeScript type for a Lexicon record definition.
+ *
+ * Represents the structure of a record type in a Lexicon document,
+ * including the key type and the object schema for the record data.
+ *
+ * @see {@link lexiconRecordSchema} for the schema definition
+ */
 export type LexiconRecord = l.Infer<typeof lexiconRecordSchema>;
+/**
+ * Schema for validating Lexicon XRPC method parameters.
+ *
+ * Validates the parameters definition for query and procedure methods.
+ * Parameters can only be primitive types (boolean, integer, string)
+ * or arrays of primitives.
+ */
 export declare const lexiconParameters: l.ObjectSchema<{
     readonly type: l.LiteralSchema<"params">;
     readonly properties: l.DictSchema<l.StringSchema<{}>, l.DiscriminatedUnionSchema<"type", readonly [l.ObjectSchema<{
@@ -479,7 +692,21 @@ export declare const lexiconParameters: l.ObjectSchema<{
     readonly required: l.OptionalSchema<l.ArraySchema<l.StringSchema<{}>>>;
     readonly description: l.OptionalSchema<l.StringSchema<{}>>;
 }>;
+/**
+ * TypeScript type for Lexicon XRPC method parameters.
+ *
+ * Represents the structure of parameters for query and procedure methods.
+ *
+ * @see {@link lexiconParameters} for the schema definition
+ */
 export type LexiconParameters = l.Infer<typeof lexiconParameters>;
+/**
+ * Schema for validating Lexicon XRPC method payloads.
+ *
+ * Validates input/output payload definitions for procedures and queries.
+ * Payloads specify the encoding (MIME type) and optional schema for
+ * the request or response body.
+ */
 export declare const lexiconPayload: l.ObjectSchema<{
     readonly encoding: l.StringSchema<{}>;
     readonly schema: l.OptionalSchema<l.DiscriminatedUnionSchema<"type", readonly [l.ObjectSchema<{
@@ -606,14 +833,42 @@ export declare const lexiconPayload: l.ObjectSchema<{
     }>]>>;
     readonly description: l.OptionalSchema<l.StringSchema<{}>>;
 }>;
+/**
+ * TypeScript type for a Lexicon XRPC payload definition.
+ *
+ * Represents the structure of an input or output payload,
+ * including encoding type and optional schema.
+ *
+ * @see {@link lexiconPayload} for the schema definition
+ */
 export type LexiconPayload = l.Infer<typeof lexiconPayload>;
+/**
+ * Schema for validating Lexicon XRPC error definitions.
+ *
+ * Validates error definitions that can be returned by XRPC methods.
+ * Each error has a name and optional description.
+ */
 export declare const lexiconError: l.ObjectSchema<{
     readonly name: l.StringSchema<{
         readonly minLength: 1;
     }>;
     readonly description: l.OptionalSchema<l.StringSchema<{}>>;
 }>;
+/**
+ * TypeScript type for a Lexicon XRPC error definition.
+ *
+ * Represents an error that can be returned by an XRPC method.
+ *
+ * @see {@link lexiconError} for the schema definition
+ */
 export type LexiconError = l.Infer<typeof lexiconError>;
+/**
+ * Schema for validating Lexicon query (GET) method definitions.
+ *
+ * Validates query method definitions which represent read-only HTTP GET
+ * operations. Queries can have parameters, an output payload, and
+ * defined error types.
+ */
 export declare const lexiconQuerySchema: l.ObjectSchema<{
     readonly type: l.LiteralSchema<"query">;
     readonly parameters: l.OptionalSchema<l.ObjectSchema<{
@@ -812,7 +1067,21 @@ export declare const lexiconQuerySchema: l.ObjectSchema<{
     }>>>;
     readonly description: l.OptionalSchema<l.StringSchema<{}>>;
 }>;
+/**
+ * TypeScript type for a Lexicon query method definition.
+ *
+ * Represents the structure of an XRPC query (GET) method.
+ *
+ * @see {@link lexiconQuerySchema} for the schema definition
+ */
 export type LexiconQuery = l.Infer<typeof lexiconQuerySchema>;
+/**
+ * Schema for validating Lexicon procedure (POST) method definitions.
+ *
+ * Validates procedure method definitions which represent HTTP POST
+ * operations that may modify state. Procedures can have parameters,
+ * input payload, output payload, and defined error types.
+ */
 export declare const lexiconProcedureSchema: l.ObjectSchema<{
     readonly type: l.LiteralSchema<"procedure">;
     readonly parameters: l.OptionalSchema<l.ObjectSchema<{
@@ -1137,7 +1406,21 @@ export declare const lexiconProcedureSchema: l.ObjectSchema<{
     }>>>;
     readonly description: l.OptionalSchema<l.StringSchema<{}>>;
 }>;
+/**
+ * TypeScript type for a Lexicon procedure method definition.
+ *
+ * Represents the structure of an XRPC procedure (POST) method.
+ *
+ * @see {@link lexiconProcedureSchema} for the schema definition
+ */
 export type LexiconProcedure = l.Infer<typeof lexiconProcedureSchema>;
+/**
+ * Schema for validating Lexicon subscription (WebSocket) method definitions.
+ *
+ * Validates subscription method definitions which represent real-time
+ * streaming connections over WebSocket. Subscriptions have parameters,
+ * a message schema defining the streamed data format, and error types.
+ */
 export declare const lexiconSubscriptionSchema: l.ObjectSchema<{
     readonly type: l.LiteralSchema<"subscription">;
     readonly description: l.OptionalSchema<l.StringSchema<{}>>;
@@ -1219,30 +1502,68 @@ export declare const lexiconSubscriptionSchema: l.ObjectSchema<{
         readonly description: l.OptionalSchema<l.StringSchema<{}>>;
     }>>>;
 }>;
+/**
+ * TypeScript type for a Lexicon subscription method definition.
+ *
+ * Represents the structure of an XRPC subscription (WebSocket) method.
+ *
+ * @see {@link lexiconSubscriptionSchema} for the schema definition
+ */
 export type LexiconSubscription = l.Infer<typeof lexiconSubscriptionSchema>;
-declare const lexiconLanguageSchema: l.StringSchema<{
+/**
+ * Schema for validating language codes in Lexicon permission definitions.
+ */
+export declare const lexiconLanguageSchema: l.StringSchema<{
     readonly format: "language";
 }>;
+/**
+ * TypeScript type for a BCP 47 language code string.
+ *
+ * @see {@link lexiconLanguageSchema} for the schema definition
+ */
 export type LexiconLanguage = l.Infer<typeof lexiconLanguageSchema>;
-declare const lexiconLanguageDict: l.DictSchema<l.StringSchema<{
+/**
+ * Schema for validating language-keyed string dictionaries.
+ * Used for localized text in permission definitions.
+ */
+export declare const lexiconLanguageDict: l.DictSchema<l.StringSchema<{
     readonly format: "language";
 }>, l.StringSchema<{}>>;
+/**
+ * TypeScript type for a language-keyed dictionary of localized strings.
+ *
+ * @see {@link lexiconLanguageDict} for the schema definition
+ */
 export type LexiconLanguageDict = l.Infer<typeof lexiconLanguageDict>;
-declare const lexiconPermissionSchema: l.IntersectionSchema<l.ObjectSchema<{
+/**
+ * Schema for validating individual Lexicon permission definitions.
+ */
+export declare const lexiconPermissionSchema: l.IntersectionSchema<l.ObjectSchema<{
     readonly type: l.LiteralSchema<"permission">;
     readonly resource: l.StringSchema<{
         readonly minLength: 1;
     }>;
-}>, l.DictSchema<l.StringSchema<{}>, l.UnionSchema<readonly [l.UnionSchema<readonly [l.BooleanSchema, l.IntegerSchema, l.StringSchema<{}>]>, l.ArraySchema<l.UnionSchema<readonly [l.BooleanSchema, l.IntegerSchema, l.StringSchema<{}>]>>]>>>;
+}>, l.DictSchema<l.StringSchema<{}>, l.UnionSchema<readonly [l.UnionSchema<readonly [l.BooleanSchema, l.IntegerSchema, l.StringSchema<{}>]>, l.ArraySchema<l.BooleanSchema>, l.ArraySchema<l.IntegerSchema>, l.ArraySchema<l.StringSchema<{}>>]>>>;
+/**
+ * TypeScript type for a Lexicon permission definition.
+ *
+ * Represents a single permission with a resource identifier
+ * and optional additional parameters.
+ *
+ * @see {@link lexiconPermissionSchema} for the schema definition
+ */
 export type LexiconPermission = l.Infer<typeof lexiconPermissionSchema>;
-declare const lexiconPermissionSetSchema: l.ObjectSchema<{
+/**
+ * Schema for validating Lexicon permission set definitions.
+ */
+export declare const lexiconPermissionSetSchema: l.ObjectSchema<{
     readonly type: l.LiteralSchema<"permission-set">;
     readonly permissions: l.ArraySchema<l.IntersectionSchema<l.ObjectSchema<{
         readonly type: l.LiteralSchema<"permission">;
         readonly resource: l.StringSchema<{
             readonly minLength: 1;
         }>;
-    }>, l.DictSchema<l.StringSchema<{}>, l.UnionSchema<readonly [l.UnionSchema<readonly [l.BooleanSchema, l.IntegerSchema, l.StringSchema<{}>]>, l.ArraySchema<l.UnionSchema<readonly [l.BooleanSchema, l.IntegerSchema, l.StringSchema<{}>]>>]>>>>;
+    }>, l.DictSchema<l.StringSchema<{}>, l.UnionSchema<readonly [l.UnionSchema<readonly [l.BooleanSchema, l.IntegerSchema, l.StringSchema<{}>]>, l.ArraySchema<l.BooleanSchema>, l.ArraySchema<l.IntegerSchema>, l.ArraySchema<l.StringSchema<{}>>]>>>>;
     readonly title: l.OptionalSchema<l.StringSchema<{}>>;
     readonly 'title:lang': l.OptionalSchema<l.DictSchema<l.StringSchema<{
         readonly format: "language";
@@ -1253,6 +1574,14 @@ declare const lexiconPermissionSetSchema: l.ObjectSchema<{
     }>, l.StringSchema<{}>>>;
     readonly description: l.OptionalSchema<l.StringSchema<{}>>;
 }>;
+/**
+ * TypeScript type for a Lexicon permission set definition.
+ *
+ * Represents a collection of permissions with optional
+ * localized title and detail text.
+ *
+ * @see {@link lexiconPermissionSetSchema} for the schema definition
+ */
 export type LexiconPermissionSet = l.Infer<typeof lexiconPermissionSetSchema>;
 declare const NAMED_LEXICON_SCHEMAS: readonly [l.ObjectSchema<{
     readonly type: l.LiteralSchema<"boolean">;
@@ -1464,6 +1793,12 @@ declare const NAMED_LEXICON_SCHEMAS: readonly [l.ObjectSchema<{
     readonly type: l.LiteralSchema<"token">;
     readonly description: l.OptionalSchema<l.StringSchema<{}>>;
 }>];
+/**
+ * TypeScript type for any named Lexicon definition.
+ *
+ * Union of all definition types that can appear in the defs section
+ * of a Lexicon document (excluding main-only types).
+ */
 export type NamedLexiconDefinition = l.Infer<(typeof NAMED_LEXICON_SCHEMAS)[number]>;
 declare const MAIN_LEXICON_SCHEMAS: readonly [l.ObjectSchema<{
     readonly type: l.LiteralSchema<"permission-set">;
@@ -1472,7 +1807,7 @@ declare const MAIN_LEXICON_SCHEMAS: readonly [l.ObjectSchema<{
         readonly resource: l.StringSchema<{
             readonly minLength: 1;
         }>;
-    }>, l.DictSchema<l.StringSchema<{}>, l.UnionSchema<readonly [l.UnionSchema<readonly [l.BooleanSchema, l.IntegerSchema, l.StringSchema<{}>]>, l.ArraySchema<l.UnionSchema<readonly [l.BooleanSchema, l.IntegerSchema, l.StringSchema<{}>]>>]>>>>;
+    }>, l.DictSchema<l.StringSchema<{}>, l.UnionSchema<readonly [l.UnionSchema<readonly [l.BooleanSchema, l.IntegerSchema, l.StringSchema<{}>]>, l.ArraySchema<l.BooleanSchema>, l.ArraySchema<l.IntegerSchema>, l.ArraySchema<l.StringSchema<{}>>]>>>>;
     readonly title: l.OptionalSchema<l.StringSchema<{}>>;
     readonly 'title:lang': l.OptionalSchema<l.DictSchema<l.StringSchema<{
         readonly format: "language";
@@ -2409,11 +2744,66 @@ declare const MAIN_LEXICON_SCHEMAS: readonly [l.ObjectSchema<{
     readonly type: l.LiteralSchema<"token">;
     readonly description: l.OptionalSchema<l.StringSchema<{}>>;
 }>];
+/**
+ * TypeScript type for main Lexicon definitions.
+ *
+ * Union of all definition types that can appear as the "main" entry
+ * in a Lexicon document's defs section.
+ */
 export type MainLexiconDefinition = l.Infer<(typeof MAIN_LEXICON_SCHEMAS)[number]>;
+/**
+ * Schema for validating Lexicon document identifiers (NSIDs).
+ *
+ * Validates that the identifier follows the Namespaced Identifier format
+ * (e.g., "com.atproto.repo.createRecord").
+ */
 export declare const lexiconIdentifierSchema: l.StringSchema<{
     readonly format: "nsid";
 }>;
+/**
+ * TypeScript type for a Lexicon document identifier.
+ *
+ * A Namespaced Identifier (NSID) string in reverse-domain format.
+ *
+ * @see {@link lexiconIdentifierSchema} for the schema definition
+ */
 export type LexiconIdentifier = l.Infer<typeof lexiconIdentifierSchema>;
+/**
+ * Schema for validating complete Lexicon document structures.
+ *
+ * Validates the top-level structure of a Lexicon document, including:
+ * - `lexicon`: Must be 1 (the current Lexicon version)
+ * - `id`: The document's NSID
+ * - `revision`: Optional version number
+ * - `description`: Optional document description
+ * - `defs`: Map of definition names to their schemas
+ *
+ * The "main" definition (if present) can be any main-only type,
+ * while other definitions are limited to named types.
+ *
+ * @example
+ * ```ts
+ * const result = lexiconDocumentSchema.parse({
+ *   lexicon: 1,
+ *   id: 'com.example.getProfile',
+ *   defs: {
+ *     main: {
+ *       type: 'query',
+ *       output: {
+ *         encoding: 'application/json',
+ *         schema: { type: 'ref', ref: '#profile' }
+ *       }
+ *     },
+ *     profile: {
+ *       type: 'object',
+ *       properties: {
+ *         name: { type: 'string' }
+ *       }
+ *     }
+ *   }
+ * })
+ * ```
+ */
 export declare const lexiconDocumentSchema: l.ObjectSchema<{
     readonly lexicon: l.LiteralSchema<1>;
     readonly id: l.StringSchema<{
@@ -2429,7 +2819,7 @@ export declare const lexiconDocumentSchema: l.ObjectSchema<{
                 readonly resource: l.StringSchema<{
                     readonly minLength: 1;
                 }>;
-            }>, l.DictSchema<l.StringSchema<{}>, l.UnionSchema<readonly [l.UnionSchema<readonly [l.BooleanSchema, l.IntegerSchema, l.StringSchema<{}>]>, l.ArraySchema<l.UnionSchema<readonly [l.BooleanSchema, l.IntegerSchema, l.StringSchema<{}>]>>]>>>>;
+            }>, l.DictSchema<l.StringSchema<{}>, l.UnionSchema<readonly [l.UnionSchema<readonly [l.BooleanSchema, l.IntegerSchema, l.StringSchema<{}>]>, l.ArraySchema<l.BooleanSchema>, l.ArraySchema<l.IntegerSchema>, l.ArraySchema<l.StringSchema<{}>>]>>>>;
             readonly title: l.OptionalSchema<l.StringSchema<{}>>;
             readonly 'title:lang': l.OptionalSchema<l.DictSchema<l.StringSchema<{
                 readonly format: "language";
@@ -3579,6 +3969,14 @@ export declare const lexiconDocumentSchema: l.ObjectSchema<{
         readonly description: l.OptionalSchema<l.StringSchema<{}>>;
     }>]>>>;
 }>;
+/**
+ * TypeScript type for a complete Lexicon document.
+ *
+ * Represents the full structure of a Lexicon JSON document,
+ * including the version, identifier, and all type definitions.
+ *
+ * @see {@link lexiconDocumentSchema} for the schema definition
+ */
 export type LexiconDocument = l.Infer<typeof lexiconDocumentSchema>;
 export {};
 //# sourceMappingURL=lexicon-document.d.ts.map