@fncts/schema 0.0.16 → 0.0.18

package/AST.d.ts

@@ -17,6 +17,7 @@ export declare abstract class Annotated {
 export declare abstract class AST extends Annotated {
     readonly [ASTTypeId]: ASTTypeId;
     abstract clone(newProperties: Partial<this>): AST;
+    toString(verbose?: boolean): string;
 }
 export declare namespace AST {
     interface Compiler<A> {
@@ -61,20 +62,23 @@ export type Concrete = Declaration | Literal | UniqueSymbol | UndefinedKeyword |
  */
 export declare function concrete(_: AST): asserts _ is Concrete;
 export declare function getAnnotations<V>(key: ASTAnnotation<V>): (self: Annotated) => Maybe<V>;
+/**
+ * @tsplus type fncts.schema.AST.Declaration
+ */
 export declare class Declaration extends AST {
     readonly typeParameters: Vector<AST>;
-    readonly type: AST;
     readonly decode: (...typeParameters: ReadonlyArray<AST>) => (input: any, options?: ParseOptions) => ParseResult<any>;
+    readonly encode: (...typeParameters: ReadonlyArray<AST>) => (input: any, options?: ParseOptions) => ParseResult<any>;
     readonly annotations: ASTAnnotationMap;
     readonly _tag = ASTTag.Declaration;
-    constructor(typeParameters: Vector<AST>, type: AST, decode: (...typeParameters: ReadonlyArray<AST>) => (input: any, options?: ParseOptions) => ParseResult<any>, annotations?: ASTAnnotationMap);
+    constructor(typeParameters: Vector<AST>, decode: (...typeParameters: ReadonlyArray<AST>) => (input: any, options?: ParseOptions) => ParseResult<any>, encode: (...typeParameters: ReadonlyArray<AST>) => (input: any, options?: ParseOptions) => ParseResult<any>, annotations?: ASTAnnotationMap);
     clone(newProperties: Partial<this>): AST;
 }
 /**
  * @tsplus static fncts.schema.ASTOps createDeclaration
  * @tsplus location "@fncts/schema/AST"
  */
-export declare function createDeclaration(typeParameters: Vector<AST>, type: AST, decode: (...typeParameters: ReadonlyArray<AST>) => (input: any, options?: ParseOptions) => ParseResult<any>, annotations?: ASTAnnotationMap): Declaration;
+export declare function createDeclaration(typeParameters: Vector<AST>, decode: (...typeParameters: ReadonlyArray<AST>) => (input: any, options?: ParseOptions) => ParseResult<any>, encode: (...typeParameters: ReadonlyArray<AST>) => (input: any, options?: ParseOptions) => ParseResult<any>, annotations?: ASTAnnotationMap): Declaration;
 /**
  * @tsplus fluent fncts.schema.AST isDeclaration
  * @tsplus location "@fncts/schema/AST"
@@ -277,6 +281,7 @@ export declare class TemplateLiteralSpan {
     readonly type: StringKeyword | NumberKeyword;
     readonly literal: string;
     constructor(type: StringKeyword | NumberKeyword, literal: string);
+    toString(): "${string}" | "${number}";
 }
 export declare class TemplateLiteral extends AST {
     readonly head: string;
@@ -295,6 +300,7 @@ export declare class Element {
     readonly type: AST;
     readonly isOptional: boolean;
     constructor(type: AST, isOptional: boolean);
+    toString(): string;
 }
 /**
  * @tsplus static fncts.schema.ASTOps createElement
@@ -320,14 +326,14 @@ export declare function createTuple(elements: Vector<Element>, rest: Maybe<Vecto
  * @tsplus location "@fncts/schema/AST"
  */
 export declare const unknownArray: Tuple;
-export declare class PropertySignature extends AST {
+export declare class PropertySignature {
     readonly name: PropertyKey;
     readonly type: AST;
     readonly isOptional: boolean;
     readonly isReadonly: boolean;
     readonly annotations: ASTAnnotationMap;
     constructor(name: PropertyKey, type: AST, isOptional: boolean, isReadonly: boolean, annotations?: ASTAnnotationMap);
-    clone(newProperties: Partial<this>): AST;
+    clone(newProperties: Partial<this>): PropertySignature;
 }
 /**
  * @tsplus static fncts.schema.ASTOps createPropertySignature
@@ -454,7 +460,8 @@ export declare function createValidation(from: AST, validation: Vector<Validatio
  * @tsplus tailRec
  */
 export declare function getCardinality(ast: AST): number;
-export declare function getWeight(ast: AST): number;
+export type Weight = readonly [number, number, number];
+export declare function getWeight(ast: AST): Weight;
 /**
  * @tsplus pipeable fncts.schema.AST combineAnnotations
  * @tsplus location "@fncts/schema/AST"
@@ -538,8 +545,14 @@ export declare function getSearchTree(members: Vector<AST>, isDecoding: boolean)
             buckets: {
                 [literal: string]: ReadonlyArray<AST>;
             };
+            literals: ReadonlyArray<Literal>;
             ast: AST;
         };
     };
     otherwise: ReadonlyArray<AST>;
 };
+/**
+ * @tsplus pipeable fncts.schema.AST getFormattedExpected
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function getFormattedExpected(verbose?: boolean): (self: AST) => Maybe<string>;

package/ASTAnnotation.d.ts

@@ -1,7 +1,9 @@
 import { Hashable } from "@fncts/base/data/Hashable";
 import { Equatable } from "@fncts/base/data/Equatable";
 import { Tag } from "@fncts/base/data/Tag/definition";
+import { ParseError } from "@fncts/schema/ParseError";
 import { Vector } from "@fncts/base/collection/immutable/Vector";
+import { AST } from "@fncts/schema/AST";
 import type { Validation } from "@fncts/base/data/Branded";
 export declare const ASTAnnotationVariance: unique symbol;
 export type ASTAnnotationVariance = typeof ASTAnnotationVariance;
@@ -42,12 +44,12 @@ export declare const DescriptionTag: import("@fncts/base/data/Tag").Tag<string,
  * @tsplus location "@fncts/schema/ASTAnnotation"
  */
 export declare const Description: ASTAnnotation<string>;
-export declare const MessageTag: import("@fncts/base/data/Tag").Tag<(_: unknown) => string, (_: unknown) => string>;
+export declare const MessageTag: import("@fncts/base/data/Tag").Tag<(error: ParseError) => string, (error: ParseError) => string>;
 /**
  * @tsplus static fncts.schema.ASTAnnotationOps Message
  * @tsplus location "@fncts/schema/ASTAnnotation"
  */
-export declare const Message: ASTAnnotation<(_: unknown) => string>;
+export declare const Message: ASTAnnotation<(error: ParseError) => string>;
 export declare const BrandTag: import("@fncts/base/data/Tag").Tag<import("@fncts/base/collection/immutable/Vector").Vector<Validation<any, any>>, import("@fncts/base/collection/immutable/Vector").Vector<Validation<any, any>>>;
 /**
  * @tsplus static fncts.schema.ASTAnnotationOps Brand
@@ -66,6 +68,12 @@ export declare const ParseOptionalTag: import("@fncts/base/data/Tag").Tag<boolea
  * @tsplus location "@fncts/schema/ASTAnnotation"
  */
 export declare const ParseOptional: ASTAnnotation<boolean>;
+export declare const SurrogateTag: import("@fncts/base/data/Tag").Tag<import("./AST").AST, import("./AST").AST>;
+/**
+ * @tsplus static fncts.schema.ASTAnnotationOps Surrogate
+ * @tsplus location "@fncts/schema/ASTAnnotation"
+ */
+export declare const Surrogate: ASTAnnotation<import("./AST").AST>;
 export type Hook<A> = (...typeParameters: ReadonlyArray<A>) => A;
 export declare function hook(handler: (...typeParameters: ReadonlyArray<any>) => any): Hook<any>;
 export declare const ParserHookTag: import("@fncts/base/data/Tag").Tag<Hook<any>, Hook<any>>;

package/ParseError/ParseError.d.ts

@@ -0,0 +1,231 @@
+import { AST } from "@fncts/schema/AST";
+import { Vector } from "@fncts/base/collection/immutable/Vector";
+import type { Declaration, Refinement, Transform, Tuple, TypeLiteral, Union } from "@fncts/schema/AST";
+export declare const enum ParseErrorTag {
+    Declaration = 0,
+    Type = 1,
+    Index = 2,
+    Key = 3,
+    Missing = 4,
+    Unexpected = 5,
+    UnionMember = 6,
+    Refinement = 7,
+    Transformation = 8,
+    TypeLiteral = 9,
+    Tuple = 10,
+    Union = 11,
+    Iterable = 12
+}
+/**
+ * @tsplus type fncts.schema.ParseError
+ * @tsplus companion fncts.schema.ParseErrorOps
+ */
+export type ParseError = DeclarationError | TypeError | RefinementError | TransformationError | TypeLiteralError | TupleError | UnionError | IterableError;
+/**
+ * @tsplus companion fncts.schema.ParseError.DeclarationError
+ */
+export declare class DeclarationError {
+    readonly ast: Declaration;
+    readonly actual: unknown;
+    readonly error: ParseError;
+    readonly _tag = ParseErrorTag.Declaration;
+    constructor(ast: Declaration, actual: unknown, error: ParseError);
+}
+/**
+ * @tsplus static fncts.schema.ParseError.DeclarationError __call
+ * @tsplus static fncts.schema.ParseErrorOps DeclarationError
+ * @tsplus location "@fncts/schema/ParseError/ParseError"
+ */
+export declare function declarationError(ast: Declaration, actual: unknown, error: ParseError): DeclarationError;
+/**
+ * @tsplus companion fncts.schema.ParseError.TypeError
+ */
+export declare class TypeError {
+    readonly ast: AST;
+    readonly actual: unknown;
+    readonly _tag = ParseErrorTag.Type;
+    constructor(ast: AST, actual: unknown);
+}
+/**
+ * @tsplus static fncts.schema.ParseError.TypeError __call
+ * @tsplus static fncts.schema.ParseErrorOps TypeError
+ * @tsplus location "@fncts/schema/ParseError/ParseError"
+ */
+export declare function typeError(expected: AST, actual: unknown): TypeError;
+/**
+ * @tsplus companion fncts.schema.ParseError.TypeLiteralError
+ */
+export declare class TypeLiteralError {
+    readonly ast: TypeLiteral;
+    readonly actual: unknown;
+    readonly errors: Vector<KeyError>;
+    readonly output: {
+        readonly [x: string]: unknown;
+    };
+    readonly _tag = ParseErrorTag.TypeLiteral;
+    constructor(ast: TypeLiteral, actual: unknown, errors: Vector<KeyError>, output?: {
+        readonly [x: string]: unknown;
+    });
+}
+/**
+ * @tsplus static fncts.schema.ParseError.TypeLiteralError __call
+ * @tsplus static fncts.schema.ParseErrorOps TypeLiteralError
+ * @tsplus location "@fncts/schema/ParseError/ParseError"
+ */
+export declare function typeLiteralError(ast: TypeLiteral, actual: unknown, errors: Vector<KeyError>, output?: {
+    readonly [x: string]: unknown;
+}): TypeLiteralError;
+/**
+ * @tsplus companion fncts.schema.ParseError.TupleError
+ */
+export declare class TupleError {
+    readonly ast: Tuple;
+    readonly actual: unknown;
+    readonly errors: Vector<IndexError>;
+    readonly output: ReadonlyArray<unknown>;
+    readonly _tag = ParseErrorTag.Tuple;
+    constructor(ast: Tuple, actual: unknown, errors: Vector<IndexError>, output?: ReadonlyArray<unknown>);
+}
+/**
+ * @tsplus static fncts.schema.ParseError.TupleError __call
+ * @tsplus static fncts.schema.ParseErrorOps TupleError
+ * @tsplus location "@fncts/schema/ParseError/ParseError"
+ */
+export declare function tupleError(ast: Tuple, actual: unknown, errors: Vector<IndexError>, output?: ReadonlyArray<unknown>): TupleError;
+/**
+ * @tsplus companion fncts.schema.ParseError.IndexError
+ */
+export declare class IndexError {
+    readonly index: number;
+    readonly error: ParseError | MissingError | UnexpectedError;
+    readonly _tag = ParseErrorTag.Index;
+    constructor(index: number, error: ParseError | MissingError | UnexpectedError);
+}
+/**
+ * @tsplus static fncts.schema.ParseError.IndexError __call
+ * @tsplus static fncts.schema.ParseErrorOps IndexError
+ * @tsplus location "@fncts/schema/ParseError/ParseError"
+ */
+export declare function indexError(index: number, error: ParseError | MissingError | UnexpectedError): IndexError;
+/**
+ * @tsplus companion fncts.schema.ParseError.KeyError
+ */
+export declare class KeyError {
+    readonly keyAST: AST;
+    readonly key: any;
+    readonly error: ParseError | MissingError | UnexpectedError;
+    readonly _tag = ParseErrorTag.Key;
+    constructor(keyAST: AST, key: any, error: ParseError | MissingError | UnexpectedError);
+}
+/**
+ * @tsplus static fncts.schema.ParseError.KeyError __call
+ * @tsplus static fncts.schema.ParseErrorOps KeyError
+ * @tsplus location "@fncts/schema/ParseError/ParseError"
+ */
+export declare function keyError(keyAST: AST, key: any, error: ParseError | MissingError | UnexpectedError): KeyError;
+/**
+ * @tsplus companion fncts.schema.ParseError.MissingError
+ */
+export declare class MissingError {
+    readonly _tag = ParseErrorTag.Missing;
+}
+/**
+ * @tsplus static fncts.schema.ParseErrorOps MissingError
+ * @tsplus location "@fncts/schema/ParseError/ParseError"
+ */
+export declare const missingError: MissingError;
+/**
+ * @tsplus companion fncts.schema.ParseError.UnexpectedError
+ */
+export declare class UnexpectedError {
+    readonly actual: unknown;
+    readonly _tag = ParseErrorTag.Unexpected;
+    constructor(actual: unknown);
+}
+/**
+ * @tsplus static fncts.schema.ParseError.UnexpectedError __call
+ * @tsplus static fncts.schema.ParseErrorOps UnexpectedError
+ * @tsplus location "@fncts/schema/ParseError/ParseError"
+ */
+export declare function unexpectedError(actual: unknown): UnexpectedError;
+/**
+ * @tsplus companion fncts.schema.ParseError.UnionError
+ */
+export declare class UnionError {
+    readonly ast: Union;
+    readonly actual: unknown;
+    readonly errors: Vector<TypeError | TypeLiteralError | UnionMemberError>;
+    readonly _tag = ParseErrorTag.Union;
+    constructor(ast: Union, actual: unknown, errors: Vector<TypeError | TypeLiteralError | UnionMemberError>);
+}
+/**
+ * @tsplus static fncts.schema.ParseError.UnionError __call
+ * @tsplus static fncts.schema.ParseErrorOps UnionError
+ * @tsplus location "@fncts/schema/ParseError/ParseError"
+ */
+export declare function unionError(ast: Union, actual: unknown, errors: Vector<TypeError | TypeLiteralError | UnionMemberError>): UnionError;
+/**
+ * @tsplus companion fncts.schema.ParseError.UnionMemberError
+ */
+export declare class UnionMemberError {
+    readonly ast: AST;
+    readonly error: ParseError;
+    readonly _tag = ParseErrorTag.UnionMember;
+    constructor(ast: AST, error: ParseError);
+}
+/**
+ * @tsplus static fncts.schema.ParseError.UnionMemberError __call
+ * @tsplus static fncts.schema.ParseErrorOps UnionMemberError
+ * @tsplus location "@fncts/schema/ParseError/ParseError"
+ */
+export declare function unionMemberError(ast: AST, error: ParseError): UnionMemberError;
+/**
+ * @tsplus companion fncts.schema.ParseError.RefinementError
+ */
+export declare class RefinementError {
+    readonly ast: Refinement;
+    readonly actual: unknown;
+    readonly kind: "From" | "Predicate";
+    readonly error: ParseError;
+    readonly _tag = ParseErrorTag.Refinement;
+    constructor(ast: Refinement, actual: unknown, kind: "From" | "Predicate", error: ParseError);
+}
+/**
+ * @tsplus static fncts.schema.ParseError.RefinementError __call
+ * @tsplus static fncts.schema.ParseErrorOps RefinementError
+ * @tsplus location "@fncts/schema/ParseError/ParseError"
+ */
+export declare function refinementError(ast: Refinement, actual: unknown, kind: "From" | "Predicate", error: ParseError): ParseError;
+/**
+ * @tsplus companion fncts.schema.ParseError.TransformationError
+ */
+export declare class TransformationError {
+    readonly ast: Transform;
+    readonly actual: unknown;
+    readonly kind: "Encoded" | "Transformation" | "Type";
+    readonly error: ParseError;
+    readonly _tag = ParseErrorTag.Transformation;
+    constructor(ast: Transform, actual: unknown, kind: "Encoded" | "Transformation" | "Type", error: ParseError);
+}
+/**
+ * @tsplus static fncts.schema.ParseError.TransformationError __call
+ * @tsplus static fncts.schema.ParseErrorOps TransformationError
+ * @tsplus location "@fncts/schema/ParseError/ParseError"
+ */
+export declare function transformationError(ast: Transform, actual: unknown, kind: "Encoded" | "Transformation" | "Type", error: ParseError): ParseError;
+/**
+ * @tsplus companion fncts.schema.ParseError.IterableError
+ */
+export declare class IterableError {
+    readonly ast: AST;
+    readonly actual: unknown;
+    readonly errors: Vector<IndexError | KeyError>;
+    readonly _tag = ParseErrorTag.Iterable;
+    constructor(ast: AST, actual: unknown, errors: Vector<IndexError | KeyError>);
+}
+/**
+ * @tsplus static fncts.schema.ParseError.IterableError __call
+ * @tsplus static fncts.schema.ParseErrorOps IterableError
+ * @tsplus location "@fncts/schema/ParseError/ParseError"
+ */
+export declare function iterableError(ast: AST, actual: unknown, errors: Vector<IndexError | KeyError>): IterableError;

package/ParseError/ParseErrorFormatter.d.ts

@@ -0,0 +1,2 @@
+import { ParseError } from "@fncts/schema/ParseError";
+export type ParseErrorFormatter = (error: ParseError) => string;

package/ParseError/PathFormatter.d.ts

@@ -0,0 +1,13 @@
+import { ParseError } from "@fncts/schema/ParseError";
+import { Lazy } from "@fncts/base/data/function/definition";
+import { ParseErrorTag } from "./ParseError.js";
+export interface ParseErrorFlat {
+    type: ParseErrorTag;
+    path: Array<string | number | symbol>;
+    message: string;
+}
+/**
+ * @tsplus getter fncts.schema.ParseError flatten
+ * @tsplus location "@fncts/schema/ParseError/PathFormatter"
+ */
+export declare function flatten(error: ParseError): Array<ParseErrorFlat>;

package/ParseError/TreeFormatter.d.ts

@@ -0,0 +1,14 @@
+import { ParseError } from "@fncts/schema/ParseError";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Vector } from "@fncts/base/collection/immutable/Vector";
+import { RoseTree } from "@fncts/base/collection/immutable/RoseTree";
+import { Lazy } from "@fncts/base/data/function/definition";
+import type { TypeError } from "./ParseError";
+/**
+ * @tsplus static fncts.schema.ParseErrorOps drawTree
+ * @tsplus getter fncts.schema.ParseError drawTree
+ * @tsplus location "@fncts/schema/ParseError/TreeFormatter"
+ */
+export declare function format(error: ParseError): string;
+export declare function getMessage(error: ParseError): Maybe<string>;
+export declare function formatTypeError(error: TypeError): string;

package/ParseError.d.ts

@@ -1,144 +1,4 @@
-import { AST } from "@fncts/schema/AST";
-import { Vector } from "@fncts/base/collection/immutable/Vector";
-import { Maybe } from "@fncts/base/data/Maybe/definition";
-import { RoseTree } from "@fncts/base/collection/immutable/RoseTree";
-import type { Refinement, Transform } from "@fncts/schema/AST";
-export declare const enum ParseErrorTag {
-    Type = 0,
-    Index = 1,
-    Key = 2,
-    Missing = 3,
-    Unexpected = 4,
-    UnionMember = 5,
-    Refinement = 6,
-    Transformation = 7
-}
-/**
- * @tsplus type fncts.schema.ParseError
- * @tsplus companion fncts.schema.ParseErrorOps
- */
-export type ParseError = TypeError | IndexError | KeyError | MissingError | UnexpectedError | UnionMemberError | RefinementError | TransformationError;
-/**
- * @tsplus companion fncts.schema.ParseError.TypeError
- */
-export declare class TypeError {
-    readonly expected: AST;
-    readonly actual: unknown;
-    readonly _tag = ParseErrorTag.Type;
-    constructor(expected: AST, actual: unknown);
-}
-/**
- * @tsplus static fncts.schema.ParseError.TypeError __call
- * @tsplus static fncts.schema.ParseErrorOps TypeError
- * @tsplus location "@fncts/schema/ParseError"
- */
-export declare function typeError(expected: AST, actual: unknown): ParseError;
-/**
- * @tsplus companion fncts.schema.ParseError.IndexError
- */
-export declare class IndexError {
-    readonly index: number;
-    readonly errors: Vector<ParseError>;
-    readonly _tag = ParseErrorTag.Index;
-    constructor(index: number, errors: Vector<ParseError>);
-}
-/**
- * @tsplus static fncts.schema.ParseError.IndexError __call
- * @tsplus static fncts.schema.ParseErrorOps IndexError
- * @tsplus location "@fncts/schema/ParseError"
- */
-export declare function indexError(index: number, errors: Vector<ParseError>): ParseError;
-/**
- * @tsplus companion fncts.schema.ParseError.KeyError
- */
-export declare class KeyError {
-    readonly keyAST: AST;
-    readonly key: any;
-    readonly errors: Vector<ParseError>;
-    readonly _tag = ParseErrorTag.Key;
-    constructor(keyAST: AST, key: any, errors: Vector<ParseError>);
-}
-/**
- * @tsplus static fncts.schema.ParseError.KeyError __call
- * @tsplus static fncts.schema.ParseErrorOps KeyError
- * @tsplus location "@fncts/schema/ParseError"
- */
-export declare function keyError(keyAST: AST, key: any, errors: Vector<ParseError>): ParseError;
-/**
- * @tsplus companion fncts.schema.ParseError.MissingError
- */
-export declare class MissingError {
-    readonly _tag = ParseErrorTag.Missing;
-}
-/**
- * @tsplus static fncts.schema.ParseErrorOps MissingError
- * @tsplus location "@fncts/schema/ParseError"
- */
-export declare const missingError: MissingError;
-/**
- * @tsplus companion fncts.schema.ParseError.UnexpectedError
- */
-export declare class UnexpectedError {
-    readonly actual: unknown;
-    readonly _tag = ParseErrorTag.Unexpected;
-    constructor(actual: unknown);
-}
-/**
- * @tsplus static fncts.schema.ParseError.UnexpectedError __call
- * @tsplus static fncts.schema.ParseErrorOps UnexpectedError
- * @tsplus location "@fncts/schema/ParseError"
- */
-export declare function unexpectedError(actual: unknown): ParseError;
-/**
- * @tsplus companion fncts.schema.ParseError.UnionMemberError
- */
-export declare class UnionMemberError {
-    readonly errors: Vector<ParseError>;
-    readonly _tag = ParseErrorTag.UnionMember;
-    constructor(errors: Vector<ParseError>);
-}
-/**
- * @tsplus static fncts.schema.ParseError.UnionMemberError __call
- * @tsplus static fncts.schema.ParseErrorOps UnionMemberError
- * @tsplus location "@fncts/schema/ParseError"
- */
-export declare function unionMemberError(errors: Vector<ParseError>): ParseError;
-/**
- * @tsplus companion fncts.schema.ParseError.RefinementError
- */
-export declare class RefinementError {
-    readonly ast: Refinement;
-    readonly actual: unknown;
-    readonly kind: "From" | "Predicate";
-    readonly errors: Vector<ParseError>;
-    readonly _tag = ParseErrorTag.Refinement;
-    constructor(ast: Refinement, actual: unknown, kind: "From" | "Predicate", errors: Vector<ParseError>);
-}
-/**
- * @tsplus static fncts.schema.ParseError.RefinementError __call
- * @tsplus static fncts.schema.ParseErrorOps RefinementError
- * @tsplus location "@fncts/schema/ParseError"
- */
-export declare function refinementError(ast: Refinement, actual: unknown, kind: "From" | "Predicate", errors: Vector<ParseError>): ParseError;
-/**
- * @tsplus companion fncts.schema.ParseError.TransformationError
- */
-export declare class TransformationError {
-    readonly ast: Transform;
-    readonly actual: unknown;
-    readonly kind: "Encoded" | "Transformation" | "Type";
-    readonly errors: Vector<ParseError>;
-    readonly _tag = ParseErrorTag.Transformation;
-    constructor(ast: Transform, actual: unknown, kind: "Encoded" | "Transformation" | "Type", errors: Vector<ParseError>);
-}
-/**
- * @tsplus static fncts.schema.ParseError.TransformationError __call
- * @tsplus static fncts.schema.ParseErrorOps TransformationError
- * @tsplus location "@fncts/schema/ParseError"
- */
-export declare function transformationError(ast: Transform, actual: unknown, kind: "Encoded" | "Transformation" | "Type", errors: Vector<ParseError>): ParseError;
-/**
- * @tsplus static fncts.schema.ParseErrorOps format
- * @tsplus location "@fncts/schema/ParseError"
- */
-export declare function format(errors: Vector<ParseError>): string;
+export * from "./ParseError/TreeFormatter.js";
+export * from "./ParseError/PathFormatter.js";
+export * from "./ParseError/ParseErrorFormatter.js";
+export * from "./ParseError/ParseError.js";

package/ParseResult.d.ts

@@ -1,23 +1,16 @@
 import { Either } from "@fncts/base/data/Either/definition";
-import { ParseFailure } from "@fncts/schema/ParseFailure";
-import { Vector } from "@fncts/base/collection/immutable/Vector";
 import { ParseError } from "@fncts/schema/ParseError";
 /**
  * @tsplus type fncts.schema.ParseResult
  * @tsplus companion fncts.schema.ParseResultOps
  */
-export interface ParseResult<A> extends Either<ParseFailure, A> {
+export interface ParseResult<A> extends Either<ParseError, A> {
 }
 /**
  * @tsplus static fncts.schema.ParseResultOps succeed
  * @tsplus location "@fncts/schema/ParseResult"
  */
 export declare function succeed<A>(value: A): ParseResult<A>;
-/**
- * @tsplus static fncts.schema.ParseResultOps failures
- * @tsplus location "@fncts/schema/ParseResult"
- */
-export declare function failures<A = never>(value: Vector<ParseError>): ParseResult<A>;
 /**
  * @tsplus static fncts.schema.ParseResultOps fail
  * @tsplus location "@fncts/schema/ParseResult"

package/Parser/interpreter.d.ts

@@ -1,5 +1,4 @@
 import { AST } from "@fncts/schema/AST";
 import { Parser } from "@fncts/schema/Parser/definition";
-import { ParseError } from "@fncts/schema/ParseError";
 import { ParseResult } from "@fncts/schema/ParseResult";
 export declare function parserFor(ast: AST, isDecoding: boolean): Parser<any>;

package/Schema/api/conc.d.ts

@@ -2,7 +2,6 @@ import { Schema } from "@fncts/schema/Schema/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
 import { Check } from "@fncts/typelevel";
 import { Parser } from "@fncts/schema/Parser/definition";
-import { ParseError } from "@fncts/schema/ParseError";
 import { Gen } from "@fncts/test/control/Gen";
 export declare function conc<A>(value: Schema<A>): Schema<Conc<A>>;
 /**
@@ -15,4 +14,3 @@ export declare function concFromArray<A>(value: Schema<A>): Schema<Conc<A>>;
  * @tsplus location "@fncts/schema/Schema/api/conc"
  */
 export declare function deriveConc<A extends Conc<any>>(...[value]: [A] extends [Conc<infer _A>] ? Check<Check.IsEqual<A, Conc<_A>>> extends Check.True ? [value: Schema<_A>] : never : never): Schema<A>;
-export declare function concParser<A>(value: Schema<A>): Parser<Conc<A>>;

package/Schema/api/hashMap.d.ts

@@ -1,6 +1,5 @@
 import { Schema } from "@fncts/schema/Schema/definition";
 import { Parser } from "@fncts/schema/Parser/definition";
-import { ParseError } from "@fncts/schema/ParseError";
 import { Gen } from "@fncts/test/control/Gen";
 import type { Check } from "@fncts/typelevel";
 import { HashMap } from "@fncts/base/collection/immutable/HashMap";

package/Schema/api/hashSet.d.ts

@@ -2,7 +2,6 @@ import { Schema } from "@fncts/schema/Schema/definition";
 import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
 import { Check } from "@fncts/typelevel";
 import { Parser } from "@fncts/schema/Parser/definition";
-import { ParseError } from "@fncts/schema/ParseError";
 import { Gen } from "@fncts/test/control/Gen";
 export declare function hashSet<A>(value: Schema<A>): Schema<HashSet<A>>;
 /**

package/Schema/api/immutableArray.d.ts

@@ -1,7 +1,6 @@
 import { Schema } from "@fncts/schema/Schema/definition";
 import { Check } from "@fncts/typelevel";
 import { Parser } from "@fncts/schema/Parser/definition";
-import { ParseError } from "@fncts/schema/ParseError";
 import { Gen } from "@fncts/test/control/Gen";
 import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray";
 /**

package/Schema/api/list.d.ts

@@ -1,8 +1,7 @@
 import { Schema } from "@fncts/schema/Schema/definition";
-import { List, Nil, Cons } from "@fncts/base/collection/immutable/List/definition";
+import { List } from "@fncts/base/collection/immutable/List/definition";
 import { Check } from "@fncts/typelevel";
 import { Parser } from "@fncts/schema/Parser/definition";
-import { ParseError } from "@fncts/schema/ParseError";
 import { Gen } from "@fncts/test/control/Gen";
 /**
  * @tsplus static fncts.schema.SchemaOps list

package/Schema/api/map.d.ts

@@ -0,0 +1,19 @@
+import { Schema } from "@fncts/schema/Schema/definition";
+import { Check } from "@fncts/typelevel";
+import { Parser } from "@fncts/schema/Parser/definition";
+import { Gen } from "@fncts/test/control/Gen";
+/**
+ * @tsplus static fncts.schema.SchemaOps map
+ * @tsplus location "@fncts/schema/Schema/api/map"
+ */
+export declare function map<K, V>(key: Schema<K>, value: Schema<V>): Schema<Map<K, V>>;
+/**
+ * @tsplus static fncts.schema.SchemaOps mapFromRecord
+ * @tsplus location "@fncts/schema/Schema/api/map"
+ */
+export declare function mapFromRecord<K extends string | symbol, V>(key: Schema<K>, value: Schema<V>): Schema<Map<K, V>>;
+/**
+ * @tsplus derive fncts.schema.Schema[fncts.Map]<_> 10
+ * @tsplus location "@fncts/schema/Schema/api/map"
+ */
+export declare function deriveMap<A extends Map<any, any>>(...[key, value]: [A] extends [Map<infer K, infer V>] ? Check<Check.IsEqual<A, Map<K, V>> & Check.Extends<K, string | symbol>> extends Check.True ? [key: Schema<K>, value: Schema<V>] : never : never): Schema<A>;