@atproto/lex-schema 0.0.11 → 0.0.13

package/dist/schema/integer.d.ts

@@ -1,12 +1,55 @@
 import { Schema, ValidationContext } from '../core.js';
+/**
+ * Configuration options for integer schema validation.
+ *
+ * @property minimum - Minimum allowed value (inclusive)
+ * @property maximum - Maximum allowed value (inclusive)
+ */
 export type IntegerSchemaOptions = {
     minimum?: number;
     maximum?: number;
 };
+/**
+ * Schema for validating integer values with optional range constraints.
+ *
+ * Only accepts safe integers (values that can be exactly represented in JavaScript).
+ * Use {@link IntegerSchemaOptions} to constrain the allowed range.
+ *
+ * @example
+ * ```ts
+ * const schema = new IntegerSchema({ minimum: 0, maximum: 100 })
+ * const result = schema.validate(42)
+ * ```
+ */
 export declare class IntegerSchema extends Schema<number> {
     readonly options?: IntegerSchemaOptions | undefined;
+    readonly type: "integer";
     constructor(options?: IntegerSchemaOptions | undefined);
     validateInContext(input: unknown, ctx: ValidationContext): import("../core.js").ValidationResult<number>;
 }
+/**
+ * Creates an integer schema with optional minimum and maximum constraints.
+ *
+ * Validates that the input is a safe integer (can be exactly represented in JavaScript)
+ * and optionally falls within a specified range.
+ *
+ * @param options - Optional configuration for minimum and maximum values
+ * @returns A new {@link IntegerSchema} instance
+ *
+ * @example
+ * ```ts
+ * // Basic integer
+ * const countSchema = l.integer()
+ *
+ * // With minimum value
+ * const positiveSchema = l.integer({ minimum: 1 })
+ *
+ * // With range constraints
+ * const percentSchema = l.integer({ minimum: 0, maximum: 100 })
+ *
+ * // Age validation
+ * const ageSchema = l.integer({ minimum: 0, maximum: 150 })
+ * ```
+ */
 export declare const integer: (options?: IntegerSchemaOptions) => IntegerSchema;
 //# sourceMappingURL=integer.d.ts.map

package/dist/schema/integer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"integer.d.ts","sourceRoot":"","sources":["../../src/schema/integer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAGtD,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,qBAAa,aAAc,SAAQ,MAAM,CAAC,MAAM,CAAC;IACnC,QAAQ,CAAC,OAAO,CAAC,EAAE,oBAAoB;gBAA9B,OAAO,CAAC,EAAE,oBAAoB,YAAA;IAInD,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;CAezD;AASD,eAAO,MAAM,OAAO,aACR,oBAAoB,kBAG9B,CAAA"}
+{"version":3,"file":"integer.d.ts","sourceRoot":"","sources":["../../src/schema/integer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAGtD;;;;;GAKG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAA;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,aAAc,SAAQ,MAAM,CAAC,MAAM,CAAC;IAGnC,QAAQ,CAAC,OAAO,CAAC,EAAE,oBAAoB;IAFnD,QAAQ,CAAC,IAAI,EAAG,SAAS,CAAS;gBAEb,OAAO,CAAC,EAAE,oBAAoB,YAAA;IAInD,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;CAezD;AASD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,OAAO,aACR,oBAAoB,kBAG9B,CAAA"}

package/dist/schema/integer.js

@@ -3,15 +3,28 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.integer = exports.IntegerSchema = void 0;
 const core_js_1 = require("../core.js");
 const memoize_js_1 = require("../util/memoize.js");
+/**
+ * Schema for validating integer values with optional range constraints.
+ *
+ * Only accepts safe integers (values that can be exactly represented in JavaScript).
+ * Use {@link IntegerSchemaOptions} to constrain the allowed range.
+ *
+ * @example
+ * ```ts
+ * const schema = new IntegerSchema({ minimum: 0, maximum: 100 })
+ * const result = schema.validate(42)
+ * ```
+ */
 class IntegerSchema extends core_js_1.Schema {
     options;
+    type = 'integer';
     constructor(options) {
         super();
         this.options = options;
     }
     validateInContext(input, ctx) {
         if (!isInteger(input)) {
-            return ctx.issueInvalidType(input, 'integer');
+            return ctx.issueUnexpectedType(input, 'integer');
         }
         if (this.options?.minimum != null && input < this.options.minimum) {
             return ctx.issueTooSmall(input, 'integer', this.options.minimum, input);
@@ -29,6 +42,30 @@ exports.IntegerSchema = IntegerSchema;
 function isInteger(input) {
     return Number.isSafeInteger(input);
 }
+/**
+ * Creates an integer schema with optional minimum and maximum constraints.
+ *
+ * Validates that the input is a safe integer (can be exactly represented in JavaScript)
+ * and optionally falls within a specified range.
+ *
+ * @param options - Optional configuration for minimum and maximum values
+ * @returns A new {@link IntegerSchema} instance
+ *
+ * @example
+ * ```ts
+ * // Basic integer
+ * const countSchema = l.integer()
+ *
+ * // With minimum value
+ * const positiveSchema = l.integer({ minimum: 1 })
+ *
+ * // With range constraints
+ * const percentSchema = l.integer({ minimum: 0, maximum: 100 })
+ *
+ * // Age validation
+ * const ageSchema = l.integer({ minimum: 0, maximum: 150 })
+ * ```
+ */
 exports.integer = (0, memoize_js_1.memoizedOptions)(function (options) {
     return new IntegerSchema(options);
 });

package/dist/schema/integer.js.map

@@ -1 +1 @@
-{"version":3,"file":"integer.js","sourceRoot":"","sources":["../../src/schema/integer.ts"],"names":[],"mappings":";;;AAAA,wCAAsD;AACtD,mDAAoD;AAOpD,MAAa,aAAc,SAAQ,gBAAc;IAC1B;IAArB,YAAqB,OAA8B;QACjD,KAAK,EAAE,CAAA;QADY,YAAO,GAAP,OAAO,CAAuB;IAEnD,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC;YACtB,OAAO,GAAG,CAAC,gBAAgB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAA;QAC/C,CAAC;QAED,IAAI,IAAI,CAAC,OAAO,EAAE,OAAO,IAAI,IAAI,IAAI,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;YAClE,OAAO,GAAG,CAAC,aAAa,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,KAAK,CAAC,CAAA;QACzE,CAAC;QAED,IAAI,IAAI,CAAC,OAAO,EAAE,OAAO,IAAI,IAAI,IAAI,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;YAClE,OAAO,GAAG,CAAC,WAAW,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,KAAK,CAAC,CAAA;QACvE,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IAC3B,CAAC;CACF;AApBD,sCAoBC;AAED;;GAEG;AACH,SAAS,SAAS,CAAC,KAAc;IAC/B,OAAO,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,CAAA;AACpC,CAAC;AAEY,QAAA,OAAO,GAAiB,IAAA,4BAAe,EAAC,UACnD,OAA8B;IAE9B,OAAO,IAAI,aAAa,CAAC,OAAO,CAAC,CAAA;AACnC,CAAC,CAAC,CAAA","sourcesContent":["import { Schema, ValidationContext } from '../core.js'\nimport { memoizedOptions } from '../util/memoize.js'\n\nexport type IntegerSchemaOptions = {\n  minimum?: number\n  maximum?: number\n}\n\nexport class IntegerSchema extends Schema<number> {\n  constructor(readonly options?: IntegerSchemaOptions) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!isInteger(input)) {\n      return ctx.issueInvalidType(input, 'integer')\n    }\n\n    if (this.options?.minimum != null && input < this.options.minimum) {\n      return ctx.issueTooSmall(input, 'integer', this.options.minimum, input)\n    }\n\n    if (this.options?.maximum != null && input > this.options.maximum) {\n      return ctx.issueTooBig(input, 'integer', this.options.maximum, input)\n    }\n\n    return ctx.success(input)\n  }\n}\n\n/**\n * Simple wrapper around {@link Number.isSafeInteger} that acts as a type guard.\n */\nfunction isInteger(input: unknown): input is number {\n  return Number.isSafeInteger(input)\n}\n\nexport const integer = /*#__PURE__*/ memoizedOptions(function (\n  options?: IntegerSchemaOptions,\n) {\n  return new IntegerSchema(options)\n})\n"]}
+{"version":3,"file":"integer.js","sourceRoot":"","sources":["../../src/schema/integer.ts"],"names":[],"mappings":";;;AAAA,wCAAsD;AACtD,mDAAoD;AAapD;;;;;;;;;;;GAWG;AACH,MAAa,aAAc,SAAQ,gBAAc;IAG1B;IAFZ,IAAI,GAAG,SAAkB,CAAA;IAElC,YAAqB,OAA8B;QACjD,KAAK,EAAE,CAAA;QADY,YAAO,GAAP,OAAO,CAAuB;IAEnD,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC;YACtB,OAAO,GAAG,CAAC,mBAAmB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAA;QAClD,CAAC;QAED,IAAI,IAAI,CAAC,OAAO,EAAE,OAAO,IAAI,IAAI,IAAI,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;YAClE,OAAO,GAAG,CAAC,aAAa,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,KAAK,CAAC,CAAA;QACzE,CAAC;QAED,IAAI,IAAI,CAAC,OAAO,EAAE,OAAO,IAAI,IAAI,IAAI,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;YAClE,OAAO,GAAG,CAAC,WAAW,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,KAAK,CAAC,CAAA;QACvE,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IAC3B,CAAC;CACF;AAtBD,sCAsBC;AAED;;GAEG;AACH,SAAS,SAAS,CAAC,KAAc;IAC/B,OAAO,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,CAAA;AACpC,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACU,QAAA,OAAO,GAAiB,IAAA,4BAAe,EAAC,UACnD,OAA8B;IAE9B,OAAO,IAAI,aAAa,CAAC,OAAO,CAAC,CAAA;AACnC,CAAC,CAAC,CAAA","sourcesContent":["import { Schema, ValidationContext } from '../core.js'\nimport { memoizedOptions } from '../util/memoize.js'\n\n/**\n * Configuration options for integer schema validation.\n *\n * @property minimum - Minimum allowed value (inclusive)\n * @property maximum - Maximum allowed value (inclusive)\n */\nexport type IntegerSchemaOptions = {\n  minimum?: number\n  maximum?: number\n}\n\n/**\n * Schema for validating integer values with optional range constraints.\n *\n * Only accepts safe integers (values that can be exactly represented in JavaScript).\n * Use {@link IntegerSchemaOptions} to constrain the allowed range.\n *\n * @example\n * ```ts\n * const schema = new IntegerSchema({ minimum: 0, maximum: 100 })\n * const result = schema.validate(42)\n * ```\n */\nexport class IntegerSchema extends Schema<number> {\n  readonly type = 'integer' as const\n\n  constructor(readonly options?: IntegerSchemaOptions) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!isInteger(input)) {\n      return ctx.issueUnexpectedType(input, 'integer')\n    }\n\n    if (this.options?.minimum != null && input < this.options.minimum) {\n      return ctx.issueTooSmall(input, 'integer', this.options.minimum, input)\n    }\n\n    if (this.options?.maximum != null && input > this.options.maximum) {\n      return ctx.issueTooBig(input, 'integer', this.options.maximum, input)\n    }\n\n    return ctx.success(input)\n  }\n}\n\n/**\n * Simple wrapper around {@link Number.isSafeInteger} that acts as a type guard.\n */\nfunction isInteger(input: unknown): input is number {\n  return Number.isSafeInteger(input)\n}\n\n/**\n * Creates an integer schema with optional minimum and maximum constraints.\n *\n * Validates that the input is a safe integer (can be exactly represented in JavaScript)\n * and optionally falls within a specified range.\n *\n * @param options - Optional configuration for minimum and maximum values\n * @returns A new {@link IntegerSchema} instance\n *\n * @example\n * ```ts\n * // Basic integer\n * const countSchema = l.integer()\n *\n * // With minimum value\n * const positiveSchema = l.integer({ minimum: 1 })\n *\n * // With range constraints\n * const percentSchema = l.integer({ minimum: 0, maximum: 100 })\n *\n * // Age validation\n * const ageSchema = l.integer({ minimum: 0, maximum: 150 })\n * ```\n */\nexport const integer = /*#__PURE__*/ memoizedOptions(function (\n  options?: IntegerSchemaOptions,\n) {\n  return new IntegerSchema(options)\n})\n"]}

package/dist/schema/intersection.d.ts

@@ -2,10 +2,15 @@ import { InferInput, InferOutput, Schema, Simplify, ValidationContext } from '..
 import { DictSchema } from './dict.js';
 import { ObjectSchema } from './object.js';
 /**
+ * Type utility for computing the intersection of two object types.
+ *
  * Allows to more accurately represent the intersection of two object types
  * where both types may share some keys, and one of them uses an index
  * signature.
  *
+ * @template A - First object type (typically from ObjectSchema)
+ * @template B - Second object type (typically from DictSchema)
+ *
  * @see {@link https://www.typescriptlang.org/play/?#code/C4TwDgpgBAglC8UDeUBmB7dAuKByARgIYBOuUAvlAGTJQDaA+lAJYB2UAzsMWwOYC6OVgFcAtvgjEKAKGkATCAGMANiWiL0rLlEI4YsjVuBQA1hBA4uPVrwRQARBnT2Dm7QDdCy4dESE6ZiD8UAD0IVAi4pJQABQcABbowspyUBIORMT2AJSyEAAeYOjExqCQUACSrMCSHErAzJoAPNJQsFAFNaxyHFAASkrFck1WfAA0UMKsJqzoAO6sAHxjrVAAQh35XT39g8TDozYTUzPzSyuLdqtwVKttMYHoqO00j88bnRDdvawQ7pJ3NpQAD860BbRwSHBQLadAA0ix2G91oJ1vDggAfWABcxPF5QOH8aFtci5aRlaAwVDMfIQVKIKo1Yh1RQNZq0Jw4AgkMjkCYoRiIzjcPioyISKTkRayBQqNRQQzaQgAMRpdL01NpclcRignm8EFVWrsKrVchxQVC4XF0SxmSAA Playground link}
  */
 export type Intersect<A, B> = B[keyof B] extends never ? A : keyof A & keyof B extends never ? // If A and B don't overlap, just return A & B
@@ -13,11 +18,61 @@ A & B : // Otherwise, properly represent the fact that accessing using an
 A & {
     [K in keyof B]: B[K] | A[keyof A & K];
 };
+/**
+ * Schema for combining an object schema with a dictionary schema.
+ *
+ * Validates that the input matches both the fixed object shape and allows
+ * additional properties that match the dictionary schema. Properties defined
+ * in the object schema are validated by the object, and remaining properties
+ * are validated by the dictionary.
+ *
+ * @template Left - The ObjectSchema type for fixed properties
+ * @template Right - The DictSchema type for additional properties
+ *
+ * @example
+ * ```ts
+ * const schema = new IntersectionSchema(
+ *   l.object({ name: l.string() }),
+ *   l.dict(l.string(), l.integer())
+ * )
+ * // Validates: { name: 'test', score: 100, count: 5 }
+ * ```
+ */
 export declare class IntersectionSchema<const Left extends ObjectSchema = any, const Right extends DictSchema = any> extends Schema<Simplify<Intersect<InferInput<Left>, InferInput<Right>>>, Simplify<Intersect<InferOutput<Left>, InferOutput<Right>>>> {
     protected readonly left: Left;
     protected readonly right: Right;
+    readonly type: "intersection";
     constructor(left: Left, right: Right);
     validateInContext(input: unknown, ctx: ValidationContext): import("../core.js").ValidationResult<Record<string, unknown>>;
 }
+/**
+ * Creates an intersection schema combining fixed object properties with dynamic dictionary properties.
+ *
+ * Useful for objects that have a known set of properties plus additional
+ * arbitrary properties that follow a pattern.
+ *
+ * @param left - Object schema defining the fixed, known properties
+ * @param right - Dictionary schema for validating additional properties
+ * @returns A new {@link IntersectionSchema} instance
+ *
+ * @example
+ * ```ts
+ * // Object with fixed and dynamic properties
+ * const configSchema = l.intersection(
+ *   l.object({
+ *     version: l.integer(),
+ *     name: l.string(),
+ *   }),
+ *   l.dict(l.string(), l.string()) // Additional string properties
+ * )
+ *
+ * configSchema.parse({
+ *   version: 1,
+ *   name: 'my-config',
+ *   customField: 'value',
+ *   anotherField: 'another',
+ * })
+ * ```
+ */
 export declare function intersection<const Left extends ObjectSchema, const Right extends DictSchema>(left: Left, right: Right): IntersectionSchema<Left, Right>;
 //# sourceMappingURL=intersection.d.ts.map

package/dist/schema/intersection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intersection.d.ts","sourceRoot":"","sources":["../../src/schema/intersection.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,WAAW,EACX,MAAM,EACN,QAAQ,EACR,iBAAiB,EAClB,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AACtC,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE1C;;;;;;GAMG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,SAAS,KAAK,GAClD,CAAC,GACD,MAAM,CAAC,GAAG,MAAM,CAAC,SAAS,KAAK,GAE7B,AADA,8CAA8C;AAC9C,CAAC,GAAG,CAAC,GAGL,AAFA,iEAAiE;AAEjE,CAAC,GAAG;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;CAAE,CAAA;AAEnD,qBAAa,kBAAkB,CAC7B,KAAK,CAAC,IAAI,SAAS,YAAY,GAAG,GAAG,EACrC,KAAK,CAAC,KAAK,SAAS,UAAU,GAAG,GAAG,CACpC,SAAQ,MAAM,CACd,QAAQ,CAAC,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,EACxD,QAAQ,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAC3D;IAEG,SAAS,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI;IAC7B,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,KAAK;gBADZ,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,KAAK;IAKjC,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;CAQzD;AAGD,wBAAgB,YAAY,CAC1B,KAAK,CAAC,IAAI,SAAS,YAAY,EAC/B,KAAK,CAAC,KAAK,SAAS,UAAU,EAC9B,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,mCAEzB"}
+{"version":3,"file":"intersection.d.ts","sourceRoot":"","sources":["../../src/schema/intersection.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,WAAW,EACX,MAAM,EACN,QAAQ,EACR,iBAAiB,EAClB,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AACtC,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE1C;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,SAAS,KAAK,GAClD,CAAC,GACD,MAAM,CAAC,GAAG,MAAM,CAAC,SAAS,KAAK,GAE7B,AADA,8CAA8C;AAC9C,CAAC,GAAG,CAAC,GAGL,AAFA,iEAAiE;AAEjE,CAAC,GAAG;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;CAAE,CAAA;AAEnD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,kBAAkB,CAC7B,KAAK,CAAC,IAAI,SAAS,YAAY,GAAG,GAAG,EACrC,KAAK,CAAC,KAAK,SAAS,UAAU,GAAG,GAAG,CACpC,SAAQ,MAAM,CACd,QAAQ,CAAC,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,EACxD,QAAQ,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAC3D;IAIG,SAAS,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI;IAC7B,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,KAAK;IAJjC,QAAQ,CAAC,IAAI,EAAG,cAAc,CAAS;gBAGlB,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,KAAK;IAKjC,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;CAQzD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,wBAAgB,YAAY,CAC1B,KAAK,CAAC,IAAI,SAAS,YAAY,EAC/B,KAAK,CAAC,KAAK,SAAS,UAAU,EAC9B,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,mCAEzB"}

package/dist/schema/intersection.js

@@ -3,9 +3,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.IntersectionSchema = void 0;
 exports.intersection = intersection;
 const core_js_1 = require("../core.js");
+/**
+ * Schema for combining an object schema with a dictionary schema.
+ *
+ * Validates that the input matches both the fixed object shape and allows
+ * additional properties that match the dictionary schema. Properties defined
+ * in the object schema are validated by the object, and remaining properties
+ * are validated by the dictionary.
+ *
+ * @template Left - The ObjectSchema type for fixed properties
+ * @template Right - The DictSchema type for additional properties
+ *
+ * @example
+ * ```ts
+ * const schema = new IntersectionSchema(
+ *   l.object({ name: l.string() }),
+ *   l.dict(l.string(), l.integer())
+ * )
+ * // Validates: { name: 'test', score: 100, count: 5 }
+ * ```
+ */
 class IntersectionSchema extends core_js_1.Schema {
     left;
     right;
+    type = 'intersection';
     constructor(left, right) {
         super();
         this.left = left;
@@ -21,6 +42,35 @@ class IntersectionSchema extends core_js_1.Schema {
     }
 }
 exports.IntersectionSchema = IntersectionSchema;
+/**
+ * Creates an intersection schema combining fixed object properties with dynamic dictionary properties.
+ *
+ * Useful for objects that have a known set of properties plus additional
+ * arbitrary properties that follow a pattern.
+ *
+ * @param left - Object schema defining the fixed, known properties
+ * @param right - Dictionary schema for validating additional properties
+ * @returns A new {@link IntersectionSchema} instance
+ *
+ * @example
+ * ```ts
+ * // Object with fixed and dynamic properties
+ * const configSchema = l.intersection(
+ *   l.object({
+ *     version: l.integer(),
+ *     name: l.string(),
+ *   }),
+ *   l.dict(l.string(), l.string()) // Additional string properties
+ * )
+ *
+ * configSchema.parse({
+ *   version: 1,
+ *   name: 'my-config',
+ *   customField: 'value',
+ *   anotherField: 'another',
+ * })
+ * ```
+ */
 /*@__NO_SIDE_EFFECTS__*/
 function intersection(left, right) {
     return new IntersectionSchema(left, right);

package/dist/schema/intersection.js.map

@@ -1 +1 @@
-{"version":3,"file":"intersection.js","sourceRoot":"","sources":["../../src/schema/intersection.ts"],"names":[],"mappings":";;;AAmDA,oCAKC;AAxDD,wCAMmB;AAoBnB,MAAa,kBAGX,SAAQ,gBAGT;IAEsB;IACA;IAFrB,YACqB,IAAU,EACV,KAAY;QAE/B,KAAK,EAAE,CAAA;QAHY,SAAI,GAAJ,IAAI,CAAM;QACV,UAAK,GAAL,KAAK,CAAO;IAGjC,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,MAAM,UAAU,GAAG,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,CAAA;QACjD,IAAI,CAAC,UAAU,CAAC,OAAO;YAAE,OAAO,UAAU,CAAA;QAE1C,OAAO,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,UAAU,CAAC,KAAK,EAAE,GAAG,EAAE;YACzD,WAAW,EAAE,IAAI,CAAC,IAAI,CAAC,aAAa;SACrC,CAAC,CAAA;IACJ,CAAC;CACF;AAtBD,gDAsBC;AAED,wBAAwB;AACxB,SAAgB,YAAY,CAG1B,IAAU,EAAE,KAAY;IACxB,OAAO,IAAI,kBAAkB,CAAc,IAAI,EAAE,KAAK,CAAC,CAAA;AACzD,CAAC","sourcesContent":["import {\n  InferInput,\n  InferOutput,\n  Schema,\n  Simplify,\n  ValidationContext,\n} from '../core.js'\nimport { DictSchema } from './dict.js'\nimport { ObjectSchema } from './object.js'\n\n/**\n * Allows to more accurately represent the intersection of two object types\n * where both types may share some keys, and one of them uses an index\n * signature.\n *\n * @see {@link https://www.typescriptlang.org/play/?#code/C4TwDgpgBAglC8UDeUBmB7dAuKByARgIYBOuUAvlAGTJQDaA+lAJYB2UAzsMWwOYC6OVgFcAtvgjEKAKGkATCAGMANiWiL0rLlEI4YsjVuBQA1hBA4uPVrwRQARBnT2Dm7QDdCy4dESE6ZiD8UAD0IVAi4pJQABQcABbowspyUBIORMT2AJSyEAAeYOjExqCQUACSrMCSHErAzJoAPNJQsFAFNaxyHFAASkrFck1WfAA0UMKsJqzoAO6sAHxjrVAAQh35XT39g8TDozYTUzPzSyuLdqtwVKttMYHoqO00j88bnRDdvawQ7pJ3NpQAD860BbRwSHBQLadAA0ix2G91oJ1vDggAfWABcxPF5QOH8aFtci5aRlaAwVDMfIQVKIKo1Yh1RQNZq0Jw4AgkMjkCYoRiIzjcPioyISKTkRayBQqNRQQzaQgAMRpdL01NpclcRignm8EFVWrsKrVchxQVC4XF0SxmSAA Playground link}\n */\nexport type Intersect<A, B> = B[keyof B] extends never\n  ? A\n  : keyof A & keyof B extends never\n    ? // If A and B don't overlap, just return A & B\n      A & B\n    : // Otherwise, properly represent the fact that accessing using an\n      // index signature could return a value from either A or B\n      A & { [K in keyof B]: B[K] | A[keyof A & K] }\n\nexport class IntersectionSchema<\n  const Left extends ObjectSchema = any,\n  const Right extends DictSchema = any,\n> extends Schema<\n  Simplify<Intersect<InferInput<Left>, InferInput<Right>>>,\n  Simplify<Intersect<InferOutput<Left>, InferOutput<Right>>>\n> {\n  constructor(\n    protected readonly left: Left,\n    protected readonly right: Right,\n  ) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    const leftResult = ctx.validate(input, this.left)\n    if (!leftResult.success) return leftResult\n\n    return this.right.validateInContext(leftResult.value, ctx, {\n      ignoredKeys: this.left.validatorsMap,\n    })\n  }\n}\n\n/*@__NO_SIDE_EFFECTS__*/\nexport function intersection<\n  const Left extends ObjectSchema,\n  const Right extends DictSchema,\n>(left: Left, right: Right) {\n  return new IntersectionSchema<Left, Right>(left, right)\n}\n"]}
+{"version":3,"file":"intersection.js","sourceRoot":"","sources":["../../src/schema/intersection.ts"],"names":[],"mappings":";;;AA2GA,oCAKC;AAhHD,wCAMmB;AAyBnB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAa,kBAGX,SAAQ,gBAGT;IAIsB;IACA;IAJZ,IAAI,GAAG,cAAuB,CAAA;IAEvC,YACqB,IAAU,EACV,KAAY;QAE/B,KAAK,EAAE,CAAA;QAHY,SAAI,GAAJ,IAAI,CAAM;QACV,UAAK,GAAL,KAAK,CAAO;IAGjC,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,MAAM,UAAU,GAAG,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,CAAA;QACjD,IAAI,CAAC,UAAU,CAAC,OAAO;YAAE,OAAO,UAAU,CAAA;QAE1C,OAAO,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,UAAU,CAAC,KAAK,EAAE,GAAG,EAAE;YACzD,WAAW,EAAE,IAAI,CAAC,IAAI,CAAC,aAAa;SACrC,CAAC,CAAA;IACJ,CAAC;CACF;AAxBD,gDAwBC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAwB;AACxB,SAAgB,YAAY,CAG1B,IAAU,EAAE,KAAY;IACxB,OAAO,IAAI,kBAAkB,CAAc,IAAI,EAAE,KAAK,CAAC,CAAA;AACzD,CAAC","sourcesContent":["import {\n  InferInput,\n  InferOutput,\n  Schema,\n  Simplify,\n  ValidationContext,\n} from '../core.js'\nimport { DictSchema } from './dict.js'\nimport { ObjectSchema } from './object.js'\n\n/**\n * Type utility for computing the intersection of two object types.\n *\n * Allows to more accurately represent the intersection of two object types\n * where both types may share some keys, and one of them uses an index\n * signature.\n *\n * @template A - First object type (typically from ObjectSchema)\n * @template B - Second object type (typically from DictSchema)\n *\n * @see {@link https://www.typescriptlang.org/play/?#code/C4TwDgpgBAglC8UDeUBmB7dAuKByARgIYBOuUAvlAGTJQDaA+lAJYB2UAzsMWwOYC6OVgFcAtvgjEKAKGkATCAGMANiWiL0rLlEI4YsjVuBQA1hBA4uPVrwRQARBnT2Dm7QDdCy4dESE6ZiD8UAD0IVAi4pJQABQcABbowspyUBIORMT2AJSyEAAeYOjExqCQUACSrMCSHErAzJoAPNJQsFAFNaxyHFAASkrFck1WfAA0UMKsJqzoAO6sAHxjrVAAQh35XT39g8TDozYTUzPzSyuLdqtwVKttMYHoqO00j88bnRDdvawQ7pJ3NpQAD860BbRwSHBQLadAA0ix2G91oJ1vDggAfWABcxPF5QOH8aFtci5aRlaAwVDMfIQVKIKo1Yh1RQNZq0Jw4AgkMjkCYoRiIzjcPioyISKTkRayBQqNRQQzaQgAMRpdL01NpclcRignm8EFVWrsKrVchxQVC4XF0SxmSAA Playground link}\n */\nexport type Intersect<A, B> = B[keyof B] extends never\n  ? A\n  : keyof A & keyof B extends never\n    ? // If A and B don't overlap, just return A & B\n      A & B\n    : // Otherwise, properly represent the fact that accessing using an\n      // index signature could return a value from either A or B\n      A & { [K in keyof B]: B[K] | A[keyof A & K] }\n\n/**\n * Schema for combining an object schema with a dictionary schema.\n *\n * Validates that the input matches both the fixed object shape and allows\n * additional properties that match the dictionary schema. Properties defined\n * in the object schema are validated by the object, and remaining properties\n * are validated by the dictionary.\n *\n * @template Left - The ObjectSchema type for fixed properties\n * @template Right - The DictSchema type for additional properties\n *\n * @example\n * ```ts\n * const schema = new IntersectionSchema(\n *   l.object({ name: l.string() }),\n *   l.dict(l.string(), l.integer())\n * )\n * // Validates: { name: 'test', score: 100, count: 5 }\n * ```\n */\nexport class IntersectionSchema<\n  const Left extends ObjectSchema = any,\n  const Right extends DictSchema = any,\n> extends Schema<\n  Simplify<Intersect<InferInput<Left>, InferInput<Right>>>,\n  Simplify<Intersect<InferOutput<Left>, InferOutput<Right>>>\n> {\n  readonly type = 'intersection' as const\n\n  constructor(\n    protected readonly left: Left,\n    protected readonly right: Right,\n  ) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    const leftResult = ctx.validate(input, this.left)\n    if (!leftResult.success) return leftResult\n\n    return this.right.validateInContext(leftResult.value, ctx, {\n      ignoredKeys: this.left.validatorsMap,\n    })\n  }\n}\n\n/**\n * Creates an intersection schema combining fixed object properties with dynamic dictionary properties.\n *\n * Useful for objects that have a known set of properties plus additional\n * arbitrary properties that follow a pattern.\n *\n * @param left - Object schema defining the fixed, known properties\n * @param right - Dictionary schema for validating additional properties\n * @returns A new {@link IntersectionSchema} instance\n *\n * @example\n * ```ts\n * // Object with fixed and dynamic properties\n * const configSchema = l.intersection(\n *   l.object({\n *     version: l.integer(),\n *     name: l.string(),\n *   }),\n *   l.dict(l.string(), l.string()) // Additional string properties\n * )\n *\n * configSchema.parse({\n *   version: 1,\n *   name: 'my-config',\n *   customField: 'value',\n *   anotherField: 'another',\n * })\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function intersection<\n  const Left extends ObjectSchema,\n  const Right extends DictSchema,\n>(left: Left, right: Right) {\n  return new IntersectionSchema<Left, Right>(left, right)\n}\n"]}

package/dist/schema/lex-map.d.ts

@@ -0,0 +1,37 @@
+import { LexMap } from '@atproto/lex-data';
+import { Schema, ValidationContext } from '../core.js';
+export type { LexMap };
+/**
+ * AT Protocol lexicon schema definitions with "type": "unknown" are represented
+ * as plain objects with string keys and values that are valid AT Protocol data
+ * types (string, integer, boolean, null, bytes, cid, array, or object). This
+ * type alias corresponds to the expected structure of such "unknown" schema
+ * values.
+ */
+export declare class LexMapSchema extends Schema<LexMap> {
+    readonly type: "lexMap";
+    validateInContext(input: unknown, ctx: ValidationContext): import("../core.js").ValidationResult<Record<string, unknown>>;
+}
+/**
+ * Creates a schema that accepts any plain object with string keys and values
+ * that are valid AT Protocol data types (string, integer, boolean, null, bytes,
+ * cid, array, or object).
+ *
+ * @see {@link LexMap} from `@atproto/lex-data` for the type definition of valid AT Protocol data types
+ * @returns A new {@link LexMapSchema} instance
+ *
+ * @example
+ * ```ts
+ * // Accept any object shape
+ * const schema = l.lexMap()
+ *
+ * schema.validate({ any: 'props' })    // success
+ * schema.validate([1, 2, 3])           // fails - only plain objects are accepted
+ * schema.validate({ foo: new Date() }) // fails - Date is not a valid LexValue
+ * schema.validate({ foo: 1.2 })        // fails - 1.2 is not a valid LexValue (not an integer)
+ * ```
+ */
+export declare const lexMap: () => LexMapSchema;
+/** @deprecated Use {@link lexMap} instead */
+export declare const unknownObject: () => LexMapSchema;
+//# sourceMappingURL=lex-map.d.ts.map

package/dist/schema/lex-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lex-map.d.ts","sourceRoot":"","sources":["../../src/schema/lex-map.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAiB,MAAM,mBAAmB,CAAA;AACzD,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAMtD,YAAY,EAAE,MAAM,EAAE,CAAA;AAEtB;;;;;;GAMG;AACH,qBAAa,YAAa,SAAQ,MAAM,CAAC,MAAM,CAAC;IAC9C,QAAQ,CAAC,IAAI,EAAG,QAAQ,CAAS;IAEjC,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;CAiBzD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,MAAM,oBAEjB,CAAA;AAEF,6CAA6C;AAC7C,eAAO,MAAM,aAAa,oBAAS,CAAA"}

package/dist/schema/lex-map.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unknownObject = exports.lexMap = exports.LexMapSchema = void 0;
+const lex_data_1 = require("@atproto/lex-data");
+const core_js_1 = require("../core.js");
+const memoize_js_1 = require("../util/memoize.js");
+const lex_value_js_1 = require("./lex-value.js");
+const propertyValueSchema = /*#__PURE__*/ (0, lex_value_js_1.lexValue)();
+/**
+ * AT Protocol lexicon schema definitions with "type": "unknown" are represented
+ * as plain objects with string keys and values that are valid AT Protocol data
+ * types (string, integer, boolean, null, bytes, cid, array, or object). This
+ * type alias corresponds to the expected structure of such "unknown" schema
+ * values.
+ */
+class LexMapSchema extends core_js_1.Schema {
+    type = 'lexMap';
+    validateInContext(input, ctx) {
+        if (!(0, lex_data_1.isPlainObject)(input)) {
+            return ctx.issueUnexpectedType(input, 'object');
+        }
+        for (const key of Object.keys(input)) {
+            // @NOTE We use a lexValue() schema here to recursively validate all
+            // nested values, which ensures that the error reporting includes the
+            // correct path and type information for any invalid nested values. This
+            // allows for more informative error descriptions than a simple "isLexMap"
+            // check.
+            const r = ctx.validateChild(input, key, propertyValueSchema); // recursively validate all properties
+            if (!r.success)
+                return r;
+        }
+        return ctx.success(input);
+    }
+}
+exports.LexMapSchema = LexMapSchema;
+/**
+ * Creates a schema that accepts any plain object with string keys and values
+ * that are valid AT Protocol data types (string, integer, boolean, null, bytes,
+ * cid, array, or object).
+ *
+ * @see {@link LexMap} from `@atproto/lex-data` for the type definition of valid AT Protocol data types
+ * @returns A new {@link LexMapSchema} instance
+ *
+ * @example
+ * ```ts
+ * // Accept any object shape
+ * const schema = l.lexMap()
+ *
+ * schema.validate({ any: 'props' })    // success
+ * schema.validate([1, 2, 3])           // fails - only plain objects are accepted
+ * schema.validate({ foo: new Date() }) // fails - Date is not a valid LexValue
+ * schema.validate({ foo: 1.2 })        // fails - 1.2 is not a valid LexValue (not an integer)
+ * ```
+ */
+exports.lexMap = (0, memoize_js_1.memoizedOptions)(function () {
+    return new LexMapSchema();
+});
+/** @deprecated Use {@link lexMap} instead */
+exports.unknownObject = exports.lexMap;
+//# sourceMappingURL=lex-map.js.map

package/dist/schema/lex-map.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lex-map.js","sourceRoot":"","sources":["../../src/schema/lex-map.ts"],"names":[],"mappings":";;;AAAA,gDAAyD;AACzD,wCAAsD;AACtD,mDAAoD;AACpD,iDAAyC;AAEzC,MAAM,mBAAmB,GAAG,aAAa,CAAC,IAAA,uBAAQ,GAAE,CAAA;AAIpD;;;;;;GAMG;AACH,MAAa,YAAa,SAAQ,gBAAc;IACrC,IAAI,GAAG,QAAiB,CAAA;IAEjC,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,CAAC,IAAA,wBAAa,EAAC,KAAK,CAAC,EAAE,CAAC;YAC1B,OAAO,GAAG,CAAC,mBAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAA;QACjD,CAAC;QAED,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;YACrC,oEAAoE;YACpE,qEAAqE;YACrE,wEAAwE;YACxE,0EAA0E;YAC1E,SAAS;YACT,MAAM,CAAC,GAAG,GAAG,CAAC,aAAa,CAAC,KAAK,EAAE,GAAG,EAAE,mBAAmB,CAAC,CAAA,CAAC,sCAAsC;YACnG,IAAI,CAAC,CAAC,CAAC,OAAO;gBAAE,OAAO,CAAC,CAAA;QAC1B,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IAC3B,CAAC;CACF;AApBD,oCAoBC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACU,QAAA,MAAM,GAAiB,IAAA,4BAAe,EAAC;IAClD,OAAO,IAAI,YAAY,EAAE,CAAA;AAC3B,CAAC,CAAC,CAAA;AAEF,6CAA6C;AAChC,QAAA,aAAa,GAAG,cAAM,CAAA","sourcesContent":["import { LexMap, isPlainObject } from '@atproto/lex-data'\nimport { Schema, ValidationContext } from '../core.js'\nimport { memoizedOptions } from '../util/memoize.js'\nimport { lexValue } from './lex-value.js'\n\nconst propertyValueSchema = /*#__PURE__*/ lexValue()\n\nexport type { LexMap }\n\n/**\n * AT Protocol lexicon schema definitions with \"type\": \"unknown\" are represented\n * as plain objects with string keys and values that are valid AT Protocol data\n * types (string, integer, boolean, null, bytes, cid, array, or object). This\n * type alias corresponds to the expected structure of such \"unknown\" schema\n * values.\n */\nexport class LexMapSchema extends Schema<LexMap> {\n  readonly type = 'lexMap' as const\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!isPlainObject(input)) {\n      return ctx.issueUnexpectedType(input, 'object')\n    }\n\n    for (const key of Object.keys(input)) {\n      // @NOTE We use a lexValue() schema here to recursively validate all\n      // nested values, which ensures that the error reporting includes the\n      // correct path and type information for any invalid nested values. This\n      // allows for more informative error descriptions than a simple \"isLexMap\"\n      // check.\n      const r = ctx.validateChild(input, key, propertyValueSchema) // recursively validate all properties\n      if (!r.success) return r\n    }\n\n    return ctx.success(input)\n  }\n}\n\n/**\n * Creates a schema that accepts any plain object with string keys and values\n * that are valid AT Protocol data types (string, integer, boolean, null, bytes,\n * cid, array, or object).\n *\n * @see {@link LexMap} from `@atproto/lex-data` for the type definition of valid AT Protocol data types\n * @returns A new {@link LexMapSchema} instance\n *\n * @example\n * ```ts\n * // Accept any object shape\n * const schema = l.lexMap()\n *\n * schema.validate({ any: 'props' })    // success\n * schema.validate([1, 2, 3])           // fails - only plain objects are accepted\n * schema.validate({ foo: new Date() }) // fails - Date is not a valid LexValue\n * schema.validate({ foo: 1.2 })        // fails - 1.2 is not a valid LexValue (not an integer)\n * ```\n */\nexport const lexMap = /*#__PURE__*/ memoizedOptions(function () {\n  return new LexMapSchema()\n})\n\n/** @deprecated Use {@link lexMap} instead */\nexport const unknownObject = lexMap\n"]}

package/dist/schema/lex-value.d.ts

@@ -0,0 +1,35 @@
+import { LexValue } from '@atproto/lex-data';
+import { Schema, ValidationContext } from '../core.js';
+export type { LexValue };
+/**
+ * AT Protocol lexicon values are any valid AT Protocol data types: string,
+ * integer, boolean, null, bytes, cid, array, or object.
+ */
+export declare class LexValueSchema extends Schema<LexValue> {
+    readonly type: "lexValue";
+    validateInContext(input: unknown, ctx: ValidationContext): import("../core.js").ValidationResult<any[] | Record<string, unknown> | import("@atproto/lex-data").LexScalar>;
+}
+/**
+ * Creates a schema that accepts any valid AT Protocol data type: string,
+ * integer, boolean, null, bytes, cid, array, or plain object. Arrays and
+ * objects are recursively validated to ensure all nested values are also valid
+ * AT Protocol data types.
+ *
+ * @see {@link LexValue} from `@atproto/lex-data` for the type definition of valid AT Protocol data types
+ * @returns A new {@link LexValueSchema} instance
+ *
+ * @example
+ * ```ts
+ * const schema = l.lexValue()
+ *
+ * schema.validate('hello')              // success
+ * schema.validate(42)                   // success
+ * schema.validate(null)                 // success
+ * schema.validate([1, 'two', null])     // success
+ * schema.validate({ any: 'props' })     // success
+ * schema.validate(new Date())           // fails - Date is not a valid LexValue
+ * schema.validate({ foo: 1.2 })         // fails - 1.2 is not a valid LexValue (not an integer)
+ * ```
+ */
+export declare const lexValue: () => LexValueSchema;
+//# sourceMappingURL=lex-value.d.ts.map

package/dist/schema/lex-value.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lex-value.d.ts","sourceRoot":"","sources":["../../src/schema/lex-value.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAA8B,MAAM,mBAAmB,CAAA;AACxE,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAGtD,YAAY,EAAE,QAAQ,EAAE,CAAA;AAexB;;;GAGG;AACH,qBAAa,cAAe,SAAQ,MAAM,CAAC,QAAQ,CAAC;IAClD,QAAQ,CAAC,IAAI,EAAG,UAAU,CAAS;IAEnC,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;CAiCzD;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,QAAQ,sBAEnB,CAAA"}

package/dist/schema/lex-value.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lexValue = exports.LexValueSchema = void 0;
+const lex_data_1 = require("@atproto/lex-data");
+const core_js_1 = require("../core.js");
+const memoize_js_1 = require("../util/memoize.js");
+const EXPECTED_TYPES = Object.freeze([
+    // Scalar types
+    'null',
+    'boolean',
+    'integer',
+    'string',
+    'cid',
+    'bytes',
+    // Recursive types
+    'array',
+    'object',
+]);
+/**
+ * AT Protocol lexicon values are any valid AT Protocol data types: string,
+ * integer, boolean, null, bytes, cid, array, or object.
+ */
+class LexValueSchema extends core_js_1.Schema {
+    type = 'lexValue';
+    validateInContext(input, ctx) {
+        // @NOTE We are *not* using "isLexValue" here to allow for more specific
+        // error messages about the path and type of the invalid value. The
+        // "isLexValue" check is effectively performed by the recursive validation
+        // of child properties below.
+        // @NOTE There are two limitations to the fact that we are not using
+        // "isLexValue" here:
+        // 1. We cannot detect circular references in objects or arrays, which would
+        //    cause infinite recursion. However, circular references are not valid
+        //    AT Protocol data types, so this is not a concern for valid input. This
+        //    could easily be addressed in the "validateChild" method by keeping
+        //    track of "parent" objects.
+        // 2. We are limited in the recursion depth we can validate due to potential
+        //    recursion depth limits in JavaScript. However, this is also not a
+        //    concern for most valid input, as extremely deep nesting is unlikely in
+        //    typical use cases.
+        if ((0, lex_data_1.isPlainObject)(input)) {
+            for (const key of Object.keys(input)) {
+                const r = ctx.validateChild(input, key, this); // recursively validate all properties
+                if (!r.success)
+                    return r;
+            }
+        }
+        else if (Array.isArray(input)) {
+            for (let i = 0; i < input.length; i++) {
+                const r = ctx.validateChild(input, i, this); // recursively validate all array items
+                if (!r.success)
+                    return r;
+            }
+        }
+        else if (!(0, lex_data_1.isLexScalar)(input)) {
+            return ctx.issueInvalidType(input, EXPECTED_TYPES);
+        }
+        return ctx.success(input);
+    }
+}
+exports.LexValueSchema = LexValueSchema;
+/**
+ * Creates a schema that accepts any valid AT Protocol data type: string,
+ * integer, boolean, null, bytes, cid, array, or plain object. Arrays and
+ * objects are recursively validated to ensure all nested values are also valid
+ * AT Protocol data types.
+ *
+ * @see {@link LexValue} from `@atproto/lex-data` for the type definition of valid AT Protocol data types
+ * @returns A new {@link LexValueSchema} instance
+ *
+ * @example
+ * ```ts
+ * const schema = l.lexValue()
+ *
+ * schema.validate('hello')              // success
+ * schema.validate(42)                   // success
+ * schema.validate(null)                 // success
+ * schema.validate([1, 'two', null])     // success
+ * schema.validate({ any: 'props' })     // success
+ * schema.validate(new Date())           // fails - Date is not a valid LexValue
+ * schema.validate({ foo: 1.2 })         // fails - 1.2 is not a valid LexValue (not an integer)
+ * ```
+ */
+exports.lexValue = (0, memoize_js_1.memoizedOptions)(function () {
+    return new LexValueSchema();
+});
+//# sourceMappingURL=lex-value.js.map

package/dist/schema/lex-value.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lex-value.js","sourceRoot":"","sources":["../../src/schema/lex-value.ts"],"names":[],"mappings":";;;AAAA,gDAAwE;AACxE,wCAAsD;AACtD,mDAAoD;AAIpD,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,CAAC;IACnC,eAAe;IACf,MAAM;IACN,SAAS;IACT,SAAS;IACT,QAAQ;IACR,KAAK;IACL,OAAO;IACP,kBAAkB;IAClB,OAAO;IACP,QAAQ;CACA,CAAC,CAAA;AAEX;;;GAGG;AACH,MAAa,cAAe,SAAQ,gBAAgB;IACzC,IAAI,GAAG,UAAmB,CAAA;IAEnC,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,wEAAwE;QACxE,mEAAmE;QACnE,0EAA0E;QAC1E,6BAA6B;QAE7B,oEAAoE;QACpE,qBAAqB;QACrB,4EAA4E;QAC5E,0EAA0E;QAC1E,4EAA4E;QAC5E,wEAAwE;QACxE,gCAAgC;QAChC,4EAA4E;QAC5E,uEAAuE;QACvE,4EAA4E;QAC5E,wBAAwB;QACxB,IAAI,IAAA,wBAAa,EAAC,KAAK,CAAC,EAAE,CAAC;YACzB,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;gBACrC,MAAM,CAAC,GAAG,GAAG,CAAC,aAAa,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,CAAC,CAAA,CAAC,sCAAsC;gBACpF,IAAI,CAAC,CAAC,CAAC,OAAO;oBAAE,OAAO,CAAC,CAAA;YAC1B,CAAC;QACH,CAAC;aAAM,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YAChC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBACtC,MAAM,CAAC,GAAG,GAAG,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC,EAAE,IAAI,CAAC,CAAA,CAAC,uCAAuC;gBACnF,IAAI,CAAC,CAAC,CAAC,OAAO;oBAAE,OAAO,CAAC,CAAA;YAC1B,CAAC;QACH,CAAC;aAAM,IAAI,CAAC,IAAA,sBAAW,EAAC,KAAK,CAAC,EAAE,CAAC;YAC/B,OAAO,GAAG,CAAC,gBAAgB,CAAC,KAAK,EAAE,cAAc,CAAC,CAAA;QACpD,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IAC3B,CAAC;CACF;AApCD,wCAoCC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACU,QAAA,QAAQ,GAAiB,IAAA,4BAAe,EAAC;IACpD,OAAO,IAAI,cAAc,EAAE,CAAA;AAC7B,CAAC,CAAC,CAAA","sourcesContent":["import { LexValue, isLexScalar, isPlainObject } from '@atproto/lex-data'\nimport { Schema, ValidationContext } from '../core.js'\nimport { memoizedOptions } from '../util/memoize.js'\n\nexport type { LexValue }\n\nconst EXPECTED_TYPES = Object.freeze([\n  // Scalar types\n  'null',\n  'boolean',\n  'integer',\n  'string',\n  'cid',\n  'bytes',\n  // Recursive types\n  'array',\n  'object',\n] as const)\n\n/**\n * AT Protocol lexicon values are any valid AT Protocol data types: string,\n * integer, boolean, null, bytes, cid, array, or object.\n */\nexport class LexValueSchema extends Schema<LexValue> {\n  readonly type = 'lexValue' as const\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    // @NOTE We are *not* using \"isLexValue\" here to allow for more specific\n    // error messages about the path and type of the invalid value. The\n    // \"isLexValue\" check is effectively performed by the recursive validation\n    // of child properties below.\n\n    // @NOTE There are two limitations to the fact that we are not using\n    // \"isLexValue\" here:\n    // 1. We cannot detect circular references in objects or arrays, which would\n    //    cause infinite recursion. However, circular references are not valid\n    //    AT Protocol data types, so this is not a concern for valid input. This\n    //    could easily be addressed in the \"validateChild\" method by keeping\n    //    track of \"parent\" objects.\n    // 2. We are limited in the recursion depth we can validate due to potential\n    //    recursion depth limits in JavaScript. However, this is also not a\n    //    concern for most valid input, as extremely deep nesting is unlikely in\n    //    typical use cases.\n    if (isPlainObject(input)) {\n      for (const key of Object.keys(input)) {\n        const r = ctx.validateChild(input, key, this) // recursively validate all properties\n        if (!r.success) return r\n      }\n    } else if (Array.isArray(input)) {\n      for (let i = 0; i < input.length; i++) {\n        const r = ctx.validateChild(input, i, this) // recursively validate all array items\n        if (!r.success) return r\n      }\n    } else if (!isLexScalar(input)) {\n      return ctx.issueInvalidType(input, EXPECTED_TYPES)\n    }\n\n    return ctx.success(input)\n  }\n}\n\n/**\n * Creates a schema that accepts any valid AT Protocol data type: string,\n * integer, boolean, null, bytes, cid, array, or plain object. Arrays and\n * objects are recursively validated to ensure all nested values are also valid\n * AT Protocol data types.\n *\n * @see {@link LexValue} from `@atproto/lex-data` for the type definition of valid AT Protocol data types\n * @returns A new {@link LexValueSchema} instance\n *\n * @example\n * ```ts\n * const schema = l.lexValue()\n *\n * schema.validate('hello')              // success\n * schema.validate(42)                   // success\n * schema.validate(null)                 // success\n * schema.validate([1, 'two', null])     // success\n * schema.validate({ any: 'props' })     // success\n * schema.validate(new Date())           // fails - Date is not a valid LexValue\n * schema.validate({ foo: 1.2 })         // fails - 1.2 is not a valid LexValue (not an integer)\n * ```\n */\nexport const lexValue = /*#__PURE__*/ memoizedOptions(function () {\n  return new LexValueSchema()\n})\n"]}

package/dist/schema/literal.d.ts

@@ -1,8 +1,53 @@
 import { Schema, ValidationContext } from '../core.js';
+/**
+ * Schema that only accepts a specific literal value.
+ *
+ * Validates that the input is exactly equal to the specified value using
+ * strict equality (===).
+ *
+ * @template TValue - The literal type (null, string, number, or boolean)
+ *
+ * @example
+ * ```ts
+ * const schema = new LiteralSchema('admin')
+ * schema.validate('admin') // success
+ * schema.validate('user')  // fails
+ * ```
+ */
 export declare class LiteralSchema<const TValue extends null | string | number | boolean> extends Schema<TValue> {
     readonly value: TValue;
+    readonly type: "literal";
     constructor(value: TValue);
     validateInContext(input: unknown, ctx: ValidationContext): import("../core.js").ValidationResult<TValue>;
 }
+/**
+ * Creates a literal schema that only accepts the exact specified value.
+ *
+ * Useful for discriminator fields in unions, constant values, or type narrowing.
+ *
+ * @param value - The exact value that must be matched
+ * @returns A new {@link LiteralSchema} instance
+ *
+ * @example
+ * ```ts
+ * // String literal
+ * const roleSchema = l.literal('admin')
+ *
+ * // Number literal
+ * const versionSchema = l.literal(1)
+ *
+ * // Boolean literal
+ * const enabledSchema = l.literal(true)
+ *
+ * // Null literal
+ * const nullSchema = l.literal(null)
+ *
+ * // In discriminated unions
+ * const actionSchema = l.discriminatedUnion('type', [
+ *   l.object({ type: l.literal('create'), data: l.unknown() }),
+ *   l.object({ type: l.literal('delete'), id: l.string() }),
+ * ])
+ * ```
+ */
 export declare function literal<const V extends null | string | number | boolean>(value: V): LiteralSchema<V>;
 //# sourceMappingURL=literal.d.ts.map

package/dist/schema/literal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"literal.d.ts","sourceRoot":"","sources":["../../src/schema/literal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAEtD,qBAAa,aAAa,CACxB,KAAK,CAAC,MAAM,SAAS,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CACrD,SAAQ,MAAM,CAAC,MAAM,CAAC;IACV,QAAQ,CAAC,KAAK,EAAE,MAAM;gBAAb,KAAK,EAAE,MAAM;IAIlC,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;CAOzD;AAGD,wBAAgB,OAAO,CAAC,KAAK,CAAC,CAAC,SAAS,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,EACtE,KAAK,EAAE,CAAC,oBAGT"}
+{"version":3,"file":"literal.d.ts","sourceRoot":"","sources":["../../src/schema/literal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAEtD;;;;;;;;;;;;;;GAcG;AACH,qBAAa,aAAa,CACxB,KAAK,CAAC,MAAM,SAAS,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CACrD,SAAQ,MAAM,CAAC,MAAM,CAAC;IAGV,QAAQ,CAAC,KAAK,EAAE,MAAM;IAFlC,QAAQ,CAAC,IAAI,EAAG,SAAS,CAAS;gBAEb,KAAK,EAAE,MAAM;IAIlC,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;CAOzD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,wBAAgB,OAAO,CAAC,KAAK,CAAC,CAAC,SAAS,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,EACtE,KAAK,EAAE,CAAC,oBAGT"}