@atproto/lex-document 0.0.21 → 0.1.0-next.0

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @atproto/lex-document
 
+## 0.1.0-next.0
+
+### Minor Changes
+
+- [#4929](https://github.com/bluesky-social/atproto/pull/4929) [`bb7491c`](https://github.com/bluesky-social/atproto/commit/bb7491c29e06181e1d2f8cf6eb454f9bb8ab961b) Thanks [@devinivy](https://github.com/devinivy)! - **BREAKING:** Drop support for Node.js 18 and 20. Node.js 22 is now the minimum supported version. Docker images now use Node.js 24.
+
+- [#4943](https://github.com/bluesky-social/atproto/pull/4943) [`07ae5d4`](https://github.com/bluesky-social/atproto/commit/07ae5d4452df51e045e0239da7a04cf0bc154028) Thanks [@devinivy](https://github.com/devinivy)! - **BREAKING:** Convert to pure ESM. All packages now ship `"type": "module"` with ES module output and Node16 module resolution.
+
+  Node.js 22's `require()` compatibility layer can still load these packages in CommonJS code.
+
+- [#4930](https://github.com/bluesky-social/atproto/pull/4930) [`042df15`](https://github.com/bluesky-social/atproto/commit/042df15087c0e62cd1e715fcbf58852fab875af9) Thanks [@devinivy](https://github.com/devinivy)! - Build with TypeScript 6.0. Emitted `.d.ts` files now use TypeScript 6's stricter `Uint8Array<ArrayBuffer>` typing in places where Web/Node APIs require buffer-backed (not shared-memory) byte arrays. Consumers compiling against these types on older TypeScript should see no runtime impact, but may need to widen or cast in spots that previously relied on `Uint8Array` defaulting to `<ArrayBufferLike>`.
+
+  Internal: tsconfig `moduleResolution: "node"` is silenced via `ignoreDeprecations: "6.0"` for now; the proper migration to `node16`/`bundler` resolution is deferred.
+
+### Patch Changes
+
+- Updated dependencies [[`bb7491c`](https://github.com/bluesky-social/atproto/commit/bb7491c29e06181e1d2f8cf6eb454f9bb8ab961b), [`07ae5d4`](https://github.com/bluesky-social/atproto/commit/07ae5d4452df51e045e0239da7a04cf0bc154028), [`042df15`](https://github.com/bluesky-social/atproto/commit/042df15087c0e62cd1e715fcbf58852fab875af9)]:
+  - @atproto/lex-schema@0.1.0-next.0
+
 ## 0.0.21
 
 ### Patch Changes

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import 'core-js/modules/esnext.symbol.async-dispose';
-import 'core-js/modules/esnext.symbol.dispose';
+import 'core-js/es/symbol/async-dispose.js';
+import 'core-js/es/symbol/dispose.js';
 export * from './lexicon-document.js';
 export * from './lexicon-indexer.js';
 export * from './lexicon-schema-builder.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,6CAA6C,CAAA;AACpD,OAAO,uCAAuC,CAAA;AAE9C,cAAc,uBAAuB,CAAA;AACrC,cAAc,sBAAsB,CAAA;AACpC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,+BAA+B,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,oCAAoC,CAAA;AAC3C,OAAO,8BAA8B,CAAA;AAErC,cAAc,uBAAuB,CAAA;AACrC,cAAc,sBAAsB,CAAA;AACpC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,+BAA+B,CAAA"}

package/dist/index.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-require("core-js/modules/esnext.symbol.async-dispose");
-require("core-js/modules/esnext.symbol.dispose");
-tslib_1.__exportStar(require("./lexicon-document.js"), exports);
-tslib_1.__exportStar(require("./lexicon-indexer.js"), exports);
-tslib_1.__exportStar(require("./lexicon-schema-builder.js"), exports);
-tslib_1.__exportStar(require("./lexicon-iterable-indexer.js"), exports);
+import 'core-js/es/symbol/async-dispose.js';
+import 'core-js/es/symbol/dispose.js';
+export * from './lexicon-document.js';
+export * from './lexicon-indexer.js';
+export * from './lexicon-schema-builder.js';
+export * from './lexicon-iterable-indexer.js';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,uDAAoD;AACpD,iDAA8C;AAE9C,gEAAqC;AACrC,+DAAoC;AACpC,sEAA2C;AAC3C,wEAA6C","sourcesContent":["import 'core-js/modules/esnext.symbol.async-dispose'\nimport 'core-js/modules/esnext.symbol.dispose'\n\nexport * from './lexicon-document.js'\nexport * from './lexicon-indexer.js'\nexport * from './lexicon-schema-builder.js'\nexport * from './lexicon-iterable-indexer.js'\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,oCAAoC,CAAA;AAC3C,OAAO,8BAA8B,CAAA;AAErC,cAAc,uBAAuB,CAAA;AACrC,cAAc,sBAAsB,CAAA;AACpC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,+BAA+B,CAAA","sourcesContent":["import 'core-js/es/symbol/async-dispose.js'\nimport 'core-js/es/symbol/dispose.js'\n\nexport * from './lexicon-document.js'\nexport * from './lexicon-indexer.js'\nexport * from './lexicon-schema-builder.js'\nexport * from './lexicon-iterable-indexer.js'\n"]}

package/dist/lexicon-document.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.lexiconDocumentSchema = exports.lexiconIdentifierSchema = exports.lexiconPermissionSetSchema = exports.lexiconPermissionSchema = exports.lexiconLanguageDict = exports.lexiconLanguageSchema = exports.lexiconSubscriptionSchema = exports.lexiconProcedureSchema = exports.lexiconQuerySchema = exports.lexiconError = exports.lexiconPayload = exports.lexiconParameters = exports.lexiconRecordSchema = exports.lexiconRecordKeySchema = exports.lexiconObjectSchema = exports.lexiconArraySchema = exports.lexiconRefUnionSchema = exports.lexiconRefSchema = exports.lexiconTokenSchema = exports.lexiconUnknownSchema = exports.lexiconBlobSchema = exports.lexiconCidLinkSchema = exports.lexiconBytesSchema = exports.lexiconStringSchema = exports.lexiconIntegerSchema = exports.lexiconBooleanSchema = void 0;
-const lex_schema_1 = require("@atproto/lex-schema");
+import { l } from '@atproto/lex-schema';
 // https://atproto.com/specs/lexicon
 // "Concrete" Types
 /**
@@ -10,11 +7,11 @@ const lex_schema_1 = require("@atproto/lex-schema");
  * Validates boolean field definitions that may include a default value,
  * a constant value, and an optional description.
  */
-exports.lexiconBooleanSchema = lex_schema_1.l.object({
-    type: lex_schema_1.l.literal('boolean'),
-    default: lex_schema_1.l.optional(lex_schema_1.l.boolean()),
-    const: lex_schema_1.l.optional(lex_schema_1.l.boolean()),
-    description: lex_schema_1.l.optional(lex_schema_1.l.string()),
+export const lexiconBooleanSchema = l.object({
+    type: l.literal('boolean'),
+    default: l.optional(l.boolean()),
+    const: l.optional(l.boolean()),
+    description: l.optional(l.string()),
 });
 /**
  * Schema for validating Lexicon integer type definitions.
@@ -22,14 +19,14 @@ exports.lexiconBooleanSchema = lex_schema_1.l.object({
  * Validates integer field definitions with support for default values,
  * minimum/maximum constraints, enumerated values, and constant values.
  */
-exports.lexiconIntegerSchema = lex_schema_1.l.object({
-    type: lex_schema_1.l.literal('integer'),
-    default: lex_schema_1.l.optional(lex_schema_1.l.integer()),
-    minimum: lex_schema_1.l.optional(lex_schema_1.l.integer()),
-    maximum: lex_schema_1.l.optional(lex_schema_1.l.integer()),
-    enum: lex_schema_1.l.optional(lex_schema_1.l.array(lex_schema_1.l.integer())),
-    const: lex_schema_1.l.optional(lex_schema_1.l.integer()),
-    description: lex_schema_1.l.optional(lex_schema_1.l.string()),
+export const lexiconIntegerSchema = l.object({
+    type: l.literal('integer'),
+    default: l.optional(l.integer()),
+    minimum: l.optional(l.integer()),
+    maximum: l.optional(l.integer()),
+    enum: l.optional(l.array(l.integer())),
+    const: l.optional(l.integer()),
+    description: l.optional(l.string()),
 });
 /**
  * Schema for validating Lexicon string type definitions.
@@ -38,18 +35,18 @@ exports.lexiconIntegerSchema = lex_schema_1.l.object({
  * length constraints (both character and grapheme-based), enumerated values,
  * known values, and constant values.
  */
-exports.lexiconStringSchema = lex_schema_1.l.object({
-    type: lex_schema_1.l.literal('string'),
-    format: lex_schema_1.l.optional(lex_schema_1.l.enum(lex_schema_1.l.STRING_FORMATS)),
-    default: lex_schema_1.l.optional(lex_schema_1.l.string()),
-    minLength: lex_schema_1.l.optional(lex_schema_1.l.integer()),
-    maxLength: lex_schema_1.l.optional(lex_schema_1.l.integer()),
-    minGraphemes: lex_schema_1.l.optional(lex_schema_1.l.integer()),
-    maxGraphemes: lex_schema_1.l.optional(lex_schema_1.l.integer()),
-    enum: lex_schema_1.l.optional(lex_schema_1.l.array(lex_schema_1.l.string())),
-    const: lex_schema_1.l.optional(lex_schema_1.l.string()),
-    knownValues: lex_schema_1.l.optional(lex_schema_1.l.array(lex_schema_1.l.string())),
-    description: lex_schema_1.l.optional(lex_schema_1.l.string()),
+export const lexiconStringSchema = l.object({
+    type: l.literal('string'),
+    format: l.optional(l.enum(l.STRING_FORMATS)),
+    default: l.optional(l.string()),
+    minLength: l.optional(l.integer()),
+    maxLength: l.optional(l.integer()),
+    minGraphemes: l.optional(l.integer()),
+    maxGraphemes: l.optional(l.integer()),
+    enum: l.optional(l.array(l.string())),
+    const: l.optional(l.string()),
+    knownValues: l.optional(l.array(l.string())),
+    description: l.optional(l.string()),
 });
 /**
  * Schema for validating Lexicon bytes type definitions.
@@ -57,11 +54,11 @@ exports.lexiconStringSchema = lex_schema_1.l.object({
  * Validates binary data field definitions with optional length constraints.
  * Used for raw byte arrays in DAG-CBOR encoding.
  */
-exports.lexiconBytesSchema = lex_schema_1.l.object({
-    type: lex_schema_1.l.literal('bytes'),
-    maxLength: lex_schema_1.l.optional(lex_schema_1.l.integer()),
-    minLength: lex_schema_1.l.optional(lex_schema_1.l.integer()),
-    description: lex_schema_1.l.optional(lex_schema_1.l.string()),
+export const lexiconBytesSchema = l.object({
+    type: l.literal('bytes'),
+    maxLength: l.optional(l.integer()),
+    minLength: l.optional(l.integer()),
+    description: l.optional(l.string()),
 });
 /**
  * Schema for validating Lexicon CID link type definitions.
@@ -69,9 +66,9 @@ exports.lexiconBytesSchema = lex_schema_1.l.object({
  * Validates Content Identifier (CID) link field definitions.
  * CIDs are used to reference content-addressed data in IPFS/IPLD.
  */
-exports.lexiconCidLinkSchema = lex_schema_1.l.object({
-    type: lex_schema_1.l.literal('cid-link'),
-    description: lex_schema_1.l.optional(lex_schema_1.l.string()),
+export const lexiconCidLinkSchema = l.object({
+    type: l.literal('cid-link'),
+    description: l.optional(l.string()),
 });
 /**
  * Schema for validating Lexicon blob type definitions.
@@ -79,25 +76,25 @@ exports.lexiconCidLinkSchema = lex_schema_1.l.object({
  * Validates blob field definitions with optional MIME type acceptance list
  * and maximum size constraints. Blobs represent uploaded file references.
  */
-exports.lexiconBlobSchema = lex_schema_1.l.object({
-    type: lex_schema_1.l.literal('blob'),
-    accept: lex_schema_1.l.optional(lex_schema_1.l.array(lex_schema_1.l.string())),
-    maxSize: lex_schema_1.l.optional(lex_schema_1.l.integer()),
-    description: lex_schema_1.l.optional(lex_schema_1.l.string()),
+export const lexiconBlobSchema = l.object({
+    type: l.literal('blob'),
+    accept: l.optional(l.array(l.string())),
+    maxSize: l.optional(l.integer()),
+    description: l.optional(l.string()),
 });
 /**
  * Array of all concrete (primitive) Lexicon type schemas.
  * Includes boolean, integer, string, bytes, cid-link, and blob types.
  */
 const CONCRETE_TYPES = [
-    exports.lexiconBooleanSchema,
-    exports.lexiconIntegerSchema,
-    exports.lexiconStringSchema,
+    lexiconBooleanSchema,
+    lexiconIntegerSchema,
+    lexiconStringSchema,
     // Lexicon (DAG-CBOR)
-    exports.lexiconBytesSchema,
-    exports.lexiconCidLinkSchema,
+    lexiconBytesSchema,
+    lexiconCidLinkSchema,
     // Lexicon Specific
-    exports.lexiconBlobSchema,
+    lexiconBlobSchema,
 ];
 // Meta types
 /**
@@ -106,9 +103,9 @@ const CONCRETE_TYPES = [
  * Validates unknown field definitions which accept any valid data.
  * Used when the schema cannot determine the type ahead of time.
  */
-exports.lexiconUnknownSchema = lex_schema_1.l.object({
-    type: lex_schema_1.l.literal('unknown'),
-    description: lex_schema_1.l.optional(lex_schema_1.l.string()),
+export const lexiconUnknownSchema = l.object({
+    type: l.literal('unknown'),
+    description: l.optional(l.string()),
 });
 /**
  * Schema for validating Lexicon token type definitions.
@@ -117,9 +114,9 @@ exports.lexiconUnknownSchema = lex_schema_1.l.object({
  * Tokens are used to define enumeration-like values that can be
  * referenced across different lexicons.
  */
-exports.lexiconTokenSchema = lex_schema_1.l.object({
-    type: lex_schema_1.l.literal('token'),
-    description: lex_schema_1.l.optional(lex_schema_1.l.string()),
+export const lexiconTokenSchema = l.object({
+    type: l.literal('token'),
+    description: l.optional(l.string()),
 });
 /**
  * Schema for validating Lexicon reference type definitions.
@@ -128,10 +125,10 @@ exports.lexiconTokenSchema = lex_schema_1.l.object({
  * within the same or different Lexicon documents. References use the
  * format "nsid#defName" for cross-document refs or "#defName" for local refs.
  */
-exports.lexiconRefSchema = lex_schema_1.l.object({
-    type: lex_schema_1.l.literal('ref'),
-    ref: lex_schema_1.l.string(),
-    description: lex_schema_1.l.optional(lex_schema_1.l.string()),
+export const lexiconRefSchema = l.object({
+    type: l.literal('ref'),
+    ref: l.string(),
+    description: l.optional(l.string()),
 });
 /**
  * Schema for validating Lexicon union reference type definitions.
@@ -140,19 +137,19 @@ exports.lexiconRefSchema = lex_schema_1.l.object({
  * The union can be closed (only listed types allowed) or open (allows
  * additional unlisted types).
  */
-exports.lexiconRefUnionSchema = lex_schema_1.l.object({
-    type: lex_schema_1.l.literal('union'),
-    refs: lex_schema_1.l.array(lex_schema_1.l.string()),
-    closed: lex_schema_1.l.optional(lex_schema_1.l.boolean()),
-    description: lex_schema_1.l.optional(lex_schema_1.l.string()),
+export const lexiconRefUnionSchema = l.object({
+    type: l.literal('union'),
+    refs: l.array(l.string()),
+    closed: l.optional(l.boolean()),
+    description: l.optional(l.string()),
 });
 // Complex Types
 const ARRAY_ITEMS_SCHEMAS = [
     ...CONCRETE_TYPES,
     // Meta
-    exports.lexiconUnknownSchema,
-    exports.lexiconRefSchema,
-    exports.lexiconRefUnionSchema,
+    lexiconUnknownSchema,
+    lexiconRefSchema,
+    lexiconRefUnionSchema,
 ];
 /**
  * Schema for validating Lexicon array type definitions.
@@ -160,12 +157,12 @@ const ARRAY_ITEMS_SCHEMAS = [
  * Validates array field definitions with specified item type and
  * optional length constraints.
  */
-exports.lexiconArraySchema = lex_schema_1.l.object({
-    type: lex_schema_1.l.literal('array'),
-    items: lex_schema_1.l.discriminatedUnion('type', ARRAY_ITEMS_SCHEMAS),
-    minLength: lex_schema_1.l.optional(lex_schema_1.l.integer()),
-    maxLength: lex_schema_1.l.optional(lex_schema_1.l.integer()),
-    description: lex_schema_1.l.optional(lex_schema_1.l.string()),
+export const lexiconArraySchema = l.object({
+    type: l.literal('array'),
+    items: l.discriminatedUnion('type', ARRAY_ITEMS_SCHEMAS),
+    minLength: l.optional(l.integer()),
+    maxLength: l.optional(l.integer()),
+    description: l.optional(l.string()),
 });
 const requirePropertiesRefinement = {
     check: (v) => !v.required || v.required.every((k) => k in v.properties),
@@ -179,15 +176,15 @@ const requirePropertiesRefinement = {
  * and nullable field lists. Includes refinement to ensure all required
  * properties are defined in the properties map.
  */
-exports.lexiconObjectSchema = lex_schema_1.l.refine(lex_schema_1.l.object({
-    type: lex_schema_1.l.literal('object'),
-    properties: lex_schema_1.l.dict(lex_schema_1.l.string(), lex_schema_1.l.discriminatedUnion('type', [
+export const lexiconObjectSchema = l.refine(l.object({
+    type: l.literal('object'),
+    properties: l.dict(l.string(), l.discriminatedUnion('type', [
         ...ARRAY_ITEMS_SCHEMAS,
-        exports.lexiconArraySchema,
+        lexiconArraySchema,
     ])),
-    required: lex_schema_1.l.optional(lex_schema_1.l.array(lex_schema_1.l.string())),
-    nullable: lex_schema_1.l.optional(lex_schema_1.l.array(lex_schema_1.l.string())),
-    description: lex_schema_1.l.optional(lex_schema_1.l.string()),
+    required: l.optional(l.array(l.string())),
+    nullable: l.optional(l.array(l.string())),
+    description: l.optional(l.string()),
 }), requirePropertiesRefinement);
 // Records
 /**
@@ -199,7 +196,7 @@ exports.lexiconObjectSchema = lex_schema_1.l.refine(lex_schema_1.l.object({
  * - "tid": Timestamp identifier
  * - "literal:<string>": A specific literal string value
  */
-exports.lexiconRecordKeySchema = lex_schema_1.l.custom(lex_schema_1.l.isLexiconRecordKey, 'Invalid record key definition (must be "any", "nsid", "tid", or "literal:<string>")');
+export const lexiconRecordKeySchema = l.custom(l.isLexiconRecordKey, 'Invalid record key definition (must be "any", "nsid", "tid", or "literal:<string>")');
 /**
  * Schema for validating Lexicon record type definitions.
  *
@@ -207,11 +204,11 @@ exports.lexiconRecordKeySchema = lex_schema_1.l.custom(lex_schema_1.l.isLexiconR
  * stored in AT Protocol repositories. Records have a key type
  * and an object schema defining the record's data structure.
  */
-exports.lexiconRecordSchema = lex_schema_1.l.object({
-    type: lex_schema_1.l.literal('record'),
-    record: exports.lexiconObjectSchema,
-    description: lex_schema_1.l.optional(lex_schema_1.l.string()),
-    key: exports.lexiconRecordKeySchema,
+export const lexiconRecordSchema = l.object({
+    type: l.literal('record'),
+    record: lexiconObjectSchema,
+    description: l.optional(l.string()),
+    key: lexiconRecordKeySchema,
 });
 // XRPC Methods
 /**
@@ -221,26 +218,26 @@ exports.lexiconRecordSchema = lex_schema_1.l.object({
  * Parameters can only be primitive types (boolean, integer, string)
  * or arrays of primitives.
  */
-exports.lexiconParameters = lex_schema_1.l.refine(lex_schema_1.l.object({
-    type: lex_schema_1.l.literal('params'),
-    properties: lex_schema_1.l.dict(lex_schema_1.l.string(), lex_schema_1.l.discriminatedUnion('type', [
-        exports.lexiconBooleanSchema,
-        exports.lexiconIntegerSchema,
-        exports.lexiconStringSchema,
-        lex_schema_1.l.object({
-            type: lex_schema_1.l.literal('array'),
-            items: lex_schema_1.l.discriminatedUnion('type', [
-                exports.lexiconBooleanSchema,
-                exports.lexiconIntegerSchema,
-                exports.lexiconStringSchema,
+export const lexiconParameters = l.refine(l.object({
+    type: l.literal('params'),
+    properties: l.dict(l.string(), l.discriminatedUnion('type', [
+        lexiconBooleanSchema,
+        lexiconIntegerSchema,
+        lexiconStringSchema,
+        l.object({
+            type: l.literal('array'),
+            items: l.discriminatedUnion('type', [
+                lexiconBooleanSchema,
+                lexiconIntegerSchema,
+                lexiconStringSchema,
             ]),
-            minLength: lex_schema_1.l.optional(lex_schema_1.l.integer()),
-            maxLength: lex_schema_1.l.optional(lex_schema_1.l.integer()),
-            description: lex_schema_1.l.optional(lex_schema_1.l.string()),
+            minLength: l.optional(l.integer()),
+            maxLength: l.optional(l.integer()),
+            description: l.optional(l.string()),
         }),
     ])),
-    required: lex_schema_1.l.optional(lex_schema_1.l.array(lex_schema_1.l.string())),
-    description: lex_schema_1.l.optional(lex_schema_1.l.string()),
+    required: l.optional(l.array(l.string())),
+    description: l.optional(l.string()),
 }), requirePropertiesRefinement);
 /**
  * Schema for validating Lexicon XRPC method payloads.
@@ -249,17 +246,17 @@ exports.lexiconParameters = lex_schema_1.l.refine(lex_schema_1.l.object({
  * Payloads specify the encoding (MIME type) and optional schema for
  * the request or response body.
  */
-exports.lexiconPayload = lex_schema_1.l.object({
-    encoding: lex_schema_1.l.refine(lex_schema_1.l.string(), {
+export const lexiconPayload = l.object({
+    encoding: l.refine(l.string(), {
         check: (v) => !v.includes(',') && !v.includes(';') && !v.includes(' '),
         message: 'Invalid encoding string (must be a single MIME type without parameters)',
     }),
-    schema: lex_schema_1.l.optional(lex_schema_1.l.discriminatedUnion('type', [
-        exports.lexiconRefSchema,
-        exports.lexiconRefUnionSchema,
-        exports.lexiconObjectSchema,
+    schema: l.optional(l.discriminatedUnion('type', [
+        lexiconRefSchema,
+        lexiconRefUnionSchema,
+        lexiconObjectSchema,
     ])),
-    description: lex_schema_1.l.optional(lex_schema_1.l.string()),
+    description: l.optional(l.string()),
 });
 /**
  * Schema for validating Lexicon XRPC error definitions.
@@ -267,9 +264,9 @@ exports.lexiconPayload = lex_schema_1.l.object({
  * Validates error definitions that can be returned by XRPC methods.
  * Each error has a name and optional description.
  */
-exports.lexiconError = lex_schema_1.l.object({
-    name: lex_schema_1.l.string({ minLength: 1 }),
-    description: lex_schema_1.l.optional(lex_schema_1.l.string()),
+export const lexiconError = l.object({
+    name: l.string({ minLength: 1 }),
+    description: l.optional(l.string()),
 });
 /**
  * Schema for validating Lexicon query (GET) method definitions.
@@ -278,12 +275,12 @@ exports.lexiconError = lex_schema_1.l.object({
  * operations. Queries can have parameters, an output payload, and
  * defined error types.
  */
-exports.lexiconQuerySchema = lex_schema_1.l.object({
-    type: lex_schema_1.l.literal('query'),
-    parameters: lex_schema_1.l.optional(exports.lexiconParameters),
-    output: lex_schema_1.l.optional(exports.lexiconPayload),
-    errors: lex_schema_1.l.optional(lex_schema_1.l.array(exports.lexiconError)),
-    description: lex_schema_1.l.optional(lex_schema_1.l.string()),
+export const lexiconQuerySchema = l.object({
+    type: l.literal('query'),
+    parameters: l.optional(lexiconParameters),
+    output: l.optional(lexiconPayload),
+    errors: l.optional(l.array(lexiconError)),
+    description: l.optional(l.string()),
 });
 /**
  * Schema for validating Lexicon procedure (POST) method definitions.
@@ -292,13 +289,13 @@ exports.lexiconQuerySchema = lex_schema_1.l.object({
  * operations that may modify state. Procedures can have parameters,
  * input payload, output payload, and defined error types.
  */
-exports.lexiconProcedureSchema = lex_schema_1.l.object({
-    type: lex_schema_1.l.literal('procedure'),
-    parameters: lex_schema_1.l.optional(exports.lexiconParameters),
-    input: lex_schema_1.l.optional(exports.lexiconPayload),
-    output: lex_schema_1.l.optional(exports.lexiconPayload),
-    errors: lex_schema_1.l.optional(lex_schema_1.l.array(exports.lexiconError)),
-    description: lex_schema_1.l.optional(lex_schema_1.l.string()),
+export const lexiconProcedureSchema = l.object({
+    type: l.literal('procedure'),
+    parameters: l.optional(lexiconParameters),
+    input: l.optional(lexiconPayload),
+    output: l.optional(lexiconPayload),
+    errors: l.optional(l.array(lexiconError)),
+    description: l.optional(l.string()),
 });
 /**
  * Schema for validating Lexicon subscription (WebSocket) method definitions.
@@ -307,57 +304,57 @@ exports.lexiconProcedureSchema = lex_schema_1.l.object({
  * streaming connections over WebSocket. Subscriptions have parameters,
  * a message schema defining the streamed data format, and error types.
  */
-exports.lexiconSubscriptionSchema = lex_schema_1.l.object({
-    type: lex_schema_1.l.literal('subscription'),
-    description: lex_schema_1.l.optional(lex_schema_1.l.string()),
-    parameters: lex_schema_1.l.optional(exports.lexiconParameters),
-    message: lex_schema_1.l.object({
-        description: lex_schema_1.l.optional(lex_schema_1.l.string()),
-        schema: exports.lexiconRefUnionSchema,
+export const lexiconSubscriptionSchema = l.object({
+    type: l.literal('subscription'),
+    description: l.optional(l.string()),
+    parameters: l.optional(lexiconParameters),
+    message: l.object({
+        description: l.optional(l.string()),
+        schema: lexiconRefUnionSchema,
     }),
-    errors: lex_schema_1.l.optional(lex_schema_1.l.array(exports.lexiconError)),
+    errors: l.optional(l.array(lexiconError)),
 });
 // Permissions
 /**
  * Schema for validating language codes in Lexicon permission definitions.
  */
-exports.lexiconLanguageSchema = lex_schema_1.l.string({ format: 'language' });
+export const lexiconLanguageSchema = l.string({ format: 'language' });
 /**
  * Schema for validating language-keyed string dictionaries.
  * Used for localized text in permission definitions.
  */
-exports.lexiconLanguageDict = lex_schema_1.l.dict(exports.lexiconLanguageSchema, lex_schema_1.l.string());
+export const lexiconLanguageDict = l.dict(lexiconLanguageSchema, l.string());
 /**
  * Schema for validating individual Lexicon permission definitions.
  */
-exports.lexiconPermissionSchema = lex_schema_1.l.intersection(lex_schema_1.l.object({
-    type: lex_schema_1.l.literal('permission'),
-    resource: lex_schema_1.l.string({ minLength: 1 }),
-}), lex_schema_1.l.dict(lex_schema_1.l.string(), lex_schema_1.l.paramSchema));
+export const lexiconPermissionSchema = l.intersection(l.object({
+    type: l.literal('permission'),
+    resource: l.string({ minLength: 1 }),
+}), l.dict(l.string(), l.paramSchema));
 /**
  * Schema for validating Lexicon permission set definitions.
  */
-exports.lexiconPermissionSetSchema = lex_schema_1.l.object({
-    type: lex_schema_1.l.literal('permission-set'),
-    permissions: lex_schema_1.l.array(exports.lexiconPermissionSchema),
-    title: lex_schema_1.l.optional(lex_schema_1.l.string()),
-    'title:lang': lex_schema_1.l.optional(exports.lexiconLanguageDict),
-    detail: lex_schema_1.l.optional(lex_schema_1.l.string()),
-    'detail:lang': lex_schema_1.l.optional(exports.lexiconLanguageDict),
-    description: lex_schema_1.l.optional(lex_schema_1.l.string()),
+export const lexiconPermissionSetSchema = l.object({
+    type: l.literal('permission-set'),
+    permissions: l.array(lexiconPermissionSchema),
+    title: l.optional(l.string()),
+    'title:lang': l.optional(lexiconLanguageDict),
+    detail: l.optional(l.string()),
+    'detail:lang': l.optional(lexiconLanguageDict),
+    description: l.optional(l.string()),
 });
 const NAMED_LEXICON_SCHEMAS = [
     ...CONCRETE_TYPES,
-    exports.lexiconArraySchema,
-    exports.lexiconObjectSchema,
-    exports.lexiconTokenSchema,
+    lexiconArraySchema,
+    lexiconObjectSchema,
+    lexiconTokenSchema,
 ];
 const MAIN_LEXICON_SCHEMAS = [
-    exports.lexiconPermissionSetSchema,
-    exports.lexiconProcedureSchema,
-    exports.lexiconQuerySchema,
-    exports.lexiconRecordSchema,
-    exports.lexiconSubscriptionSchema,
+    lexiconPermissionSetSchema,
+    lexiconProcedureSchema,
+    lexiconQuerySchema,
+    lexiconRecordSchema,
+    lexiconSubscriptionSchema,
     ...NAMED_LEXICON_SCHEMAS,
 ];
 /**
@@ -366,7 +363,7 @@ const MAIN_LEXICON_SCHEMAS = [
  * Validates that the identifier follows the Namespaced Identifier format
  * (e.g., "com.atproto.repo.createRecord").
  */
-exports.lexiconIdentifierSchema = lex_schema_1.l.string({ format: 'nsid' });
+export const lexiconIdentifierSchema = l.string({ format: 'nsid' });
 /**
  * Schema for validating complete Lexicon document structures.
  *
@@ -403,13 +400,13 @@ exports.lexiconIdentifierSchema = lex_schema_1.l.string({ format: 'nsid' });
  * })
  * ```
  */
-exports.lexiconDocumentSchema = lex_schema_1.l.object({
-    lexicon: lex_schema_1.l.literal(1),
-    id: exports.lexiconIdentifierSchema,
-    revision: lex_schema_1.l.optional(lex_schema_1.l.integer()),
-    description: lex_schema_1.l.optional(lex_schema_1.l.string()),
-    defs: lex_schema_1.l.intersection(lex_schema_1.l.object({
-        main: lex_schema_1.l.optional(lex_schema_1.l.discriminatedUnion('type', MAIN_LEXICON_SCHEMAS)),
-    }), lex_schema_1.l.dict(lex_schema_1.l.string({ minLength: 1 }), lex_schema_1.l.discriminatedUnion('type', NAMED_LEXICON_SCHEMAS))),
+export const lexiconDocumentSchema = l.object({
+    lexicon: l.literal(1),
+    id: lexiconIdentifierSchema,
+    revision: l.optional(l.integer()),
+    description: l.optional(l.string()),
+    defs: l.intersection(l.object({
+        main: l.optional(l.discriminatedUnion('type', MAIN_LEXICON_SCHEMAS)),
+    }), l.dict(l.string({ minLength: 1 }), l.discriminatedUnion('type', NAMED_LEXICON_SCHEMAS))),
 });
 //# sourceMappingURL=lexicon-document.js.map