@atproto/lex-schema 0.0.0

package/dist/schema/dict.d.ts

@@ -0,0 +1,18 @@
+import { Infer, ValidationResult, Validator, ValidatorContext } from '../validation.js';
+export type DictSchemaOutput<KeySchema extends Validator, ValueSchema extends Validator> = Infer<KeySchema> extends never ? Record<string, never> : Record<Infer<KeySchema> & string, Infer<ValueSchema>>;
+/**
+ * @note There is no dictionary in Lexicon schemas. This is a custom extension
+ * to allow map-like objects when using the lex library programmatically (i.e.
+ * not code generated from a lexicon schema).
+ */
+export declare class DictSchema<const KeySchema extends Validator = any, const ValueSchema extends Validator = any> extends Validator<DictSchemaOutput<KeySchema, ValueSchema>> {
+    readonly keySchema: KeySchema;
+    readonly valueSchema: ValueSchema;
+    constructor(keySchema: KeySchema, valueSchema: ValueSchema);
+    validateInContext(input: unknown, ctx: ValidatorContext, options?: {
+        ignoredKeys?: {
+            has(k: string): boolean;
+        };
+    }): ValidationResult<DictSchemaOutput<KeySchema, ValueSchema>>;
+}
+//# sourceMappingURL=dict.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dict.d.ts","sourceRoot":"","sources":["../../src/schema/dict.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,EACL,gBAAgB,EAChB,SAAS,EACT,gBAAgB,EACjB,MAAM,kBAAkB,CAAA;AAEzB,MAAM,MAAM,gBAAgB,CAC1B,SAAS,SAAS,SAAS,EAC3B,WAAW,SAAS,SAAS,IAE7B,KAAK,CAAC,SAAS,CAAC,SAAS,KAAK,GAC1B,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,GACrB,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,GAAG,MAAM,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC,CAAA;AAE3D;;;;GAIG;AACH,qBAAa,UAAU,CACrB,KAAK,CAAC,SAAS,SAAS,SAAS,GAAG,GAAG,EACvC,KAAK,CAAC,WAAW,SAAS,SAAS,GAAG,GAAG,CACzC,SAAQ,SAAS,CAAC,gBAAgB,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;IAEzD,QAAQ,CAAC,SAAS,EAAE,SAAS;IAC7B,QAAQ,CAAC,WAAW,EAAE,WAAW;gBADxB,SAAS,EAAE,SAAS,EACpB,WAAW,EAAE,WAAW;IAK1B,iBAAiB,CACxB,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,gBAAgB,EACrB,OAAO,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE;YAAE,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;SAAE,CAAA;KAAE,GACtD,gBAAgB,CAAC,gBAAgB,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;CAgC9D"}

package/dist/schema/dict.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DictSchema = void 0;
+const lex_data_1 = require("@atproto/lex-data");
+const validation_js_1 = require("../validation.js");
+/**
+ * @note There is no dictionary in Lexicon schemas. This is a custom extension
+ * to allow map-like objects when using the lex library programmatically (i.e.
+ * not code generated from a lexicon schema).
+ */
+class DictSchema extends validation_js_1.Validator {
+    keySchema;
+    valueSchema;
+    constructor(keySchema, valueSchema) {
+        super();
+        this.keySchema = keySchema;
+        this.valueSchema = valueSchema;
+    }
+    validateInContext(input, ctx, options) {
+        if (!(0, lex_data_1.isPlainObject)(input)) {
+            return ctx.issueInvalidType(input, 'dict');
+        }
+        let copy;
+        for (const key in input) {
+            if (options?.ignoredKeys?.has(key))
+                continue;
+            const keyResult = ctx.validate(key, this.keySchema);
+            if (!keyResult.success)
+                return keyResult;
+            if (keyResult.value !== key) {
+                // We can't safely "move" the key to a different name in the output
+                // object (because there may already be something there), so we issue a
+                // "required key" error if the key validation changes the key
+                return ctx.issueRequiredKey(input, key);
+            }
+            const valueResult = ctx.validateChild(input, key, this.valueSchema);
+            if (!valueResult.success)
+                return valueResult;
+            if (valueResult.value !== input[key]) {
+                copy ??= { ...input };
+                copy[key] = valueResult.value;
+            }
+        }
+        return ctx.success((copy ?? input));
+    }
+}
+exports.DictSchema = DictSchema;
+//# sourceMappingURL=dict.js.map

package/dist/schema/dict.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dict.js","sourceRoot":"","sources":["../../src/schema/dict.ts"],"names":[],"mappings":";;;AAAA,gDAAiD;AACjD,oDAKyB;AAUzB;;;;GAIG;AACH,MAAa,UAGX,SAAQ,yBAAmD;IAEhD;IACA;IAFX,YACW,SAAoB,EACpB,WAAwB;QAEjC,KAAK,EAAE,CAAA;QAHE,cAAS,GAAT,SAAS,CAAW;QACpB,gBAAW,GAAX,WAAW,CAAa;IAGnC,CAAC;IAEQ,iBAAiB,CACxB,KAAc,EACd,GAAqB,EACrB,OAAuD;QAEvD,IAAI,CAAC,IAAA,wBAAa,EAAC,KAAK,CAAC,EAAE,CAAC;YAC1B,OAAO,GAAG,CAAC,gBAAgB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;QAC5C,CAAC;QAED,IAAI,IAAyC,CAAA;QAE7C,KAAK,MAAM,GAAG,IAAI,KAAK,EAAE,CAAC;YACxB,IAAI,OAAO,EAAE,WAAW,EAAE,GAAG,CAAC,GAAG,CAAC;gBAAE,SAAQ;YAE5C,MAAM,SAAS,GAAG,GAAG,CAAC,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAC,SAAS,CAAC,CAAA;YACnD,IAAI,CAAC,SAAS,CAAC,OAAO;gBAAE,OAAO,SAAS,CAAA;YACxC,IAAI,SAAS,CAAC,KAAK,KAAK,GAAG,EAAE,CAAC;gBAC5B,mEAAmE;gBACnE,uEAAuE;gBACvE,6DAA6D;gBAC7D,OAAO,GAAG,CAAC,gBAAgB,CAAC,KAAK,EAAE,GAAG,CAAC,CAAA;YACzC,CAAC;YAED,MAAM,WAAW,GAAG,GAAG,CAAC,aAAa,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,CAAC,WAAW,CAAC,CAAA;YACnE,IAAI,CAAC,WAAW,CAAC,OAAO;gBAAE,OAAO,WAAW,CAAA;YAE5C,IAAI,WAAW,CAAC,KAAK,KAAK,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;gBACrC,IAAI,KAAK,EAAE,GAAG,KAAK,EAAE,CAAA;gBACrB,IAAI,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,KAAK,CAAA;YAC/B,CAAC;QACH,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAChB,CAAC,IAAI,IAAI,KAAK,CAA6C,CAC5D,CAAA;IACH,CAAC;CACF;AA/CD,gCA+CC","sourcesContent":["import { isPlainObject } from '@atproto/lex-data'\nimport {\n  Infer,\n  ValidationResult,\n  Validator,\n  ValidatorContext,\n} from '../validation.js'\n\nexport type DictSchemaOutput<\n  KeySchema extends Validator,\n  ValueSchema extends Validator,\n> =\n  Infer<KeySchema> extends never\n    ? Record<string, never>\n    : Record<Infer<KeySchema> & string, Infer<ValueSchema>>\n\n/**\n * @note There is no dictionary in Lexicon schemas. This is a custom extension\n * to allow map-like objects when using the lex library programmatically (i.e.\n * not code generated from a lexicon schema).\n */\nexport class DictSchema<\n  const KeySchema extends Validator = any,\n  const ValueSchema extends Validator = any,\n> extends Validator<DictSchemaOutput<KeySchema, ValueSchema>> {\n  constructor(\n    readonly keySchema: KeySchema,\n    readonly valueSchema: ValueSchema,\n  ) {\n    super()\n  }\n\n  override validateInContext(\n    input: unknown,\n    ctx: ValidatorContext,\n    options?: { ignoredKeys?: { has(k: string): boolean } },\n  ): ValidationResult<DictSchemaOutput<KeySchema, ValueSchema>> {\n    if (!isPlainObject(input)) {\n      return ctx.issueInvalidType(input, 'dict')\n    }\n\n    let copy: undefined | Record<string, unknown>\n\n    for (const key in input) {\n      if (options?.ignoredKeys?.has(key)) continue\n\n      const keyResult = ctx.validate(key, this.keySchema)\n      if (!keyResult.success) return keyResult\n      if (keyResult.value !== key) {\n        // We can't safely \"move\" the key to a different name in the output\n        // object (because there may already be something there), so we issue a\n        // \"required key\" error if the key validation changes the key\n        return ctx.issueRequiredKey(input, key)\n      }\n\n      const valueResult = ctx.validateChild(input, key, this.valueSchema)\n      if (!valueResult.success) return valueResult\n\n      if (valueResult.value !== input[key]) {\n        copy ??= { ...input }\n        copy[key] = valueResult.value\n      }\n    }\n\n    return ctx.success(\n      (copy ?? input) as DictSchemaOutput<KeySchema, ValueSchema>,\n    )\n  }\n}\n"]}

package/dist/schema/discriminated-union.d.ts

@@ -0,0 +1,34 @@
+import { ArrayContaining } from '../core.js';
+import { ValidationResult, Validator, ValidatorContext } from '../validation.js';
+import { ObjectSchema } from './object.js';
+export type DiscriminatedUnionSchemaVariant<Discriminator extends string> = ObjectSchema<{
+    [_ in Discriminator]: Validator;
+}, {
+    required: ArrayContaining<Discriminator, string>;
+}>;
+export type DiscriminatedUnionSchemaVariants<Discriminator extends string> = readonly [
+    DiscriminatedUnionSchemaVariant<Discriminator>,
+    ...DiscriminatedUnionSchemaVariant<Discriminator>[]
+];
+export type DiscriminatedUnionSchemaOutput<Options extends readonly Validator[]> = Options extends readonly [Validator<infer V>] ? V : Options extends readonly [
+    Validator<infer V>,
+    ...infer Rest extends Validator[]
+] ? V | DiscriminatedUnionSchemaOutput<Rest> : never;
+/**
+ * @note There is no discriminated union in Lexicon schemas. This is a custom
+ * extension to allow optimized validation of union of objects when using the
+ * lex library programmatically (i.e. not code generated from a lexicon schema).
+ */
+export declare class DiscriminatedUnionSchema<const Discriminator extends string = any, const Options extends DiscriminatedUnionSchemaVariants<Discriminator> = any> extends Validator<DiscriminatedUnionSchemaOutput<Options>> {
+    readonly discriminator: Discriminator;
+    readonly variants: Options;
+    constructor(discriminator: Discriminator, variants: Options);
+    /**
+     * If all variants have a literal or enum for the discriminator property,
+     * and there are no overlapping values, returns a map of discriminator values
+     * to variants. Otherwise, returns null.
+     */
+    protected get variantsMap(): Map<unknown, DiscriminatedUnionSchemaVariant<Discriminator>> | null;
+    validateInContext(input: unknown, ctx: ValidatorContext): ValidationResult<DiscriminatedUnionSchemaOutput<Options>>;
+}
+//# sourceMappingURL=discriminated-union.d.ts.map

package/dist/schema/discriminated-union.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discriminated-union.d.ts","sourceRoot":"","sources":["../../src/schema/discriminated-union.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAC5C,OAAO,EAGL,gBAAgB,EAChB,SAAS,EACT,gBAAgB,EACjB,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE1C,MAAM,MAAM,+BAA+B,CAAC,aAAa,SAAS,MAAM,IACtE,YAAY,CACV;KAAG,CAAC,IAAI,aAAa,GAAG,SAAS;CAAE,EACnC;IAAE,QAAQ,EAAE,eAAe,CAAC,aAAa,EAAE,MAAM,CAAC,CAAA;CAAE,CACrD,CAAA;AAEH,MAAM,MAAM,gCAAgC,CAAC,aAAa,SAAS,MAAM,IACvE,SAAS;IACP,+BAA+B,CAAC,aAAa,CAAC;IAC9C,GAAG,+BAA+B,CAAC,aAAa,CAAC,EAAE;CACpD,CAAA;AAEH,MAAM,MAAM,8BAA8B,CACxC,OAAO,SAAS,SAAS,SAAS,EAAE,IAClC,OAAO,SAAS,SAAS,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,GAC7C,CAAC,GACD,OAAO,SAAS,SAAS;IACrB,SAAS,CAAC,MAAM,CAAC,CAAC;IAClB,GAAG,MAAM,IAAI,SAAS,SAAS,EAAE;CAClC,GACD,CAAC,GAAG,8BAA8B,CAAC,IAAI,CAAC,GACxC,KAAK,CAAA;AAEX;;;;GAIG;AACH,qBAAa,wBAAwB,CACnC,KAAK,CAAC,aAAa,SAAS,MAAM,GAAG,GAAG,EACxC,KAAK,CAAC,OAAO,SAAS,gCAAgC,CAAC,aAAa,CAAC,GAAG,GAAG,CAC3E,SAAQ,SAAS,CAAC,8BAA8B,CAAC,OAAO,CAAC,CAAC;IAExD,QAAQ,CAAC,aAAa,EAAE,aAAa;IACrC,QAAQ,CAAC,QAAQ,EAAE,OAAO;gBADjB,aAAa,EAAE,aAAa,EAC5B,QAAQ,EAAE,OAAO;IAK5B;;;;OAIG;IACH,SAAS,KAAK,WAAW,wEA6BxB;IAEQ,iBAAiB,CACxB,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,gBAAgB,GACpB,gBAAgB,CAAC,8BAA8B,CAAC,OAAO,CAAC,CAAC;CAoD7D"}

package/dist/schema/discriminated-union.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscriminatedUnionSchema = void 0;
+const lex_data_1 = require("@atproto/lex-data");
+const validation_js_1 = require("../validation.js");
+const enum_js_1 = require("./enum.js");
+const literal_js_1 = require("./literal.js");
+/**
+ * @note There is no discriminated union in Lexicon schemas. This is a custom
+ * extension to allow optimized validation of union of objects when using the
+ * lex library programmatically (i.e. not code generated from a lexicon schema).
+ */
+class DiscriminatedUnionSchema extends validation_js_1.Validator {
+    discriminator;
+    variants;
+    constructor(discriminator, variants) {
+        super();
+        this.discriminator = discriminator;
+        this.variants = variants;
+    }
+    /**
+     * If all variants have a literal or enum for the discriminator property,
+     * and there are no overlapping values, returns a map of discriminator values
+     * to variants. Otherwise, returns null.
+     */
+    get variantsMap() {
+        const map = new Map();
+        for (const variant of this.variants) {
+            const schema = variant.validators[this.discriminator];
+            if (schema instanceof literal_js_1.LiteralSchema) {
+                if (map.has(schema.value))
+                    return null; // overlapping value
+                map.set(schema.value, variant);
+            }
+            else if (schema instanceof enum_js_1.EnumSchema) {
+                for (const val of schema.values) {
+                    if (map.has(val))
+                        return null; // overlapping value
+                    map.set(val, variant);
+                }
+            }
+            else {
+                return null; // not a literal or enum
+            }
+        }
+        // Cache the map on the instance (to avoid re-computing)
+        Object.defineProperty(this, 'variantsMap', {
+            value: map,
+            writable: false,
+            enumerable: false,
+            configurable: true,
+        });
+        return map;
+    }
+    validateInContext(input, ctx) {
+        if (!(0, lex_data_1.isPlainObject)(input)) {
+            return ctx.issueInvalidType(input, 'object');
+        }
+        if (!Object.hasOwn(input, this.discriminator)) {
+            return ctx.issueRequiredKey(input, this.discriminator);
+        }
+        // Fast path: if we have a mapping of discriminator values to variants,
+        // we can directly select the correct variant to validate against. This also
+        // outputs a better error (with a single failure issue) when the discriminator.
+        if (this.variantsMap) {
+            const variant = this.variantsMap.get(input[this.discriminator]);
+            if (!variant) {
+                return ctx.issueInvalidPropertyValue(input, this.discriminator, [
+                    ...this.variantsMap.keys(),
+                ]);
+            }
+            return ctx.validate(input, variant);
+        }
+        // Slow path: try validating against each variant and return the first
+        // successful one (or aggregate all failures if none match).
+        const failures = [];
+        for (const variant of this.variants) {
+            const discSchema = variant.validators[this.discriminator];
+            const discResult = ctx.validateChild(input, this.discriminator, discSchema);
+            if (!discResult.success) {
+                failures.push(discResult);
+                continue;
+            }
+            return ctx.validate(input, variant);
+        }
+        return {
+            success: false,
+            error: validation_js_1.ValidationError.fromFailures(failures),
+        };
+    }
+}
+exports.DiscriminatedUnionSchema = DiscriminatedUnionSchema;
+//# sourceMappingURL=discriminated-union.js.map

package/dist/schema/discriminated-union.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"discriminated-union.js","sourceRoot":"","sources":["../../src/schema/discriminated-union.ts"],"names":[],"mappings":"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","sourcesContent":["import { isPlainObject } from '@atproto/lex-data'\nimport { ArrayContaining } from '../core.js'\nimport {\n  ValidationError,\n  ValidationFailure,\n  ValidationResult,\n  Validator,\n  ValidatorContext,\n} from '../validation.js'\nimport { EnumSchema } from './enum.js'\nimport { LiteralSchema } from './literal.js'\nimport { ObjectSchema } from './object.js'\n\nexport type DiscriminatedUnionSchemaVariant<Discriminator extends string> =\n  ObjectSchema<\n    { [_ in Discriminator]: Validator },\n    { required: ArrayContaining<Discriminator, string> }\n  >\n\nexport type DiscriminatedUnionSchemaVariants<Discriminator extends string> =\n  readonly [\n    DiscriminatedUnionSchemaVariant<Discriminator>,\n    ...DiscriminatedUnionSchemaVariant<Discriminator>[],\n  ]\n\nexport type DiscriminatedUnionSchemaOutput<\n  Options extends readonly Validator[],\n> = Options extends readonly [Validator<infer V>]\n  ? V\n  : Options extends readonly [\n        Validator<infer V>,\n        ...infer Rest extends Validator[],\n      ]\n    ? V | DiscriminatedUnionSchemaOutput<Rest>\n    : never\n\n/**\n * @note There is no discriminated union in Lexicon schemas. This is a custom\n * extension to allow optimized validation of union of objects when using the\n * lex library programmatically (i.e. not code generated from a lexicon schema).\n */\nexport class DiscriminatedUnionSchema<\n  const Discriminator extends string = any,\n  const Options extends DiscriminatedUnionSchemaVariants<Discriminator> = any,\n> extends Validator<DiscriminatedUnionSchemaOutput<Options>> {\n  constructor(\n    readonly discriminator: Discriminator,\n    readonly variants: Options,\n  ) {\n    super()\n  }\n\n  /**\n   * If all variants have a literal or enum for the discriminator property,\n   * and there are no overlapping values, returns a map of discriminator values\n   * to variants. Otherwise, returns null.\n   */\n  protected get variantsMap() {\n    const map = new Map<\n      unknown,\n      DiscriminatedUnionSchemaVariant<Discriminator>\n    >()\n    for (const variant of this.variants) {\n      const schema = variant.validators[this.discriminator]\n      if (schema instanceof LiteralSchema) {\n        if (map.has(schema.value)) return null // overlapping value\n        map.set(schema.value, variant)\n      } else if (schema instanceof EnumSchema) {\n        for (const val of schema.values) {\n          if (map.has(val)) return null // overlapping value\n          map.set(val, variant)\n        }\n      } else {\n        return null // not a literal or enum\n      }\n    }\n\n    // Cache the map on the instance (to avoid re-computing)\n    Object.defineProperty(this, 'variantsMap', {\n      value: map,\n      writable: false,\n      enumerable: false,\n      configurable: true,\n    })\n\n    return map\n  }\n\n  override validateInContext(\n    input: unknown,\n    ctx: ValidatorContext,\n  ): ValidationResult<DiscriminatedUnionSchemaOutput<Options>> {\n    if (!isPlainObject(input)) {\n      return ctx.issueInvalidType(input, 'object')\n    }\n\n    if (!Object.hasOwn(input, this.discriminator)) {\n      return ctx.issueRequiredKey(input, this.discriminator)\n    }\n\n    // Fast path: if we have a mapping of discriminator values to variants,\n    // we can directly select the correct variant to validate against. This also\n    // outputs a better error (with a single failure issue) when the discriminator.\n    if (this.variantsMap) {\n      const variant = this.variantsMap.get(input[this.discriminator])\n      if (!variant) {\n        return ctx.issueInvalidPropertyValue(input, this.discriminator, [\n          ...this.variantsMap.keys(),\n        ])\n      }\n\n      return ctx.validate(input, variant) as ValidationResult<\n        DiscriminatedUnionSchemaOutput<Options>\n      >\n    }\n\n    // Slow path: try validating against each variant and return the first\n    // successful one (or aggregate all failures if none match).\n    const failures: ValidationFailure[] = []\n\n    for (const variant of this.variants) {\n      const discSchema = variant.validators[this.discriminator]\n      const discResult = ctx.validateChild(\n        input,\n        this.discriminator,\n        discSchema,\n      )\n\n      if (!discResult.success) {\n        failures.push(discResult)\n        continue\n      }\n\n      return ctx.validate(input, variant) as ValidationResult<\n        DiscriminatedUnionSchemaOutput<Options>\n      >\n    }\n\n    return {\n      success: false,\n      error: ValidationError.fromFailures(failures),\n    }\n  }\n}\n"]}

package/dist/schema/enum.d.ts

@@ -0,0 +1,7 @@
+import { ValidationResult, Validator, ValidatorContext } from '../validation.js';
+export declare class EnumSchema<Output extends null | string | number | boolean = any> extends Validator<Output> {
+    readonly values: readonly Output[];
+    constructor(values: readonly Output[]);
+    validateInContext(input: unknown, ctx: ValidatorContext): ValidationResult<Output>;
+}
+//# sourceMappingURL=enum.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"enum.d.ts","sourceRoot":"","sources":["../../src/schema/enum.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AAEhF,qBAAa,UAAU,CACrB,MAAM,SAAS,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,GAAG,CACrD,SAAQ,SAAS,CAAC,MAAM,CAAC;IACb,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE;gBAAzB,MAAM,EAAE,SAAS,MAAM,EAAE;IAIrC,iBAAiB,CACxB,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,gBAAgB,GACpB,gBAAgB,CAAC,MAAM,CAAC;CAO5B"}

package/dist/schema/enum.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnumSchema = void 0;
+const validation_js_1 = require("../validation.js");
+class EnumSchema extends validation_js_1.Validator {
+    values;
+    constructor(values) {
+        super();
+        this.values = values;
+    }
+    validateInContext(input, ctx) {
+        if (!this.values.includes(input)) {
+            return ctx.issueInvalidValue(input, this.values);
+        }
+        return ctx.success(input);
+    }
+}
+exports.EnumSchema = EnumSchema;
+//# sourceMappingURL=enum.js.map

package/dist/schema/enum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum.js","sourceRoot":"","sources":["../../src/schema/enum.ts"],"names":[],"mappings":";;;AAAA,oDAAgF;AAEhF,MAAa,UAEX,SAAQ,yBAAiB;IACJ;IAArB,YAAqB,MAAyB;QAC5C,KAAK,EAAE,CAAA;QADY,WAAM,GAAN,MAAM,CAAmB;IAE9C,CAAC;IAEQ,iBAAiB,CACxB,KAAc,EACd,GAAqB;QAErB,IAAI,CAAE,IAAI,CAAC,MAA6B,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;YACzD,OAAO,GAAG,CAAC,iBAAiB,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,CAAA;QAClD,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,KAAe,CAAC,CAAA;IACrC,CAAC;CACF;AAjBD,gCAiBC","sourcesContent":["import { ValidationResult, Validator, ValidatorContext } from '../validation.js'\n\nexport class EnumSchema<\n  Output extends null | string | number | boolean = any,\n> extends Validator<Output> {\n  constructor(readonly values: readonly Output[]) {\n    super()\n  }\n\n  override validateInContext(\n    input: unknown,\n    ctx: ValidatorContext,\n  ): ValidationResult<Output> {\n    if (!(this.values as readonly unknown[]).includes(input)) {\n      return ctx.issueInvalidValue(input, this.values)\n    }\n\n    return ctx.success(input as Output)\n  }\n}\n"]}

package/dist/schema/integer.d.ts

@@ -0,0 +1,13 @@
+import { ValidationResult, Validator, ValidatorContext } from '../validation.js';
+export type IntegerSchemaOptions = {
+    default?: number;
+    minimum?: number;
+    maximum?: number;
+};
+export declare class IntegerSchema extends Validator<number> {
+    readonly options: IntegerSchemaOptions;
+    readonly lexiconType: "integer";
+    constructor(options: IntegerSchemaOptions);
+    validateInContext(input: unknown | undefined, ctx: ValidatorContext): ValidationResult<number>;
+}
+//# sourceMappingURL=integer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"integer.d.ts","sourceRoot":"","sources":["../../src/schema/integer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AAEhF,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,qBAAa,aAAc,SAAQ,SAAS,CAAC,MAAM,CAAC;IAGtC,QAAQ,CAAC,OAAO,EAAE,oBAAoB;IAFlD,QAAQ,CAAC,WAAW,EAAG,SAAS,CAAS;gBAEpB,OAAO,EAAE,oBAAoB;IAIzC,iBAAiB,CACxB,KAAK,EAAE,OAAO,YAAuB,EACrC,GAAG,EAAE,gBAAgB,GACpB,gBAAgB,CAAC,MAAM,CAAC;CAe5B"}

package/dist/schema/integer.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegerSchema = void 0;
+const validation_js_1 = require("../validation.js");
+class IntegerSchema extends validation_js_1.Validator {
+    options;
+    lexiconType = 'integer';
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    validateInContext(input = this.options.default, ctx) {
+        if (!isInteger(input)) {
+            return ctx.issueInvalidType(input, 'integer');
+        }
+        if (this.options.minimum !== undefined && input < this.options.minimum) {
+            return ctx.issueTooSmall(input, 'integer', this.options.minimum, input);
+        }
+        if (this.options.maximum !== undefined && input > this.options.maximum) {
+            return ctx.issueTooBig(input, 'integer', this.options.maximum, input);
+        }
+        return ctx.success(input);
+    }
+}
+exports.IntegerSchema = IntegerSchema;
+/**
+ * Simple wrapper around {@link Number.isInteger} that acts as a type guard.
+ */
+function isInteger(input) {
+    return Number.isInteger(input);
+}
+//# sourceMappingURL=integer.js.map

package/dist/schema/integer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"integer.js","sourceRoot":"","sources":["../../src/schema/integer.ts"],"names":[],"mappings":";;;AAAA,oDAAgF;AAQhF,MAAa,aAAc,SAAQ,yBAAiB;IAG7B;IAFZ,WAAW,GAAG,SAAkB,CAAA;IAEzC,YAAqB,OAA6B;QAChD,KAAK,EAAE,CAAA;QADY,YAAO,GAAP,OAAO,CAAsB;IAElD,CAAC;IAEQ,iBAAiB,CACxB,QAAiB,IAAI,CAAC,OAAO,CAAC,OAAO,EACrC,GAAqB;QAErB,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,CAAC,OAAO,KAAK,SAAS,IAAI,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;YACvE,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,CAAC,OAAO,KAAK,SAAS,IAAI,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;YACvE,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;AAzBD,sCAyBC;AAED;;GAEG;AACH,SAAS,SAAS,CAAC,KAAc;IAC/B,OAAO,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,CAAA;AAChC,CAAC","sourcesContent":["import { ValidationResult, Validator, ValidatorContext } from '../validation.js'\n\nexport type IntegerSchemaOptions = {\n  default?: number\n  minimum?: number\n  maximum?: number\n}\n\nexport class IntegerSchema extends Validator<number> {\n  readonly lexiconType = 'integer' as const\n\n  constructor(readonly options: IntegerSchemaOptions) {\n    super()\n  }\n\n  override validateInContext(\n    input: unknown = this.options.default,\n    ctx: ValidatorContext,\n  ): ValidationResult<number> {\n    if (!isInteger(input)) {\n      return ctx.issueInvalidType(input, 'integer')\n    }\n\n    if (this.options.minimum !== undefined && input < this.options.minimum) {\n      return ctx.issueTooSmall(input, 'integer', this.options.minimum, input)\n    }\n\n    if (this.options.maximum !== undefined && 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.isInteger} that acts as a type guard.\n */\nfunction isInteger(input: unknown): input is number {\n  return Number.isInteger(input)\n}\n"]}

package/dist/schema/intersection.d.ts

@@ -0,0 +1,16 @@
+import { Infer, ValidationResult, Validator, ValidatorContext } from '../validation.js';
+export type IntersectionSchemaValidators = readonly [
+    Validator,
+    Validator,
+    ...Validator[]
+];
+export type IntersectionSchemaOutput<V extends readonly Validator[], Base = unknown> = V extends readonly [
+    infer First extends Validator,
+    ...infer Rest extends Validator[]
+] ? IntersectionSchemaOutput<Rest, Base & Infer<First>> : Base;
+export declare class IntersectionSchema<V extends IntersectionSchemaValidators = any> extends Validator<IntersectionSchemaOutput<V>> {
+    protected readonly validators: V;
+    constructor(validators: V);
+    validateInContext(input: unknown, ctx: ValidatorContext): ValidationResult<IntersectionSchemaOutput<V>>;
+}
+//# sourceMappingURL=intersection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"intersection.d.ts","sourceRoot":"","sources":["../../src/schema/intersection.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EACL,gBAAgB,EAChB,SAAS,EACT,gBAAgB,EACjB,MAAM,kBAAkB,CAAA;AAEzB,MAAM,MAAM,4BAA4B,GAAG,SAAS;IAClD,SAAS;IACT,SAAS;IACT,GAAG,SAAS,EAAE;CACf,CAAA;AACD,MAAM,MAAM,wBAAwB,CAClC,CAAC,SAAS,SAAS,SAAS,EAAE,EAC9B,IAAI,GAAG,OAAO,IACZ,CAAC,SAAS,SAAS;IACrB,MAAM,KAAK,SAAS,SAAS;IAC7B,GAAG,MAAM,IAAI,SAAS,SAAS,EAAE;CAClC,GACG,wBAAwB,CAAC,IAAI,EAAE,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,GACnD,IAAI,CAAA;AAER,qBAAa,kBAAkB,CAC7B,CAAC,SAAS,4BAA4B,GAAG,GAAG,CAC5C,SAAQ,SAAS,CAAC,wBAAwB,CAAC,CAAC,CAAC,CAAC;IAClC,SAAS,CAAC,QAAQ,CAAC,UAAU,EAAE,CAAC;gBAAb,UAAU,EAAE,CAAC;IAInC,iBAAiB,CACxB,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,gBAAgB,GACpB,gBAAgB,CAAC,wBAAwB,CAAC,CAAC,CAAC,CAAC;CAwBjD"}

package/dist/schema/intersection.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntersectionSchema = void 0;
+const validation_js_1 = require("../validation.js");
+class IntersectionSchema extends validation_js_1.Validator {
+    validators;
+    constructor(validators) {
+        super();
+        this.validators = validators;
+    }
+    validateInContext(input, ctx) {
+        for (let i = 0; i < this.validators.length; i++) {
+            const result = ctx.validate(input, this.validators[i]);
+            if (!result.success) {
+                return result;
+            }
+            // @NOTE because transforming the value could make it invalid for previous
+            // validators, we need to ensure the input remains unchanged only gets
+            // transformed by the first validator.
+            if (i !== 0 && input !== result.value) {
+                // The alternative would be to allow transforms on a first pass
+                // (ignoring errors) and then re-validate the final value against all
+                // validators (without allowing further transforms). This would be way
+                // less efficient (we could make this optional).
+                return ctx.issueInvalidValue(input, [result.value]);
+            }
+            input = result.value;
+        }
+        return ctx.success(input);
+    }
+}
+exports.IntersectionSchema = IntersectionSchema;
+//# sourceMappingURL=intersection.js.map

package/dist/schema/intersection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"intersection.js","sourceRoot":"","sources":["../../src/schema/intersection.ts"],"names":[],"mappings":";;;AAAA,oDAKyB;AAiBzB,MAAa,kBAEX,SAAQ,yBAAsC;IACf;IAA/B,YAA+B,UAAa;QAC1C,KAAK,EAAE,CAAA;QADsB,eAAU,GAAV,UAAU,CAAG;IAE5C,CAAC;IAEQ,iBAAiB,CACxB,KAAc,EACd,GAAqB;QAErB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAChD,MAAM,MAAM,GAAG,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAA;YAEtD,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;gBACpB,OAAO,MAAM,CAAA;YACf,CAAC;YAED,0EAA0E;YAC1E,sEAAsE;YACtE,sCAAsC;YACtC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,KAAK,MAAM,CAAC,KAAK,EAAE,CAAC;gBACtC,+DAA+D;gBAC/D,qEAAqE;gBACrE,sEAAsE;gBACtE,gDAAgD;gBAChD,OAAO,GAAG,CAAC,iBAAiB,CAAC,KAAK,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA;YACrD,CAAC;YAED,KAAK,GAAG,MAAM,CAAC,KAAK,CAAA;QACtB,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,KAAoC,CAAC,CAAA;IAC1D,CAAC;CACF;AAlCD,gDAkCC","sourcesContent":["import {\n  Infer,\n  ValidationResult,\n  Validator,\n  ValidatorContext,\n} from '../validation.js'\n\nexport type IntersectionSchemaValidators = readonly [\n  Validator,\n  Validator,\n  ...Validator[],\n]\nexport type IntersectionSchemaOutput<\n  V extends readonly Validator[],\n  Base = unknown,\n> = V extends readonly [\n  infer First extends Validator,\n  ...infer Rest extends Validator[],\n]\n  ? IntersectionSchemaOutput<Rest, Base & Infer<First>>\n  : Base\n\nexport class IntersectionSchema<\n  V extends IntersectionSchemaValidators = any,\n> extends Validator<IntersectionSchemaOutput<V>> {\n  constructor(protected readonly validators: V) {\n    super()\n  }\n\n  override validateInContext(\n    input: unknown,\n    ctx: ValidatorContext,\n  ): ValidationResult<IntersectionSchemaOutput<V>> {\n    for (let i = 0; i < this.validators.length; i++) {\n      const result = ctx.validate(input, this.validators[i])\n\n      if (!result.success) {\n        return result\n      }\n\n      // @NOTE because transforming the value could make it invalid for previous\n      // validators, we need to ensure the input remains unchanged only gets\n      // transformed by the first validator.\n      if (i !== 0 && input !== result.value) {\n        // The alternative would be to allow transforms on a first pass\n        // (ignoring errors) and then re-validate the final value against all\n        // validators (without allowing further transforms). This would be way\n        // less efficient (we could make this optional).\n        return ctx.issueInvalidValue(input, [result.value])\n      }\n\n      input = result.value\n    }\n\n    return ctx.success(input as IntersectionSchemaOutput<V>)\n  }\n}\n"]}

package/dist/schema/literal.d.ts

@@ -0,0 +1,7 @@
+import { ValidationResult, Validator, ValidatorContext } from '../validation.js';
+export declare class LiteralSchema<Output extends null | string | number | boolean = any> extends Validator<Output> {
+    readonly value: Output;
+    constructor(value: Output);
+    validateInContext(input: unknown, ctx: ValidatorContext): ValidationResult<Output>;
+}
+//# sourceMappingURL=literal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"literal.d.ts","sourceRoot":"","sources":["../../src/schema/literal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AAEhF,qBAAa,aAAa,CACxB,MAAM,SAAS,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,GAAG,CACrD,SAAQ,SAAS,CAAC,MAAM,CAAC;IACb,QAAQ,CAAC,KAAK,EAAE,MAAM;gBAAb,KAAK,EAAE,MAAM;IAIzB,iBAAiB,CACxB,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,gBAAgB,GACpB,gBAAgB,CAAC,MAAM,CAAC;CAO5B"}

package/dist/schema/literal.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiteralSchema = void 0;
+const validation_js_1 = require("../validation.js");
+class LiteralSchema extends validation_js_1.Validator {
+    value;
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    validateInContext(input, ctx) {
+        if (input !== this.value) {
+            return ctx.issueInvalidValue(input, [this.value]);
+        }
+        return ctx.success(this.value);
+    }
+}
+exports.LiteralSchema = LiteralSchema;
+//# sourceMappingURL=literal.js.map

package/dist/schema/literal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"literal.js","sourceRoot":"","sources":["../../src/schema/literal.ts"],"names":[],"mappings":";;;AAAA,oDAAgF;AAEhF,MAAa,aAEX,SAAQ,yBAAiB;IACJ;IAArB,YAAqB,KAAa;QAChC,KAAK,EAAE,CAAA;QADY,UAAK,GAAL,KAAK,CAAQ;IAElC,CAAC;IAEQ,iBAAiB,CACxB,KAAc,EACd,GAAqB;QAErB,IAAI,KAAK,KAAK,IAAI,CAAC,KAAK,EAAE,CAAC;YACzB,OAAO,GAAG,CAAC,iBAAiB,CAAC,KAAK,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAA;QACnD,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;IAChC,CAAC;CACF;AAjBD,sCAiBC","sourcesContent":["import { ValidationResult, Validator, ValidatorContext } from '../validation.js'\n\nexport class LiteralSchema<\n  Output extends null | string | number | boolean = any,\n> extends Validator<Output> {\n  constructor(readonly value: Output) {\n    super()\n  }\n\n  override validateInContext(\n    input: unknown,\n    ctx: ValidatorContext,\n  ): ValidationResult<Output> {\n    if (input !== this.value) {\n      return ctx.issueInvalidValue(input, [this.value])\n    }\n\n    return ctx.success(this.value)\n  }\n}\n"]}

package/dist/schema/never.d.ts

@@ -0,0 +1,5 @@
+import { ValidationFailure, Validator, ValidatorContext } from '../validation.js';
+export declare class NeverSchema extends Validator<never> {
+    validateInContext(input: unknown, ctx: ValidatorContext): ValidationFailure;
+}
+//# sourceMappingURL=never.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"never.d.ts","sourceRoot":"","sources":["../../src/schema/never.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,SAAS,EACT,gBAAgB,EACjB,MAAM,kBAAkB,CAAA;AAEzB,qBAAa,WAAY,SAAQ,SAAS,CAAC,KAAK,CAAC;IACtC,iBAAiB,CACxB,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,gBAAgB,GACpB,iBAAiB;CAGrB"}

package/dist/schema/never.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NeverSchema = void 0;
+const validation_js_1 = require("../validation.js");
+class NeverSchema extends validation_js_1.Validator {
+    validateInContext(input, ctx) {
+        return ctx.issueInvalidType(input, 'never');
+    }
+}
+exports.NeverSchema = NeverSchema;
+//# sourceMappingURL=never.js.map

package/dist/schema/never.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"never.js","sourceRoot":"","sources":["../../src/schema/never.ts"],"names":[],"mappings":";;;AAAA,oDAIyB;AAEzB,MAAa,WAAY,SAAQ,yBAAgB;IACtC,iBAAiB,CACxB,KAAc,EACd,GAAqB;QAErB,OAAO,GAAG,CAAC,gBAAgB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAA;IAC7C,CAAC;CACF;AAPD,kCAOC","sourcesContent":["import {\n  ValidationFailure,\n  Validator,\n  ValidatorContext,\n} from '../validation.js'\n\nexport class NeverSchema extends Validator<never> {\n  override validateInContext(\n    input: unknown,\n    ctx: ValidatorContext,\n  ): ValidationFailure {\n    return ctx.issueInvalidType(input, 'never')\n  }\n}\n"]}

package/dist/schema/null.d.ts

@@ -0,0 +1,7 @@
+import { ValidationResult, Validator, ValidatorContext } from '../validation.js';
+export declare class NullSchema extends Validator<null> {
+    readonly lexiconType: "null";
+    constructor();
+    validateInContext(input: unknown, ctx: ValidatorContext): ValidationResult<null>;
+}
+//# sourceMappingURL=null.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"null.d.ts","sourceRoot":"","sources":["../../src/schema/null.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AAEhF,qBAAa,UAAW,SAAQ,SAAS,CAAC,IAAI,CAAC;IAC7C,QAAQ,CAAC,WAAW,EAAG,MAAM,CAAS;;IAM7B,iBAAiB,CACxB,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,gBAAgB,GACpB,gBAAgB,CAAC,IAAI,CAAC;CAO1B"}

package/dist/schema/null.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullSchema = void 0;
+const validation_js_1 = require("../validation.js");
+class NullSchema extends validation_js_1.Validator {
+    lexiconType = 'null';
+    constructor() {
+        super();
+    }
+    validateInContext(input, ctx) {
+        if (input !== null) {
+            return ctx.issueInvalidType(input, 'null');
+        }
+        return ctx.success(null);
+    }
+}
+exports.NullSchema = NullSchema;
+//# sourceMappingURL=null.js.map

package/dist/schema/null.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"null.js","sourceRoot":"","sources":["../../src/schema/null.ts"],"names":[],"mappings":";;;AAAA,oDAAgF;AAEhF,MAAa,UAAW,SAAQ,yBAAe;IACpC,WAAW,GAAG,MAAe,CAAA;IAEtC;QACE,KAAK,EAAE,CAAA;IACT,CAAC;IAEQ,iBAAiB,CACxB,KAAc,EACd,GAAqB;QAErB,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YACnB,OAAO,GAAG,CAAC,gBAAgB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;QAC5C,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;IAC1B,CAAC;CACF;AAjBD,gCAiBC","sourcesContent":["import { ValidationResult, Validator, ValidatorContext } from '../validation.js'\n\nexport class NullSchema extends Validator<null> {\n  readonly lexiconType = 'null' as const\n\n  constructor() {\n    super()\n  }\n\n  override validateInContext(\n    input: unknown,\n    ctx: ValidatorContext,\n  ): ValidationResult<null> {\n    if (input !== null) {\n      return ctx.issueInvalidType(input, 'null')\n    }\n\n    return ctx.success(null)\n  }\n}\n"]}

package/dist/schema/object.d.ts

@@ -0,0 +1,47 @@
+import { Simplify } from '../core.js';
+import { Infer, ValidationResult, Validator, ValidatorContext } from '../validation.js';
+import { DictSchema } from './dict.js';
+export type ObjectSchemaProperties = {
+    [_ in string]: Validator<any>;
+};
+export type ObjectSchemaOptions = {
+    required?: readonly string[];
+    nullable?: readonly string[];
+    unknownProperties?: 'strict' | DictSchema;
+};
+export type ObjectSchemaNullValue<O extends ObjectSchemaOptions, K extends string> = O extends {
+    nullable: readonly (infer N extends string)[];
+} ? K extends N ? null : never : never;
+export type ObjectSchemaPropertiesOutput<P extends ObjectSchemaProperties, O extends ObjectSchemaOptions> = O extends {
+    required: readonly (infer R extends string)[];
+} ? {
+    -readonly [K in string & keyof P & R]-?: Infer<P[K]> | ObjectSchemaNullValue<O, K>;
+} & {
+    -readonly [K in Exclude<string & keyof P, R>]?: Infer<P[K]> | ObjectSchemaNullValue<O, K>;
+} : {
+    -readonly [K in string & keyof P]?: Infer<P[K]> | ObjectSchemaNullValue<O, K>;
+};
+/**
+ * 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.
+ *
+ * @see {@link https://www.typescriptlang.org/play/?#code/C4TwDgpgBAglC8UDeUBmB7dAuKByARgIYBOuUAvlAGTJQDaA+lAJYB2UAzsMWwOYC6OVgFcAtvgjEKAKGkATCAGMANiWiL0rLlEI4YsjVuBQA1hBA4uPVrwRQARBnT2Dm7QDdCy4dESE6ZiD8UAD0IVAi4pJQABQcABbowspyUBIORMT2AJSyEAAeYOjExqCQUACSrMCSHErAzJoAPNJQsFAFNaxyHFAASkrFck1WfAA0UMKsJqzoAO6sAHxjrVAAQh35XT39g8TDozYTUzPzSyuLdqtwVKttMYHoqO00j88bnRDdvawQ7pJ3NpQAD860BbRwSHBQLadAA0ix2G91oJ1vDggAfWABcxPF5QOH8aFtci5aRlaAwVDMfIQVKIKo1Yh1RQNZq0Jw4AgkMjkCYoRiIzjcPioyISKTkRayBQqNRQQzaQgAMRpdL01NpclcRignm8EFVWrsKrVchxQVC4XF0SxmSAA Playground link}
+ */
+type Intersect<A extends Record<string, unknown>, B extends Record<string, unknown>> = B[keyof B] extends never ? A : keyof A & keyof B extends never ? // If A and B don't overlap, just return A & B
+A & B : // Otherwise, properly represent the fact that accessing using an
+A & {
+    [K in keyof B]: B[K] | A[keyof A & K];
+};
+export type ObjectSchemaOutput<P extends ObjectSchemaProperties, O extends ObjectSchemaOptions> = O extends {
+    unknownProperties: Validator<infer D extends Record<string, unknown>>;
+} ? Simplify<Intersect<ObjectSchemaPropertiesOutput<P, O>, D>> : Simplify<ObjectSchemaPropertiesOutput<P, O>>;
+export declare class ObjectSchema<const Validators extends ObjectSchemaProperties = any, const Options extends ObjectSchemaOptions = any, const Output extends ObjectSchemaOutput<Validators, Options> = ObjectSchemaOutput<Validators, Options>> extends Validator<Output> {
+    readonly validators: Validators;
+    readonly options: Options;
+    constructor(validators: Validators, options: Options);
+    get validatorsMap(): Map<string, Validator>;
+    validateInContext(input: unknown, ctx: ValidatorContext): ValidationResult<Output>;
+}
+export {};
+//# sourceMappingURL=object.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../../src/schema/object.ts"],"names":[],"mappings":"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"}