@atproto/lex-schema 0.0.9 → 0.0.10

package/dist/schema/bytes.js.map

@@ -1 +1 @@
-{"version":3,"file":"bytes.js","sourceRoot":"","sources":["../../src/schema/bytes.ts"],"names":[],"mappings":";;;AAAA,gDAAgD;AAChD,wCAAuE;AAOvE,MAAa,WAAY,SAAQ,gBAAkB;IAC5B;IAArB,YAAqB,UAA8B,EAAE;QACnD,KAAK,EAAE,CAAA;QADY,YAAO,GAAP,OAAO,CAAyB;IAErD,CAAC;IAED,iBAAiB,CACf,KAAc,EACd,GAAqB;QAErB,kDAAkD;QAClD,MAAM,KAAK,GAAG,IAAA,uBAAY,EAAC,KAAK,CAAC,CAAA;QACjC,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO,GAAG,CAAC,gBAAgB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAA;QAC7C,CAAC;QAED,MAAM,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC,OAAO,CAAA;QAClC,IAAI,SAAS,IAAI,IAAI,IAAI,KAAK,CAAC,MAAM,GAAG,SAAS,EAAE,CAAC;YAClD,OAAO,GAAG,CAAC,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;QACnE,CAAC;QAED,MAAM,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC,OAAO,CAAA;QAClC,IAAI,SAAS,IAAI,IAAI,IAAI,KAAK,CAAC,MAAM,GAAG,SAAS,EAAE,CAAC;YAClD,OAAO,GAAG,CAAC,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;QACjE,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IAC3B,CAAC;CACF;AA3BD,kCA2BC","sourcesContent":["import { asUint8Array } from '@atproto/lex-data'\nimport { Schema, ValidationResult, ValidatorContext } from '../core.js'\n\nexport type BytesSchemaOptions = {\n  minLength?: number\n  maxLength?: number\n}\n\nexport class BytesSchema extends Schema<Uint8Array> {\n  constructor(readonly options: BytesSchemaOptions = {}) {\n    super()\n  }\n\n  validateInContext(\n    input: unknown,\n    ctx: ValidatorContext,\n  ): ValidationResult<Uint8Array> {\n    // Coerce different binary formats into Uint8Array\n    const bytes = asUint8Array(input)\n    if (!bytes) {\n      return ctx.issueInvalidType(input, 'bytes')\n    }\n\n    const { minLength } = this.options\n    if (minLength != null && bytes.length < minLength) {\n      return ctx.issueTooSmall(bytes, 'bytes', minLength, bytes.length)\n    }\n\n    const { maxLength } = this.options\n    if (maxLength != null && bytes.length > maxLength) {\n      return ctx.issueTooBig(bytes, 'bytes', maxLength, bytes.length)\n    }\n\n    return ctx.success(bytes)\n  }\n}\n"]}
+{"version":3,"file":"bytes.js","sourceRoot":"","sources":["../../src/schema/bytes.ts"],"names":[],"mappings":";;;AAAA,gDAA8D;AAC9D,wCAAsD;AACtD,mDAAoD;AAOpD,MAAa,WAAY,SAAQ,gBAAkB;IAC5B;IAArB,YAAqB,UAA8B,EAAE;QACnD,KAAK,EAAE,CAAA;QADY,YAAO,GAAP,OAAO,CAAyB;IAErD,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,mEAAmE;QACnE,MAAM,KAAK,GACT,GAAG,CAAC,OAAO,CAAC,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,IAAA,uBAAY,EAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAA,uBAAY,EAAC,KAAK,CAAC,CAAA;QAC1E,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO,GAAG,CAAC,gBAAgB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAA;QAC7C,CAAC;QAED,MAAM,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC,OAAO,CAAA;QAClC,IAAI,SAAS,IAAI,IAAI,IAAI,KAAK,CAAC,MAAM,GAAG,SAAS,EAAE,CAAC;YAClD,OAAO,GAAG,CAAC,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;QACnE,CAAC;QAED,MAAM,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC,OAAO,CAAA;QAClC,IAAI,SAAS,IAAI,IAAI,IAAI,KAAK,CAAC,MAAM,GAAG,SAAS,EAAE,CAAC;YAClD,OAAO,GAAG,CAAC,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;QACjE,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IAC3B,CAAC;CACF;AAzBD,kCAyBC;AAEY,QAAA,KAAK,GAAiB,IAAA,4BAAe,EAAC,UACjD,OAA4B;IAE5B,OAAO,IAAI,WAAW,CAAC,OAAO,CAAC,CAAA;AACjC,CAAC,CAAC,CAAA","sourcesContent":["import { asUint8Array, ifUint8Array } from '@atproto/lex-data'\nimport { Schema, ValidationContext } from '../core.js'\nimport { memoizedOptions } from '../util/memoize.js'\n\nexport type BytesSchemaOptions = {\n  minLength?: number\n  maxLength?: number\n}\n\nexport class BytesSchema extends Schema<Uint8Array> {\n  constructor(readonly options: BytesSchemaOptions = {}) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    // In \"parse\" mode, coerce different binary formats into Uint8Array\n    const bytes =\n      ctx.options.mode === 'parse' ? asUint8Array(input) : ifUint8Array(input)\n    if (!bytes) {\n      return ctx.issueInvalidType(input, 'bytes')\n    }\n\n    const { minLength } = this.options\n    if (minLength != null && bytes.length < minLength) {\n      return ctx.issueTooSmall(bytes, 'bytes', minLength, bytes.length)\n    }\n\n    const { maxLength } = this.options\n    if (maxLength != null && bytes.length > maxLength) {\n      return ctx.issueTooBig(bytes, 'bytes', maxLength, bytes.length)\n    }\n\n    return ctx.success(bytes)\n  }\n}\n\nexport const bytes = /*#__PURE__*/ memoizedOptions(function (\n  options?: BytesSchemaOptions,\n) {\n  return new BytesSchema(options)\n})\n"]}

package/dist/schema/cid.d.ts

@@ -1,13 +1,13 @@
 import { CheckCidOptions, Cid, InferCheckedCid } from '@atproto/lex-data';
-import { Schema, ValidationResult, ValidatorContext } from '../core.js';
+import { Schema, ValidationContext } from '../core.js';
 export type { Cid };
 export type CidSchemaOptions = CheckCidOptions;
-export type CidSchemaOutput<TOptions extends CidSchemaOptions = {
+export declare class CidSchema<const TOptions extends CidSchemaOptions = {
     flavor: undefined;
-}> = InferCheckedCid<TOptions>;
-export declare class CidSchema<TOptions extends CidSchemaOptions> extends Schema<CidSchemaOutput<TOptions>> {
-    readonly options: TOptions;
-    constructor(options: TOptions);
-    validateInContext(input: unknown, ctx: ValidatorContext): ValidationResult<CidSchemaOutput<TOptions>>;
+}> extends Schema<InferCheckedCid<TOptions>> {
+    readonly options?: TOptions | undefined;
+    constructor(options?: TOptions | undefined);
+    validateInContext(input: unknown, ctx: ValidationContext): import("../core.js").ValidationResult<Cid<0 | 1, number, number>>;
 }
+export declare const cid: <O extends CidSchemaOptions = {}>(options?: O) => CidSchema<O>;
 //# sourceMappingURL=cid.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"cid.d.ts","sourceRoot":"","sources":["../../src/schema/cid.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,GAAG,EAAE,eAAe,EAAS,MAAM,mBAAmB,CAAA;AAChF,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAEvE,YAAY,EAAE,GAAG,EAAE,CAAA;AAEnB,MAAM,MAAM,gBAAgB,GAAG,eAAe,CAAA;AAC9C,MAAM,MAAM,eAAe,CACzB,QAAQ,SAAS,gBAAgB,GAAG;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,IACvD,eAAe,CAAC,QAAQ,CAAC,CAAA;AAE7B,qBAAa,SAAS,CAAC,QAAQ,SAAS,gBAAgB,CAAE,SAAQ,MAAM,CACtE,eAAe,CAAC,QAAQ,CAAC,CAC1B;IACa,QAAQ,CAAC,OAAO,EAAE,QAAQ;gBAAjB,OAAO,EAAE,QAAQ;IAItC,iBAAiB,CACf,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,gBAAgB,GACpB,gBAAgB,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;CAO/C"}
+{"version":3,"file":"cid.d.ts","sourceRoot":"","sources":["../../src/schema/cid.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,GAAG,EAAE,eAAe,EAAS,MAAM,mBAAmB,CAAA;AAChF,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAGtD,YAAY,EAAE,GAAG,EAAE,CAAA;AAEnB,MAAM,MAAM,gBAAgB,GAAG,eAAe,CAAA;AAE9C,qBAAa,SAAS,CACpB,KAAK,CAAC,QAAQ,SAAS,gBAAgB,GAAG;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,CAC/D,SAAQ,MAAM,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;IAC7B,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ;gBAAlB,OAAO,CAAC,EAAE,QAAQ,YAAA;IAIvC,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;CAOzD;AAED,eAAO,MAAM,GAAG,GACd,CAAC,SAAS,gBAAgB,iBAChB,CAAC,iBAEX,CAAA"}

package/dist/schema/cid.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CidSchema = void 0;
+exports.cid = exports.CidSchema = 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");
 class CidSchema extends core_js_1.Schema {
     options;
     constructor(options) {
@@ -17,4 +18,7 @@ class CidSchema extends core_js_1.Schema {
     }
 }
 exports.CidSchema = CidSchema;
+exports.cid = (0, memoize_js_1.memoizedOptions)(function (options) {
+    return new CidSchema(options);
+});
 //# sourceMappingURL=cid.js.map

package/dist/schema/cid.js.map

@@ -1 +1 @@
-{"version":3,"file":"cid.js","sourceRoot":"","sources":["../../src/schema/cid.ts"],"names":[],"mappings":";;;AAAA,gDAAgF;AAChF,wCAAuE;AASvE,MAAa,SAA6C,SAAQ,gBAEjE;IACsB;IAArB,YAAqB,OAAiB;QACpC,KAAK,EAAE,CAAA;QADY,YAAO,GAAP,OAAO,CAAU;IAEtC,CAAC;IAED,iBAAiB,CACf,KAAc,EACd,GAAqB;QAErB,IAAI,CAAC,IAAA,gBAAK,EAAC,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;YAChC,OAAO,GAAG,CAAC,gBAAgB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAA;QAC3C,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IAC3B,CAAC;CACF;AAjBD,8BAiBC","sourcesContent":["import { CheckCidOptions, Cid, InferCheckedCid, isCid } from '@atproto/lex-data'\nimport { Schema, ValidationResult, ValidatorContext } from '../core.js'\n\nexport type { Cid }\n\nexport type CidSchemaOptions = CheckCidOptions\nexport type CidSchemaOutput<\n  TOptions extends CidSchemaOptions = { flavor: undefined },\n> = InferCheckedCid<TOptions>\n\nexport class CidSchema<TOptions extends CidSchemaOptions> extends Schema<\n  CidSchemaOutput<TOptions>\n> {\n  constructor(readonly options: TOptions) {\n    super()\n  }\n\n  validateInContext(\n    input: unknown,\n    ctx: ValidatorContext,\n  ): ValidationResult<CidSchemaOutput<TOptions>> {\n    if (!isCid(input, this.options)) {\n      return ctx.issueInvalidType(input, 'cid')\n    }\n\n    return ctx.success(input)\n  }\n}\n"]}
+{"version":3,"file":"cid.js","sourceRoot":"","sources":["../../src/schema/cid.ts"],"names":[],"mappings":";;;AAAA,gDAAgF;AAChF,wCAAsD;AACtD,mDAAoD;AAMpD,MAAa,SAEX,SAAQ,gBAAiC;IACpB;IAArB,YAAqB,OAAkB;QACrC,KAAK,EAAE,CAAA;QADY,YAAO,GAAP,OAAO,CAAW;IAEvC,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,CAAC,IAAA,gBAAK,EAAC,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;YAChC,OAAO,GAAG,CAAC,gBAAgB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAA;QAC3C,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IAC3B,CAAC;CACF;AAdD,8BAcC;AAEY,QAAA,GAAG,GAAiB,IAAA,4BAAe,EAAC,UAE/C,OAAW;IACX,OAAO,IAAI,SAAS,CAAC,OAAO,CAAC,CAAA;AAC/B,CAAC,CAAC,CAAA","sourcesContent":["import { CheckCidOptions, Cid, InferCheckedCid, isCid } from '@atproto/lex-data'\nimport { Schema, ValidationContext } from '../core.js'\nimport { memoizedOptions } from '../util/memoize.js'\n\nexport type { Cid }\n\nexport type CidSchemaOptions = CheckCidOptions\n\nexport class CidSchema<\n  const TOptions extends CidSchemaOptions = { flavor: undefined },\n> extends Schema<InferCheckedCid<TOptions>> {\n  constructor(readonly options?: TOptions) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!isCid(input, this.options)) {\n      return ctx.issueInvalidType(input, 'cid')\n    }\n\n    return ctx.success(input)\n  }\n}\n\nexport const cid = /*#__PURE__*/ memoizedOptions(function <\n  O extends CidSchemaOptions = NonNullable<unknown>,\n>(options?: O) {\n  return new CidSchema(options)\n})\n"]}

package/dist/schema/custom.d.ts

@@ -1,14 +1,15 @@
-import { Issue, PropertyKey, Schema, ValidationResult, ValidatorContext } from '../core.js';
+import { Issue, PropertyKey, Schema, ValidationContext } from '../core.js';
 export type CustomAssertionContext = {
     path: PropertyKey[];
     addIssue(issue: Issue): void;
 };
-export type CustomAssertion<T = any> = (this: null, input: unknown, ctx: CustomAssertionContext) => input is T;
-export declare class CustomSchema<T = unknown> extends Schema<T> {
+export type CustomAssertion<TValue> = (this: null, input: unknown, ctx: CustomAssertionContext) => input is TValue;
+export declare class CustomSchema<const TValue = unknown> extends Schema<TValue> {
     private readonly assertion;
     private readonly message;
     private readonly path?;
-    constructor(assertion: CustomAssertion<T>, message: string, path?: (PropertyKey | readonly PropertyKey[]) | undefined);
-    validateInContext(input: unknown, ctx: ValidatorContext): ValidationResult<T>;
+    constructor(assertion: CustomAssertion<TValue>, message: string, path?: (PropertyKey | readonly PropertyKey[]) | undefined);
+    validateInContext(input: unknown, ctx: ValidationContext): import("../core.js").ValidationResult<TValue>;
 }
+export declare function custom<TValue>(assertion: CustomAssertion<TValue>, message: string, path?: PropertyKey | readonly PropertyKey[]): CustomSchema<TValue>;
 //# sourceMappingURL=custom.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"custom.d.ts","sourceRoot":"","sources":["../../src/schema/custom.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EAEL,WAAW,EACX,MAAM,EACN,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,YAAY,CAAA;AAEnB,MAAM,MAAM,sBAAsB,GAAG;IACnC,IAAI,EAAE,WAAW,EAAE,CAAA;IACnB,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;CAC7B,CAAA;AAED,MAAM,MAAM,eAAe,CAAC,CAAC,GAAG,GAAG,IAAI,CACrC,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,sBAAsB,KACxB,KAAK,IAAI,CAAC,CAAA;AAEf,qBAAa,YAAY,CAAC,CAAC,GAAG,OAAO,CAAE,SAAQ,MAAM,CAAC,CAAC,CAAC;IAEpD,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC;gBAFL,SAAS,EAAE,eAAe,CAAC,CAAC,CAAC,EAC7B,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,GAAE,WAAW,GAAG,SAAS,WAAW,EAAE,aAAA;IAK9D,iBAAiB,CACf,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,gBAAgB,GACpB,gBAAgB,CAAC,CAAC,CAAC;CAKvB"}
+{"version":3,"file":"custom.d.ts","sourceRoot":"","sources":["../../src/schema/custom.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EAEL,WAAW,EACX,MAAM,EACN,iBAAiB,EAClB,MAAM,YAAY,CAAA;AAEnB,MAAM,MAAM,sBAAsB,GAAG;IACnC,IAAI,EAAE,WAAW,EAAE,CAAA;IACnB,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;CAC7B,CAAA;AAED,MAAM,MAAM,eAAe,CAAC,MAAM,IAAI,CACpC,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,sBAAsB,KACxB,KAAK,IAAI,MAAM,CAAA;AAEpB,qBAAa,YAAY,CAAC,KAAK,CAAC,MAAM,GAAG,OAAO,CAAE,SAAQ,MAAM,CAAC,MAAM,CAAC;IAEpE,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC;gBAFL,SAAS,EAAE,eAAe,CAAC,MAAM,CAAC,EAClC,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,GAAE,WAAW,GAAG,SAAS,WAAW,EAAE,aAAA;IAK9D,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;CAOzD;AAGD,wBAAgB,MAAM,CAAC,MAAM,EAC3B,SAAS,EAAE,eAAe,CAAC,MAAM,CAAC,EAClC,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,WAAW,EAAE,wBAG5C"}

package/dist/schema/custom.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CustomSchema = void 0;
+exports.custom = custom;
 const core_js_1 = require("../core.js");
 class CustomSchema extends core_js_1.Schema {
     assertion;
@@ -13,11 +14,16 @@ class CustomSchema extends core_js_1.Schema {
         this.path = path;
     }
     validateInContext(input, ctx) {
-        if (this.assertion.call(null, input, ctx))
-            return ctx.success(input);
-        const path = ctx.concatPath(this.path);
-        return ctx.issue(new core_js_1.IssueCustom(path, input, this.message));
+        if (!this.assertion.call(null, input, ctx)) {
+            const path = ctx.concatPath(this.path);
+            return ctx.issue(new core_js_1.IssueCustom(path, input, this.message));
+        }
+        return ctx.success(input);
     }
 }
 exports.CustomSchema = CustomSchema;
+/*@__NO_SIDE_EFFECTS__*/
+function custom(assertion, message, path) {
+    return new CustomSchema(assertion, message, path);
+}
 //# sourceMappingURL=custom.js.map

package/dist/schema/custom.js.map

@@ -1 +1 @@
-{"version":3,"file":"custom.js","sourceRoot":"","sources":["../../src/schema/custom.ts"],"names":[],"mappings":";;;AAAA,wCAOmB;AAanB,MAAa,YAA0B,SAAQ,gBAAS;IAEnC;IACA;IACA;IAHnB,YACmB,SAA6B,EAC7B,OAAe,EACf,IAA2C;QAE5D,KAAK,EAAE,CAAA;QAJU,cAAS,GAAT,SAAS,CAAoB;QAC7B,YAAO,GAAP,OAAO,CAAQ;QACf,SAAI,GAAJ,IAAI,CAAuC;IAG9D,CAAC;IAED,iBAAiB,CACf,KAAc,EACd,GAAqB;QAErB,IAAI,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,CAAC;YAAE,OAAO,GAAG,CAAC,OAAO,CAAC,KAAU,CAAC,CAAA;QACzE,MAAM,IAAI,GAAG,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QACtC,OAAO,GAAG,CAAC,KAAK,CAAC,IAAI,qBAAW,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAA;IAC9D,CAAC;CACF;AAjBD,oCAiBC","sourcesContent":["import {\n  Issue,\n  IssueCustom,\n  PropertyKey,\n  Schema,\n  ValidationResult,\n  ValidatorContext,\n} from '../core.js'\n\nexport type CustomAssertionContext = {\n  path: PropertyKey[]\n  addIssue(issue: Issue): void\n}\n\nexport type CustomAssertion<T = any> = (\n  this: null,\n  input: unknown,\n  ctx: CustomAssertionContext,\n) => input is T\n\nexport class CustomSchema<T = unknown> extends Schema<T> {\n  constructor(\n    private readonly assertion: CustomAssertion<T>,\n    private readonly message: string,\n    private readonly path?: PropertyKey | readonly PropertyKey[],\n  ) {\n    super()\n  }\n\n  validateInContext(\n    input: unknown,\n    ctx: ValidatorContext,\n  ): ValidationResult<T> {\n    if (this.assertion.call(null, input, ctx)) return ctx.success(input as T)\n    const path = ctx.concatPath(this.path)\n    return ctx.issue(new IssueCustom(path, input, this.message))\n  }\n}\n"]}
+{"version":3,"file":"custom.js","sourceRoot":"","sources":["../../src/schema/custom.ts"],"names":[],"mappings":";;;AAsCA,wBAMC;AA5CD,wCAMmB;AAanB,MAAa,YAAqC,SAAQ,gBAAc;IAEnD;IACA;IACA;IAHnB,YACmB,SAAkC,EAClC,OAAe,EACf,IAA2C;QAE5D,KAAK,EAAE,CAAA;QAJU,cAAS,GAAT,SAAS,CAAyB;QAClC,YAAO,GAAP,OAAO,CAAQ;QACf,SAAI,GAAJ,IAAI,CAAuC;IAG9D,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,CAAC,EAAE,CAAC;YAC3C,MAAM,IAAI,GAAG,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;YACtC,OAAO,GAAG,CAAC,KAAK,CAAC,IAAI,qBAAW,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAA;QAC9D,CAAC;QACD,OAAO,GAAG,CAAC,OAAO,CAAC,KAAe,CAAC,CAAA;IACrC,CAAC;CACF;AAhBD,oCAgBC;AAED,wBAAwB;AACxB,SAAgB,MAAM,CACpB,SAAkC,EAClC,OAAe,EACf,IAA2C;IAE3C,OAAO,IAAI,YAAY,CAAS,SAAS,EAAE,OAAO,EAAE,IAAI,CAAC,CAAA;AAC3D,CAAC","sourcesContent":["import {\n  Issue,\n  IssueCustom,\n  PropertyKey,\n  Schema,\n  ValidationContext,\n} from '../core.js'\n\nexport type CustomAssertionContext = {\n  path: PropertyKey[]\n  addIssue(issue: Issue): void\n}\n\nexport type CustomAssertion<TValue> = (\n  this: null,\n  input: unknown,\n  ctx: CustomAssertionContext,\n) => input is TValue\n\nexport class CustomSchema<const TValue = unknown> extends Schema<TValue> {\n  constructor(\n    private readonly assertion: CustomAssertion<TValue>,\n    private readonly message: string,\n    private readonly path?: PropertyKey | readonly PropertyKey[],\n  ) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!this.assertion.call(null, input, ctx)) {\n      const path = ctx.concatPath(this.path)\n      return ctx.issue(new IssueCustom(path, input, this.message))\n    }\n    return ctx.success(input as TValue)\n  }\n}\n\n/*@__NO_SIDE_EFFECTS__*/\nexport function custom<TValue>(\n  assertion: CustomAssertion<TValue>,\n  message: string,\n  path?: PropertyKey | readonly PropertyKey[],\n) {\n  return new CustomSchema<TValue>(assertion, message, path)\n}\n"]}

package/dist/schema/dict.d.ts

@@ -1,18 +1,18 @@
-import { Infer, Schema, ValidationResult, Validator, ValidatorContext } from '../core.js';
-export type DictSchemaOutput<KeySchema extends Validator<string>, ValueSchema extends Validator> = Record<Infer<KeySchema>, Infer<ValueSchema>>;
+import { InferInput, InferOutput, Schema, ValidationContext, Validator } from '../core.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).
  */
-export declare class DictSchema<const KeySchema extends Validator<string> = any, const ValueSchema extends Validator = any> extends Schema<DictSchemaOutput<KeySchema, ValueSchema>> {
-    readonly keySchema: KeySchema;
-    readonly valueSchema: ValueSchema;
-    constructor(keySchema: KeySchema, valueSchema: ValueSchema);
-    validateInContext(input: unknown, ctx: ValidatorContext, options?: {
+export declare class DictSchema<const TKey extends Validator<string> = any, const TValue extends Validator = any> extends Schema<Record<InferInput<TKey>, InferInput<TValue>>, Record<InferInput<TKey>, InferOutput<TValue>>> {
+    readonly keySchema: TKey;
+    readonly valueSchema: TValue;
+    constructor(keySchema: TKey, valueSchema: TValue);
+    validateInContext(input: unknown, ctx: ValidationContext, options?: {
         ignoredKeys?: {
             has(k: string): boolean;
         };
-    }): ValidationResult<DictSchemaOutput<KeySchema, ValueSchema>>;
+    }): import("../core.js").ValidationResult<Record<string, unknown>>;
 }
+export declare function dict<const TKey extends Validator<string>, const TValue extends Validator>(key: TKey, value: TValue): DictSchema<TKey, TValue>;
 //# sourceMappingURL=dict.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"dict.d.ts","sourceRoot":"","sources":["../../src/schema/dict.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,EACL,MAAM,EACN,gBAAgB,EAChB,SAAS,EACT,gBAAgB,EACjB,MAAM,YAAY,CAAA;AAEnB,MAAM,MAAM,gBAAgB,CAC1B,SAAS,SAAS,SAAS,CAAC,MAAM,CAAC,EACnC,WAAW,SAAS,SAAS,IAC3B,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC,CAAA;AAEhD;;;;GAIG;AACH,qBAAa,UAAU,CACrB,KAAK,CAAC,SAAS,SAAS,SAAS,CAAC,MAAM,CAAC,GAAG,GAAG,EAC/C,KAAK,CAAC,WAAW,SAAS,SAAS,GAAG,GAAG,CACzC,SAAQ,MAAM,CAAC,gBAAgB,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;IAEtD,QAAQ,CAAC,SAAS,EAAE,SAAS;IAC7B,QAAQ,CAAC,WAAW,EAAE,WAAW;gBADxB,SAAS,EAAE,SAAS,EACpB,WAAW,EAAE,WAAW;IAKnC,iBAAiB,CACf,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"}
+{"version":3,"file":"dict.d.ts","sourceRoot":"","sources":["../../src/schema/dict.ts"],"names":[],"mappings":"AACA,OAAO,EACL,UAAU,EACV,WAAW,EACX,MAAM,EACN,iBAAiB,EACjB,SAAS,EACV,MAAM,YAAY,CAAA;AAEnB;;;;GAIG;AACH,qBAAa,UAAU,CACrB,KAAK,CAAC,IAAI,SAAS,SAAS,CAAC,MAAM,CAAC,GAAG,GAAG,EAC1C,KAAK,CAAC,MAAM,SAAS,SAAS,GAAG,GAAG,CACpC,SAAQ,MAAM,CACd,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,CAAC,EAC5C,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC,CAC9C;IAEG,QAAQ,CAAC,SAAS,EAAE,IAAI;IACxB,QAAQ,CAAC,WAAW,EAAE,MAAM;gBADnB,SAAS,EAAE,IAAI,EACf,WAAW,EAAE,MAAM;IAK9B,iBAAiB,CACf,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,iBAAiB,EACtB,OAAO,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE;YAAE,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;SAAE,CAAA;KAAE;CAoC1D;AAGD,wBAAgB,IAAI,CAClB,KAAK,CAAC,IAAI,SAAS,SAAS,CAAC,MAAM,CAAC,EACpC,KAAK,CAAC,MAAM,SAAS,SAAS,EAC9B,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,4BAEzB"}

package/dist/schema/dict.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DictSchema = void 0;
+exports.dict = dict;
 const lex_data_1 = require("@atproto/lex-data");
 const core_js_1 = require("../core.js");
 /**
@@ -36,13 +37,21 @@ class DictSchema extends core_js_1.Schema {
             const valueResult = ctx.validateChild(input, key, this.valueSchema);
             if (!valueResult.success)
                 return valueResult;
-            if (valueResult.value !== input[key]) {
+            if (!Object.is(valueResult.value, input[key])) {
+                if (ctx.options.mode === 'validate') {
+                    // In "validate" mode, we can't modify the input, so we issue an error
+                    return ctx.issueInvalidPropertyValue(input, key, [valueResult.value]);
+                }
                 copy ??= { ...input };
                 copy[key] = valueResult.value;
             }
         }
-        return ctx.success((copy ?? input));
+        return ctx.success(copy ?? input);
     }
 }
 exports.DictSchema = DictSchema;
+/*@__NO_SIDE_EFFECTS__*/
+function dict(key, value) {
+    return new DictSchema(key, value);
+}
 //# sourceMappingURL=dict.js.map

package/dist/schema/dict.js.map

@@ -1 +1 @@
-{"version":3,"file":"dict.js","sourceRoot":"","sources":["../../src/schema/dict.ts"],"names":[],"mappings":";;;AAAA,gDAAiD;AACjD,wCAMmB;AAOnB;;;;GAIG;AACH,MAAa,UAGX,SAAQ,gBAAgD;IAE7C;IACA;IAFX,YACW,SAAoB,EACpB,WAAwB;QAEjC,KAAK,EAAE,CAAA;QAHE,cAAS,GAAT,SAAS,CAAW;QACpB,gBAAW,GAAX,WAAW,CAAa;IAGnC,CAAC;IAED,iBAAiB,CACf,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  Schema,\n  ValidationResult,\n  Validator,\n  ValidatorContext,\n} from '../core.js'\n\nexport type DictSchemaOutput<\n  KeySchema extends Validator<string>,\n  ValueSchema extends Validator,\n> = Record<Infer<KeySchema>, 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<string> = any,\n  const ValueSchema extends Validator = any,\n> extends Schema<DictSchemaOutput<KeySchema, ValueSchema>> {\n  constructor(\n    readonly keySchema: KeySchema,\n    readonly valueSchema: ValueSchema,\n  ) {\n    super()\n  }\n\n  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"]}
+{"version":3,"file":"dict.js","sourceRoot":"","sources":["../../src/schema/dict.ts"],"names":[],"mappings":";;;AAsEA,oBAKC;AA3ED,gDAAiD;AACjD,wCAMmB;AAEnB;;;;GAIG;AACH,MAAa,UAGX,SAAQ,gBAGT;IAEY;IACA;IAFX,YACW,SAAe,EACf,WAAmB;QAE5B,KAAK,EAAE,CAAA;QAHE,cAAS,GAAT,SAAS,CAAM;QACf,gBAAW,GAAX,WAAW,CAAQ;IAG9B,CAAC;IAED,iBAAiB,CACf,KAAc,EACd,GAAsB,EACtB,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,CAAC,MAAM,CAAC,EAAE,CAAC,WAAW,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;gBAC9C,IAAI,GAAG,CAAC,OAAO,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;oBACpC,sEAAsE;oBACtE,OAAO,GAAG,CAAC,yBAAyB,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAA;gBACvE,CAAC;gBAED,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,CAAC,IAAI,IAAI,KAAK,CAAC,CAAA;IACnC,CAAC;CACF;AArDD,gCAqDC;AAED,wBAAwB;AACxB,SAAgB,IAAI,CAGlB,GAAS,EAAE,KAAa;IACxB,OAAO,IAAI,UAAU,CAAe,GAAG,EAAE,KAAK,CAAC,CAAA;AACjD,CAAC","sourcesContent":["import { isPlainObject } from '@atproto/lex-data'\nimport {\n  InferInput,\n  InferOutput,\n  Schema,\n  ValidationContext,\n  Validator,\n} from '../core.js'\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 TKey extends Validator<string> = any,\n  const TValue extends Validator = any,\n> extends Schema<\n  Record<InferInput<TKey>, InferInput<TValue>>,\n  Record<InferInput<TKey>, InferOutput<TValue>>\n> {\n  constructor(\n    readonly keySchema: TKey,\n    readonly valueSchema: TValue,\n  ) {\n    super()\n  }\n\n  validateInContext(\n    input: unknown,\n    ctx: ValidationContext,\n    options?: { ignoredKeys?: { has(k: string): boolean } },\n  ) {\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 (!Object.is(valueResult.value, input[key])) {\n        if (ctx.options.mode === 'validate') {\n          // In \"validate\" mode, we can't modify the input, so we issue an error\n          return ctx.issueInvalidPropertyValue(input, key, [valueResult.value])\n        }\n\n        copy ??= { ...input }\n        copy[key] = valueResult.value\n      }\n    }\n\n    return ctx.success(copy ?? input)\n  }\n}\n\n/*@__NO_SIDE_EFFECTS__*/\nexport function dict<\n  const TKey extends Validator<string>,\n  const TValue extends Validator,\n>(key: TKey, value: TValue) {\n  return new DictSchema<TKey, TValue>(key, value)\n}\n"]}

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

@@ -1,25 +1,32 @@
-import { Infer, Schema, ValidationResult, Validator, ValidatorContext } from '../core.js';
+import { InferInput, InferOutput, Schema, ValidationContext, ValidationResult, Validator } from '../core.js';
 import { EnumSchema } from './enum.js';
 import { LiteralSchema } from './literal.js';
 import { ObjectSchema } from './object.js';
-export type DiscriminatedUnionVariant<Discriminator extends string> = ObjectSchema<Record<Discriminator, EnumSchema | LiteralSchema>>;
-export type DiscriminatedUnionVariants<Discriminator extends string> = readonly [
-    DiscriminatedUnionVariant<Discriminator>,
-    ...DiscriminatedUnionVariant<Discriminator>[]
+export type DiscriminatedUnionVariant<Discriminator extends string = string> = ObjectSchema<Record<Discriminator, EnumSchema<any> | LiteralSchema<any>>>;
+export type DiscriminatedUnionVariants<TDiscriminator extends string> = readonly [
+    DiscriminatedUnionVariant<TDiscriminator>,
+    ...DiscriminatedUnionVariant<TDiscriminator>[]
 ];
-export type DiscriminatedUnionSchemaOutput<Variants extends readonly Validator[]> = Variants extends readonly [
-    infer V extends Validator,
-    ...infer Rest extends readonly Validator[]
-] ? Infer<V> | DiscriminatedUnionSchemaOutput<Rest> : never;
+type DiscriminatedUnionSchemaInput<TVariants extends readonly Validator[]> = TVariants extends readonly [
+    infer TValidator extends Validator,
+    ...infer TRest extends readonly Validator[]
+] ? InferInput<TValidator> | DiscriminatedUnionSchemaInput<TRest> : never;
+type DiscriminatedUnionSchemaOutput<TVariants extends readonly Validator[]> = TVariants extends readonly [
+    infer TValidator extends Validator,
+    ...infer TRest extends readonly Validator[]
+] ? InferOutput<TValidator> | DiscriminatedUnionSchemaOutput<TRest> : 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 Variants extends DiscriminatedUnionVariants<Discriminator> = any> extends Schema<DiscriminatedUnionSchemaOutput<Variants>> {
-    readonly discriminator: Discriminator;
-    readonly variantsMap: Map<unknown, DiscriminatedUnionVariant<Discriminator>>;
-    constructor(discriminator: Discriminator, variants: Variants);
-    validateInContext(input: unknown, ctx: ValidatorContext): ValidationResult<DiscriminatedUnionSchemaOutput<Variants>>;
+export declare class DiscriminatedUnionSchema<const TDiscriminator extends string, const TVariants extends DiscriminatedUnionVariants<TDiscriminator>> extends Schema<DiscriminatedUnionSchemaInput<TVariants>, DiscriminatedUnionSchemaOutput<TVariants>> {
+    readonly discriminator: TDiscriminator;
+    readonly variants: TVariants;
+    readonly variantsMap: Map<unknown, DiscriminatedUnionVariant<TDiscriminator>>;
+    constructor(discriminator: TDiscriminator, variants: TVariants);
+    validateInContext(input: unknown, ctx: ValidationContext): ValidationResult<DiscriminatedUnionSchemaInput<TVariants>>;
 }
+export declare function discriminatedUnion<const Discriminator extends string, const Options extends DiscriminatedUnionVariants<Discriminator>>(discriminator: Discriminator, variants: Options): DiscriminatedUnionSchema<Discriminator, Options>;
+export {};
 //# sourceMappingURL=discriminated-union.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"discriminated-union.d.ts","sourceRoot":"","sources":["../../src/schema/discriminated-union.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,EACL,MAAM,EACN,gBAAgB,EAChB,SAAS,EACT,gBAAgB,EACjB,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AACtC,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE1C,MAAM,MAAM,yBAAyB,CAAC,aAAa,SAAS,MAAM,IAChE,YAAY,CAAC,MAAM,CAAC,aAAa,EAAE,UAAU,GAAG,aAAa,CAAC,CAAC,CAAA;AAEjE,MAAM,MAAM,0BAA0B,CAAC,aAAa,SAAS,MAAM,IACjE,SAAS;IACP,yBAAyB,CAAC,aAAa,CAAC;IACxC,GAAG,yBAAyB,CAAC,aAAa,CAAC,EAAE;CAC9C,CAAA;AAEH,MAAM,MAAM,8BAA8B,CACxC,QAAQ,SAAS,SAAS,SAAS,EAAE,IACnC,QAAQ,SAAS,SAAS;IAC5B,MAAM,CAAC,SAAS,SAAS;IACzB,GAAG,MAAM,IAAI,SAAS,SAAS,SAAS,EAAE;CAC3C,GACG,KAAK,CAAC,CAAC,CAAC,GAAG,8BAA8B,CAAC,IAAI,CAAC,GAC/C,KAAK,CAAA;AAET;;;;GAIG;AACH,qBAAa,wBAAwB,CACnC,KAAK,CAAC,aAAa,SAAS,MAAM,GAAG,GAAG,EACxC,KAAK,CAAC,QAAQ,SAAS,0BAA0B,CAAC,aAAa,CAAC,GAAG,GAAG,CACtE,SAAQ,MAAM,CAAC,8BAA8B,CAAC,QAAQ,CAAC,CAAC;IAItD,QAAQ,CAAC,aAAa,EAAE,aAAa;IAHvC,QAAQ,CAAC,WAAW,EAAE,GAAG,CAAC,OAAO,EAAE,yBAAyB,CAAC,aAAa,CAAC,CAAC,CAAA;gBAGjE,aAAa,EAAE,aAAa,EACrC,QAAQ,EAAE,QAAQ;IAUpB,iBAAiB,CACf,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,gBAAgB,GACpB,gBAAgB,CAAC,8BAA8B,CAAC,QAAQ,CAAC,CAAC;CAwB9D"}
+{"version":3,"file":"discriminated-union.d.ts","sourceRoot":"","sources":["../../src/schema/discriminated-union.ts"],"names":[],"mappings":"AACA,OAAO,EACL,UAAU,EACV,WAAW,EACX,MAAM,EACN,iBAAiB,EACjB,gBAAgB,EAChB,SAAS,EACV,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AACtC,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE1C,MAAM,MAAM,yBAAyB,CAAC,aAAa,SAAS,MAAM,GAAG,MAAM,IACzE,YAAY,CAAC,MAAM,CAAC,aAAa,EAAE,UAAU,CAAC,GAAG,CAAC,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,CAAA;AAE3E,MAAM,MAAM,0BAA0B,CAAC,cAAc,SAAS,MAAM,IAClE,SAAS;IACP,yBAAyB,CAAC,cAAc,CAAC;IACzC,GAAG,yBAAyB,CAAC,cAAc,CAAC,EAAE;CAC/C,CAAA;AAEH,KAAK,6BAA6B,CAAC,SAAS,SAAS,SAAS,SAAS,EAAE,IACvE,SAAS,SAAS,SAAS;IACzB,MAAM,UAAU,SAAS,SAAS;IAClC,GAAG,MAAM,KAAK,SAAS,SAAS,SAAS,EAAE;CAC5C,GACG,UAAU,CAAC,UAAU,CAAC,GAAG,6BAA6B,CAAC,KAAK,CAAC,GAC7D,KAAK,CAAA;AAEX,KAAK,8BAA8B,CAAC,SAAS,SAAS,SAAS,SAAS,EAAE,IACxE,SAAS,SAAS,SAAS;IACzB,MAAM,UAAU,SAAS,SAAS;IAClC,GAAG,MAAM,KAAK,SAAS,SAAS,SAAS,EAAE;CAC5C,GACG,WAAW,CAAC,UAAU,CAAC,GAAG,8BAA8B,CAAC,KAAK,CAAC,GAC/D,KAAK,CAAA;AAEX;;;;GAIG;AACH,qBAAa,wBAAwB,CACnC,KAAK,CAAC,cAAc,SAAS,MAAM,EACnC,KAAK,CAAC,SAAS,SAAS,0BAA0B,CAAC,cAAc,CAAC,CAClE,SAAQ,MAAM,CACd,6BAA6B,CAAC,SAAS,CAAC,EACxC,8BAA8B,CAAC,SAAS,CAAC,CAC1C;IAIG,QAAQ,CAAC,aAAa,EAAE,cAAc;IACtC,QAAQ,CAAC,QAAQ,EAAE,SAAS;IAJ9B,QAAQ,CAAC,WAAW,EAAE,GAAG,CAAC,OAAO,EAAE,yBAAyB,CAAC,cAAc,CAAC,CAAC,CAAA;gBAGlE,aAAa,EAAE,cAAc,EAC7B,QAAQ,EAAE,SAAS;IAU9B,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;CAwBzD;AAuCD,wBAAgB,kBAAkB,CAChC,KAAK,CAAC,aAAa,SAAS,MAAM,EAClC,KAAK,CAAC,OAAO,SAAS,0BAA0B,CAAC,aAAa,CAAC,EAC/D,aAAa,EAAE,aAAa,EAAE,QAAQ,EAAE,OAAO,oDAKhD"}

package/dist/schema/discriminated-union.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DiscriminatedUnionSchema = void 0;
+exports.discriminatedUnion = discriminatedUnion;
 const lex_data_1 = require("@atproto/lex-data");
 const core_js_1 = require("../core.js");
 const enum_js_1 = require("./enum.js");
@@ -12,10 +13,12 @@ const literal_js_1 = require("./literal.js");
  */
 class DiscriminatedUnionSchema extends core_js_1.Schema {
     discriminator;
+    variants;
     variantsMap;
     constructor(discriminator, variants) {
         super();
         this.discriminator = discriminator;
+        this.variants = variants;
         // Although we usually try to avoid initialization work in constructors,
         // here it is necessary to ensure that invalid discriminated throw from the
         // place of construction, rather than later during validation.
@@ -66,4 +69,8 @@ function buildVariantsMap(discriminator, variants) {
     }
     return variantsMap;
 }
+/*@__NO_SIDE_EFFECTS__*/
+function discriminatedUnion(discriminator, variants) {
+    return new DiscriminatedUnionSchema(discriminator, variants);
+}
 //# sourceMappingURL=discriminated-union.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"discriminated-union.js","sourceRoot":"","sources":["../../src/schema/discriminated-union.ts"],"names":[],"mappings":";;;AAAA,gDAAiD;AACjD,wCAMmB;AACnB,uCAAsC;AACtC,6CAA4C;AAqB5C;;;;GAIG;AACH,MAAa,wBAGX,SAAQ,gBAAgD;IAI7C;IAHF,WAAW,CAAwD;IAE5E,YACW,aAA4B,EACrC,QAAkB;QAElB,KAAK,EAAE,CAAA;QAHE,kBAAa,GAAb,aAAa,CAAe;QAKrC,wEAAwE;QACxE,2EAA2E;QAC3E,8DAA8D;QAC9D,IAAI,CAAC,WAAW,GAAG,gBAAgB,CAAC,aAAa,EAAE,QAAQ,CAAC,CAAA;IAC9D,CAAC;IAED,iBAAiB,CACf,KAAc,EACd,GAAqB;QAErB,IAAI,CAAC,IAAA,wBAAa,EAAC,KAAK,CAAC,EAAE,CAAC;YAC1B,OAAO,GAAG,CAAC,gBAAgB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAA;QAC9C,CAAC;QAED,MAAM,EAAE,aAAa,EAAE,GAAG,IAAI,CAAA;QAE9B,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,aAAa,CAAC,EAAE,CAAC;YACzC,OAAO,GAAG,CAAC,gBAAgB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAA;QACnD,CAAC;QAED,MAAM,kBAAkB,GAAG,KAAK,CAAC,aAAa,CAAC,CAAA;QAE/C,MAAM,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAA;QACxD,IAAI,OAAO,EAAE,CAAC;YACZ,OAAO,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAEjC,CAAA;QACH,CAAC;QAED,OAAO,GAAG,CAAC,yBAAyB,CAAC,KAAK,EAAE,aAAa,EAAE;YACzD,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE;SAC3B,CAAC,CAAA;IACJ,CAAC;CACF;AA7CD,4DA6CC;AAED,SAAS,gBAAgB,CACvB,aAA4B,EAC5B,QAAmD;IAEnD,MAAM,WAAW,GAAG,IAAI,GAAG,EAGxB,CAAA;IAEH,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC/B,MAAM,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,aAAa,CAAC,CAAA;QAC3C,IAAI,MAAM,YAAY,0BAAa,EAAE,CAAC;YACpC,IAAI,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;gBAClC,MAAM,IAAI,SAAS,CAAC,oCAAoC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAA;YACzE,CAAC;YACD,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,EAAE,OAAO,CAAC,CAAA;QACxC,CAAC;aAAM,IAAI,MAAM,YAAY,oBAAU,EAAE,CAAC;YACxC,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;gBAChC,IAAI,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;oBACzB,MAAM,IAAI,SAAS,CAAC,oCAAoC,GAAG,EAAE,CAAC,CAAA;gBAChE,CAAC;gBACD,WAAW,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,CAAA;YAC/B,CAAC;QACH,CAAC;aAAM,CAAC;YACN,sDAAsD;YAEtD,kDAAkD;YAClD,MAAM,IAAI,SAAS,CACjB,4DAA4D,CAC7D,CAAA;QACH,CAAC;IACH,CAAC;IAED,OAAO,WAAW,CAAA;AACpB,CAAC","sourcesContent":["import { isPlainObject } from '@atproto/lex-data'\nimport {\n  Infer,\n  Schema,\n  ValidationResult,\n  Validator,\n  ValidatorContext,\n} from '../core.js'\nimport { EnumSchema } from './enum.js'\nimport { LiteralSchema } from './literal.js'\nimport { ObjectSchema } from './object.js'\n\nexport type DiscriminatedUnionVariant<Discriminator extends string> =\n  ObjectSchema<Record<Discriminator, EnumSchema | LiteralSchema>>\n\nexport type DiscriminatedUnionVariants<Discriminator extends string> =\n  readonly [\n    DiscriminatedUnionVariant<Discriminator>,\n    ...DiscriminatedUnionVariant<Discriminator>[],\n  ]\n\nexport type DiscriminatedUnionSchemaOutput<\n  Variants extends readonly Validator[],\n> = Variants extends readonly [\n  infer V extends Validator,\n  ...infer Rest extends readonly Validator[],\n]\n  ? Infer<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 Variants extends DiscriminatedUnionVariants<Discriminator> = any,\n> extends Schema<DiscriminatedUnionSchemaOutput<Variants>> {\n  readonly variantsMap: Map<unknown, DiscriminatedUnionVariant<Discriminator>>\n\n  constructor(\n    readonly discriminator: Discriminator,\n    variants: Variants,\n  ) {\n    super()\n\n    // Although we usually try to avoid initialization work in constructors,\n    // here it is necessary to ensure that invalid discriminated throw from the\n    // place of construction, rather than later during validation.\n    this.variantsMap = buildVariantsMap(discriminator, variants)\n  }\n\n  validateInContext(\n    input: unknown,\n    ctx: ValidatorContext,\n  ): ValidationResult<DiscriminatedUnionSchemaOutput<Variants>> {\n    if (!isPlainObject(input)) {\n      return ctx.issueInvalidType(input, 'object')\n    }\n\n    const { discriminator } = this\n\n    if (!Object.hasOwn(input, discriminator)) {\n      return ctx.issueRequiredKey(input, discriminator)\n    }\n\n    const discriminatorValue = input[discriminator]\n\n    const variant = this.variantsMap.get(discriminatorValue)\n    if (variant) {\n      return ctx.validate(input, variant) as ValidationResult<\n        DiscriminatedUnionSchemaOutput<Variants>\n      >\n    }\n\n    return ctx.issueInvalidPropertyValue(input, discriminator, [\n      ...this.variantsMap.keys(),\n    ])\n  }\n}\n\nfunction buildVariantsMap<Discriminator extends string>(\n  discriminator: Discriminator,\n  variants: DiscriminatedUnionVariants<Discriminator>,\n) {\n  const variantsMap = new Map<\n    unknown,\n    DiscriminatedUnionVariant<Discriminator>\n  >()\n\n  for (const variant of variants) {\n    const schema = variant.shape[discriminator]\n    if (schema instanceof LiteralSchema) {\n      if (variantsMap.has(schema.value)) {\n        throw new TypeError(`Overlapping discriminator value: ${schema.value}`)\n      }\n      variantsMap.set(schema.value, variant)\n    } else if (schema instanceof EnumSchema) {\n      for (const val of schema.values) {\n        if (variantsMap.has(val)) {\n          throw new TypeError(`Overlapping discriminator value: ${val}`)\n        }\n        variantsMap.set(val, variant)\n      }\n    } else {\n      // Only enumerable discriminator schemas are supported\n\n      // Should never happen if types are used correctly\n      throw new TypeError(\n        `Discriminator schema must be a LiteralSchema or EnumSchema`,\n      )\n    }\n  }\n\n  return variantsMap\n}\n"]}
+{"version":3,"file":"discriminated-union.js","sourceRoot":"","sources":["../../src/schema/discriminated-union.ts"],"names":[],"mappings":";;;AA+HA,gDAQC;AAvID,gDAAiD;AACjD,wCAOmB;AACnB,uCAAsC;AACtC,6CAA4C;AA4B5C;;;;GAIG;AACH,MAAa,wBAGX,SAAQ,gBAGT;IAIY;IACA;IAJF,WAAW,CAAyD;IAE7E,YACW,aAA6B,EAC7B,QAAmB;QAE5B,KAAK,EAAE,CAAA;QAHE,kBAAa,GAAb,aAAa,CAAgB;QAC7B,aAAQ,GAAR,QAAQ,CAAW;QAI5B,wEAAwE;QACxE,2EAA2E;QAC3E,8DAA8D;QAC9D,IAAI,CAAC,WAAW,GAAG,gBAAgB,CAAC,aAAa,EAAE,QAAQ,CAAC,CAAA;IAC9D,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,CAAC,IAAA,wBAAa,EAAC,KAAK,CAAC,EAAE,CAAC;YAC1B,OAAO,GAAG,CAAC,gBAAgB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAA;QAC9C,CAAC;QAED,MAAM,EAAE,aAAa,EAAE,GAAG,IAAI,CAAA;QAE9B,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,aAAa,CAAC,EAAE,CAAC;YACzC,OAAO,GAAG,CAAC,gBAAgB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAA;QACnD,CAAC;QAED,MAAM,kBAAkB,GAAG,KAAK,CAAC,aAAa,CAAC,CAAA;QAE/C,MAAM,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAA;QACxD,IAAI,OAAO,EAAE,CAAC;YACZ,OAAO,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAEjC,CAAA;QACH,CAAC;QAED,OAAO,GAAG,CAAC,yBAAyB,CAAC,KAAK,EAAE,aAAa,EAAE;YACzD,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE;SAC3B,CAAC,CAAA;IACJ,CAAC;CACF;AA7CD,4DA6CC;AAED,SAAS,gBAAgB,CACvB,aAA4B,EAC5B,QAAmD;IAEnD,MAAM,WAAW,GAAG,IAAI,GAAG,EAGxB,CAAA;IAEH,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC/B,MAAM,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,aAAa,CAAC,CAAA;QAC3C,IAAI,MAAM,YAAY,0BAAa,EAAE,CAAC;YACpC,IAAI,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;gBAClC,MAAM,IAAI,SAAS,CAAC,oCAAoC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAA;YACzE,CAAC;YACD,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,EAAE,OAAO,CAAC,CAAA;QACxC,CAAC;aAAM,IAAI,MAAM,YAAY,oBAAU,EAAE,CAAC;YACxC,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;gBAChC,IAAI,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;oBACzB,MAAM,IAAI,SAAS,CAAC,oCAAoC,GAAG,EAAE,CAAC,CAAA;gBAChE,CAAC;gBACD,WAAW,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,CAAA;YAC/B,CAAC;QACH,CAAC;aAAM,CAAC;YACN,sDAAsD;YAEtD,kDAAkD;YAClD,MAAM,IAAI,SAAS,CACjB,4DAA4D,CAC7D,CAAA;QACH,CAAC;IACH,CAAC;IAED,OAAO,WAAW,CAAA;AACpB,CAAC;AAED,wBAAwB;AACxB,SAAgB,kBAAkB,CAGhC,aAA4B,EAAE,QAAiB;IAC/C,OAAO,IAAI,wBAAwB,CACjC,aAAa,EACb,QAAQ,CACT,CAAA;AACH,CAAC","sourcesContent":["import { isPlainObject } from '@atproto/lex-data'\nimport {\n  InferInput,\n  InferOutput,\n  Schema,\n  ValidationContext,\n  ValidationResult,\n  Validator,\n} from '../core.js'\nimport { EnumSchema } from './enum.js'\nimport { LiteralSchema } from './literal.js'\nimport { ObjectSchema } from './object.js'\n\nexport type DiscriminatedUnionVariant<Discriminator extends string = string> =\n  ObjectSchema<Record<Discriminator, EnumSchema<any> | LiteralSchema<any>>>\n\nexport type DiscriminatedUnionVariants<TDiscriminator extends string> =\n  readonly [\n    DiscriminatedUnionVariant<TDiscriminator>,\n    ...DiscriminatedUnionVariant<TDiscriminator>[],\n  ]\n\ntype DiscriminatedUnionSchemaInput<TVariants extends readonly Validator[]> =\n  TVariants extends readonly [\n    infer TValidator extends Validator,\n    ...infer TRest extends readonly Validator[],\n  ]\n    ? InferInput<TValidator> | DiscriminatedUnionSchemaInput<TRest>\n    : never\n\ntype DiscriminatedUnionSchemaOutput<TVariants extends readonly Validator[]> =\n  TVariants extends readonly [\n    infer TValidator extends Validator,\n    ...infer TRest extends readonly Validator[],\n  ]\n    ? InferOutput<TValidator> | DiscriminatedUnionSchemaOutput<TRest>\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 TDiscriminator extends string,\n  const TVariants extends DiscriminatedUnionVariants<TDiscriminator>,\n> extends Schema<\n  DiscriminatedUnionSchemaInput<TVariants>,\n  DiscriminatedUnionSchemaOutput<TVariants>\n> {\n  readonly variantsMap: Map<unknown, DiscriminatedUnionVariant<TDiscriminator>>\n\n  constructor(\n    readonly discriminator: TDiscriminator,\n    readonly variants: TVariants,\n  ) {\n    super()\n\n    // Although we usually try to avoid initialization work in constructors,\n    // here it is necessary to ensure that invalid discriminated throw from the\n    // place of construction, rather than later during validation.\n    this.variantsMap = buildVariantsMap(discriminator, variants)\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!isPlainObject(input)) {\n      return ctx.issueInvalidType(input, 'object')\n    }\n\n    const { discriminator } = this\n\n    if (!Object.hasOwn(input, discriminator)) {\n      return ctx.issueRequiredKey(input, discriminator)\n    }\n\n    const discriminatorValue = input[discriminator]\n\n    const variant = this.variantsMap.get(discriminatorValue)\n    if (variant) {\n      return ctx.validate(input, variant) as ValidationResult<\n        DiscriminatedUnionSchemaInput<TVariants>\n      >\n    }\n\n    return ctx.issueInvalidPropertyValue(input, discriminator, [\n      ...this.variantsMap.keys(),\n    ])\n  }\n}\n\nfunction buildVariantsMap<Discriminator extends string>(\n  discriminator: Discriminator,\n  variants: DiscriminatedUnionVariants<Discriminator>,\n) {\n  const variantsMap = new Map<\n    unknown,\n    DiscriminatedUnionVariant<Discriminator>\n  >()\n\n  for (const variant of variants) {\n    const schema = variant.shape[discriminator]\n    if (schema instanceof LiteralSchema) {\n      if (variantsMap.has(schema.value)) {\n        throw new TypeError(`Overlapping discriminator value: ${schema.value}`)\n      }\n      variantsMap.set(schema.value, variant)\n    } else if (schema instanceof EnumSchema) {\n      for (const val of schema.values) {\n        if (variantsMap.has(val)) {\n          throw new TypeError(`Overlapping discriminator value: ${val}`)\n        }\n        variantsMap.set(val, variant)\n      }\n    } else {\n      // Only enumerable discriminator schemas are supported\n\n      // Should never happen if types are used correctly\n      throw new TypeError(\n        `Discriminator schema must be a LiteralSchema or EnumSchema`,\n      )\n    }\n  }\n\n  return variantsMap\n}\n\n/*@__NO_SIDE_EFFECTS__*/\nexport function discriminatedUnion<\n  const Discriminator extends string,\n  const Options extends DiscriminatedUnionVariants<Discriminator>,\n>(discriminator: Discriminator, variants: Options) {\n  return new DiscriminatedUnionSchema<Discriminator, Options>(\n    discriminator,\n    variants,\n  )\n}\n"]}

package/dist/schema/enum.d.ts

@@ -1,11 +1,9 @@
-import { Schema, ValidationResult, ValidatorContext } from '../core.js';
-export type EnumSchemaOptions<T extends null | string | number | boolean> = {
-    default?: T;
-};
-export declare class EnumSchema<Output extends null | string | number | boolean = any> extends Schema<Output> {
-    readonly values: readonly Output[];
-    readonly options?: EnumSchemaOptions<Output> | undefined;
-    constructor(values: readonly Output[], options?: EnumSchemaOptions<Output> | undefined);
-    validateInContext(input: unknown | undefined, ctx: ValidatorContext): ValidationResult<Output>;
+import { Schema, ValidationContext } from '../core.js';
+export declare class EnumSchema<const TValue extends null | string | number | boolean> extends Schema<TValue> {
+    readonly values: readonly TValue[];
+    constructor(values: readonly TValue[]);
+    validateInContext(input: unknown, ctx: ValidationContext): import("../core.js").ValidationResult<TValue>;
 }
+export declare function enumSchema<const V extends null | string | number | boolean>(value: readonly V[]): EnumSchema<V>;
+export { enumSchema as enum };
 //# sourceMappingURL=enum.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"enum.d.ts","sourceRoot":"","sources":["../../src/schema/enum.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAEvE,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,IAAI;IAC1E,OAAO,CAAC,EAAE,CAAC,CAAA;CACZ,CAAA;AAED,qBAAa,UAAU,CACrB,MAAM,SAAS,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,GAAG,CACrD,SAAQ,MAAM,CAAC,MAAM,CAAC;IAEpB,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE;IAClC,QAAQ,CAAC,OAAO,CAAC,EAAE,iBAAiB,CAAC,MAAM,CAAC;gBADnC,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,OAAO,CAAC,EAAE,iBAAiB,CAAC,MAAM,CAAC,YAAA;IAK9C,iBAAiB,CACf,KAAK,EAAE,OAAO,YAAwB,EACtC,GAAG,EAAE,gBAAgB,GACpB,gBAAgB,CAAC,MAAM,CAAC;CAO5B"}
+{"version":3,"file":"enum.d.ts","sourceRoot":"","sources":["../../src/schema/enum.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAEtD,qBAAa,UAAU,CACrB,KAAK,CAAC,MAAM,SAAS,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CACrD,SAAQ,MAAM,CAAC,MAAM,CAAC;IACV,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE;gBAAzB,MAAM,EAAE,SAAS,MAAM,EAAE;IAI9C,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;CAOzD;AAGD,wBAAgB,UAAU,CAAC,KAAK,CAAC,CAAC,SAAS,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,EACzE,KAAK,EAAE,SAAS,CAAC,EAAE,iBAGpB;AAGD,OAAO,EAAE,UAAU,IAAI,IAAI,EAAE,CAAA"}

package/dist/schema/enum.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EnumSchema = void 0;
+exports.enumSchema = enumSchema;
+exports.enum = enumSchema;
 const core_js_1 = require("../core.js");
 class EnumSchema extends core_js_1.Schema {
     values;
-    options;
-    constructor(values, options) {
+    constructor(values) {
         super();
         this.values = values;
-        this.options = options;
     }
-    validateInContext(input = this.options?.default, ctx) {
+    validateInContext(input, ctx) {
         if (!this.values.includes(input)) {
             return ctx.issueInvalidValue(input, this.values);
         }
@@ -18,4 +18,8 @@ class EnumSchema extends core_js_1.Schema {
     }
 }
 exports.EnumSchema = EnumSchema;
+/*@__NO_SIDE_EFFECTS__*/
+function enumSchema(value) {
+    return new EnumSchema(value);
+}
 //# sourceMappingURL=enum.js.map

package/dist/schema/enum.js.map

@@ -1 +1 @@
-{"version":3,"file":"enum.js","sourceRoot":"","sources":["../../src/schema/enum.ts"],"names":[],"mappings":";;;AAAA,wCAAuE;AAMvE,MAAa,UAEX,SAAQ,gBAAc;IAEX;IACA;IAFX,YACW,MAAyB,EACzB,OAAmC;QAE5C,KAAK,EAAE,CAAA;QAHE,WAAM,GAAN,MAAM,CAAmB;QACzB,YAAO,GAAP,OAAO,CAA4B;IAG9C,CAAC;IAED,iBAAiB,CACf,QAAiB,IAAI,CAAC,OAAO,EAAE,OAAO,EACtC,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;AApBD,gCAoBC","sourcesContent":["import { Schema, ValidationResult, ValidatorContext } from '../core.js'\n\nexport type EnumSchemaOptions<T extends null | string | number | boolean> = {\n  default?: T\n}\n\nexport class EnumSchema<\n  Output extends null | string | number | boolean = any,\n> extends Schema<Output> {\n  constructor(\n    readonly values: readonly Output[],\n    readonly options?: EnumSchemaOptions<Output>,\n  ) {\n    super()\n  }\n\n  validateInContext(\n    input: unknown = this.options?.default,\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"]}
+{"version":3,"file":"enum.js","sourceRoot":"","sources":["../../src/schema/enum.ts"],"names":[],"mappings":";;;AAmBA,gCAIC;AAGsB,0BAAI;AA1B3B,wCAAsD;AAEtD,MAAa,UAEX,SAAQ,gBAAc;IACD;IAArB,YAAqB,MAAyB;QAC5C,KAAK,EAAE,CAAA;QADY,WAAM,GAAN,MAAM,CAAmB;IAE9C,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,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;AAdD,gCAcC;AAED,wBAAwB;AACxB,SAAgB,UAAU,CACxB,KAAmB;IAEnB,OAAO,IAAI,UAAU,CAAI,KAAK,CAAC,CAAA;AACjC,CAAC","sourcesContent":["import { Schema, ValidationContext } from '../core.js'\n\nexport class EnumSchema<\n  const TValue extends null | string | number | boolean,\n> extends Schema<TValue> {\n  constructor(readonly values: readonly TValue[]) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!(this.values as readonly unknown[]).includes(input)) {\n      return ctx.issueInvalidValue(input, this.values)\n    }\n\n    return ctx.success(input as TValue)\n  }\n}\n\n/*@__NO_SIDE_EFFECTS__*/\nexport function enumSchema<const V extends null | string | number | boolean>(\n  value: readonly V[],\n) {\n  return new EnumSchema<V>(value)\n}\n\n// @NOTE \"enum\" is a reserved keyword in JS/TS\nexport { enumSchema as enum }\n"]}

package/dist/schema/integer.d.ts

@@ -1,12 +1,12 @@
-import { Schema, ValidationResult, ValidatorContext } from '../core.js';
+import { Schema, ValidationContext } from '../core.js';
 export type IntegerSchemaOptions = {
-    default?: number;
     minimum?: number;
     maximum?: number;
 };
 export declare class IntegerSchema extends Schema<number> {
-    readonly options: IntegerSchemaOptions;
-    constructor(options?: IntegerSchemaOptions);
-    validateInContext(input: unknown | undefined, ctx: ValidatorContext): ValidationResult<number>;
+    readonly options?: IntegerSchemaOptions | undefined;
+    constructor(options?: IntegerSchemaOptions | undefined);
+    validateInContext(input: unknown, ctx: ValidationContext): import("../core.js").ValidationResult<number>;
 }
+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,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAEvE,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,MAAM,CAAC,MAAM,CAAC;IACnC,QAAQ,CAAC,OAAO,EAAE,oBAAoB;gBAA7B,OAAO,GAAE,oBAAyB;IAIvD,iBAAiB,CACf,KAAK,EAAE,OAAO,YAAwB,EACtC,GAAG,EAAE,gBAAgB,GACpB,gBAAgB,CAAC,MAAM,CAAC;CAe5B"}
+{"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"}

package/dist/schema/integer.js

@@ -1,21 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IntegerSchema = void 0;
+exports.integer = exports.IntegerSchema = void 0;
 const core_js_1 = require("../core.js");
+const memoize_js_1 = require("../util/memoize.js");
 class IntegerSchema extends core_js_1.Schema {
     options;
-    constructor(options = {}) {
+    constructor(options) {
         super();
         this.options = options;
     }
-    validateInContext(input = this.options?.default, ctx) {
+    validateInContext(input, ctx) {
         if (!isInteger(input)) {
             return ctx.issueInvalidType(input, 'integer');
         }
-        if (this.options.minimum !== undefined && input < this.options.minimum) {
+        if (this.options?.minimum != null && input < this.options.minimum) {
             return ctx.issueTooSmall(input, 'integer', this.options.minimum, input);
         }
-        if (this.options.maximum !== undefined && input > this.options.maximum) {
+        if (this.options?.maximum != null && input > this.options.maximum) {
             return ctx.issueTooBig(input, 'integer', this.options.maximum, input);
         }
         return ctx.success(input);
@@ -28,4 +29,7 @@ exports.IntegerSchema = IntegerSchema;
 function isInteger(input) {
     return Number.isSafeInteger(input);
 }
+exports.integer = (0, memoize_js_1.memoizedOptions)(function (options) {
+    return new IntegerSchema(options);
+});
 //# sourceMappingURL=integer.js.map

package/dist/schema/integer.js.map

@@ -1 +1 @@
-{"version":3,"file":"integer.js","sourceRoot":"","sources":["../../src/schema/integer.ts"],"names":[],"mappings":";;;AAAA,wCAAuE;AAQvE,MAAa,aAAc,SAAQ,gBAAc;IAC1B;IAArB,YAAqB,UAAgC,EAAE;QACrD,KAAK,EAAE,CAAA;QADY,YAAO,GAAP,OAAO,CAA2B;IAEvD,CAAC;IAED,iBAAiB,CACf,QAAiB,IAAI,CAAC,OAAO,EAAE,OAAO,EACtC,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;AAvBD,sCAuBC;AAED;;GAEG;AACH,SAAS,SAAS,CAAC,KAAc;IAC/B,OAAO,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,CAAA;AACpC,CAAC","sourcesContent":["import { Schema, ValidationResult, ValidatorContext } from '../core.js'\n\nexport type IntegerSchemaOptions = {\n  default?: number\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(\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.isSafeInteger} that acts as a type guard.\n */\nfunction isInteger(input: unknown): input is number {\n  return Number.isSafeInteger(input)\n}\n"]}
+{"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"]}

package/dist/schema/intersection.d.ts

@@ -1,4 +1,4 @@
-import { Infer, Schema, Simplify, ValidationResult, ValidatorContext } from '../core.js';
+import { InferInput, InferOutput, Schema, Simplify, ValidationContext } from '../core.js';
 import { DictSchema } from './dict.js';
 import { ObjectSchema } from './object.js';
 /**
@@ -13,11 +13,11 @@ A & B : // Otherwise, properly represent the fact that accessing using an
 A & {
     [K in keyof B]: B[K] | A[keyof A & K];
 };
-export type IntersectionSchemaOutput<Left extends ObjectSchema, Right extends DictSchema> = Simplify<Intersect<Infer<Left>, Infer<Right>>>;
-export declare class IntersectionSchema<const Left extends ObjectSchema = any, const Right extends DictSchema = any> extends Schema<IntersectionSchemaOutput<Left, Right>> {
+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;
     constructor(left: Left, right: Right);
-    validateInContext(input: unknown, ctx: ValidatorContext): ValidationResult<IntersectionSchemaOutput<Left, Right>>;
+    validateInContext(input: unknown, ctx: ValidationContext): import("../core.js").ValidationResult<Record<string, unknown>>;
 }
+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,KAAK,EACL,MAAM,EACN,QAAQ,EACR,gBAAgB,EAChB,gBAAgB,EACjB,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,MAAM,MAAM,wBAAwB,CAClC,IAAI,SAAS,YAAY,EACzB,KAAK,SAAS,UAAU,IACtB,QAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;AAElD,qBAAa,kBAAkB,CAC7B,KAAK,CAAC,IAAI,SAAS,YAAY,GAAG,GAAG,EACrC,KAAK,CAAC,KAAK,SAAS,UAAU,GAAG,GAAG,CACpC,SAAQ,MAAM,CAAC,wBAAwB,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAEnD,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,CACf,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,gBAAgB,GACpB,gBAAgB,CAAC,wBAAwB,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;CAQ3D"}
+{"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"}

package/dist/schema/intersection.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IntersectionSchema = void 0;
+exports.intersection = intersection;
 const core_js_1 = require("../core.js");
 class IntersectionSchema extends core_js_1.Schema {
     left;
@@ -20,4 +21,8 @@ class IntersectionSchema extends core_js_1.Schema {
     }
 }
 exports.IntersectionSchema = IntersectionSchema;
+/*@__NO_SIDE_EFFECTS__*/
+function intersection(left, right) {
+    return new IntersectionSchema(left, right);
+}
 //# sourceMappingURL=intersection.js.map

package/dist/schema/intersection.js.map

@@ -1 +1 @@
-{"version":3,"file":"intersection.js","sourceRoot":"","sources":["../../src/schema/intersection.ts"],"names":[],"mappings":";;;AAAA,wCAMmB;AAyBnB,MAAa,kBAGX,SAAQ,gBAA6C;IAEhC;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,CACf,KAAc,EACd,GAAqB;QAErB,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,CAA4D,CAAA;IAC/D,CAAC;CACF;AAtBD,gDAsBC","sourcesContent":["import {\n  Infer,\n  Schema,\n  Simplify,\n  ValidationResult,\n  ValidatorContext,\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 type IntersectionSchemaOutput<\n  Left extends ObjectSchema,\n  Right extends DictSchema,\n> = Simplify<Intersect<Infer<Left>, Infer<Right>>>\n\nexport class IntersectionSchema<\n  const Left extends ObjectSchema = any,\n  const Right extends DictSchema = any,\n> extends Schema<IntersectionSchemaOutput<Left, Right>> {\n  constructor(\n    protected readonly left: Left,\n    protected readonly right: Right,\n  ) {\n    super()\n  }\n\n  validateInContext(\n    input: unknown,\n    ctx: ValidatorContext,\n  ): ValidationResult<IntersectionSchemaOutput<Left, Right>> {\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    }) as ValidationResult<IntersectionSchemaOutput<Left, Right>>\n  }\n}\n"]}
+{"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"]}