@fncts/schema 0.0.23 → 0.0.24

package/AST.d.ts

@@ -1,8 +1,10 @@
+import { Equatable } from "@fncts/base/data/Equatable";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Vector } from "@fncts/base/collection/immutable/Vector";
 import { ParseResult } from "@fncts/schema/ParseResult";
 import { ParseError } from "@fncts/schema/ParseError";
 import type { Validation as ValidationType } from "@fncts/base/data/Branded";
+import type { EqualsContext } from "@fncts/base/data/Equatable";
 import { ASTAnnotation } from "./ASTAnnotation.js";
 import { ASTAnnotationMap } from "./ASTAnnotationMap.js";
 export declare const ASTTypeId: unique symbol;
@@ -14,9 +16,10 @@ export declare abstract class Annotated {
  * @tsplus type fncts.schema.AST
  * @tsplus companion fncts.schema.ASTOps
  */
-export declare abstract class AST extends Annotated {
+export declare abstract class AST extends Annotated implements Equatable {
     readonly [ASTTypeId]: ASTTypeId;
     abstract clone(newProperties: Partial<this>): AST;
+    abstract [Symbol.equals](that: unknown, context: EqualsContext): boolean;
     toString(verbose?: boolean): string;
 }
 export declare namespace AST {
@@ -61,11 +64,12 @@ export type Concrete = Declaration | Literal | UniqueSymbol | UndefinedKeyword |
  * @tsplus location "@fncts/schema/AST"
  */
 export declare function concrete(_: AST): asserts _ is Concrete;
+export declare function isAST(u: unknown): u is AST;
 export declare function getAnnotations<V>(key: ASTAnnotation<V>): (self: Annotated) => Maybe<V>;
 /**
  * @tsplus type fncts.schema.AST.Declaration
  */
-export declare class Declaration extends AST {
+export declare class Declaration extends AST implements Equatable {
     readonly typeParameters: Vector<AST>;
     readonly decode: (...typeParameters: ReadonlyArray<AST>) => (input: any, options?: ParseOptions) => ParseResult<any>;
     readonly encode: (...typeParameters: ReadonlyArray<AST>) => (input: any, options?: ParseOptions) => ParseResult<any>;
@@ -73,6 +77,7 @@ export declare class Declaration extends AST {
     readonly _tag = ASTTag.Declaration;
     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;
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ASTOps createDeclaration
@@ -85,12 +90,13 @@ export declare function createDeclaration(typeParameters: Vector<AST>, decode: (
  */
 export declare function isDeclaration(self: AST): self is Declaration;
 export type LiteralValue = string | number | boolean | null | bigint;
-export declare class Literal extends AST {
+export declare class Literal extends AST implements Equatable {
     readonly literal: LiteralValue;
     readonly annotations: ASTAnnotationMap;
     readonly _tag = ASTTag.Literal;
     constructor(literal: LiteralValue, annotations?: ASTAnnotationMap);
     clone(newProperties: Partial<this>): AST;
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ASTOps createLiteral
@@ -102,12 +108,13 @@ export declare function createLiteral(literal: LiteralValue, annotations?: ASTAn
  * @tsplus location "@fncts/schema/AST"
  */
 export declare function isLiteral(self: AST): self is Literal;
-export declare class UniqueSymbol extends AST {
+export declare class UniqueSymbol extends AST implements Equatable {
     readonly symbol: symbol;
     readonly annotations: ASTAnnotationMap;
     readonly _tag = ASTTag.UniqueSymbol;
     constructor(symbol: symbol, annotations?: ASTAnnotationMap);
     clone(newProperties: Partial<this>): AST;
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ASTOps createUniqueSymbol
@@ -119,66 +126,72 @@ export declare function createUniqueSymbol(symbol: symbol, annotations?: ASTAnno
  * @tsplus location "@fncts/schema/AST"
  */
 export declare function isUniqueSymbol(self: AST): self is UniqueSymbol;
-export declare class UndefinedKeyword extends AST {
+export declare class UndefinedKeyword extends AST implements Equatable {
     readonly annotations: ASTAnnotationMap;
     readonly _tag = ASTTag.UndefinedKeyword;
     constructor(annotations?: ASTAnnotationMap);
     clone(newProperties: Partial<this>): AST;
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ASTOps undefinedKeyword
  * @tsplus location "@fncts/schema/AST"
  */
 export declare const undefinedKeyword: UndefinedKeyword;
-export declare class VoidKeyword extends AST {
+export declare class VoidKeyword extends AST implements Equatable {
     readonly annotations: ASTAnnotationMap;
     readonly _tag = ASTTag.VoidKeyword;
     constructor(annotations?: ASTAnnotationMap);
     clone(newProperties: Partial<this>): AST;
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ASTOps voidKeyword
  * @tsplus location "@fncts/schema/AST"
  */
 export declare const voidKeyword: VoidKeyword;
-export declare class NeverKeyword extends AST {
+export declare class NeverKeyword extends AST implements Equatable {
     readonly annotations: ASTAnnotationMap;
     readonly _tag = ASTTag.NeverKeyword;
     constructor(annotations?: ASTAnnotationMap);
     clone(newProperties: Partial<this>): AST;
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ASTOps neverKeyword
  * @tsplus location "@fncts/schema/AST"
  */
 export declare const neverKeyword: NeverKeyword;
-export declare class UnknownKeyword extends AST {
+export declare class UnknownKeyword extends AST implements Equatable {
     readonly annotations: ASTAnnotationMap;
     readonly _tag = ASTTag.UnknownKeyword;
     constructor(annotations?: ASTAnnotationMap);
     clone(newProperties: Partial<this>): AST;
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ASTOps unknownKeyword
  * @tsplus location "@fncts/schema/AST"
  */
 export declare const unknownKeyword: UnknownKeyword;
-export declare class AnyKeyword extends AST {
+export declare class AnyKeyword extends AST implements Equatable {
     readonly annotations: ASTAnnotationMap;
     readonly _tag = ASTTag.AnyKeyword;
     constructor(annotations?: ASTAnnotationMap);
     clone(newProperties: Partial<this>): AST;
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ASTOps anyKeyword
  * @tsplus location "@fncts/schema/AST"
  */
 export declare const anyKeyword: AnyKeyword;
-export declare class StringKeyword extends AST {
+export declare class StringKeyword extends AST implements Equatable {
     readonly annotations: ASTAnnotationMap;
     readonly _tag = ASTTag.StringKeyword;
     constructor(annotations?: ASTAnnotationMap);
     clone(newProperties: Partial<this>): AST;
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ASTOps stringKeyword
@@ -190,11 +203,12 @@ export declare const stringKeyword: StringKeyword;
  * @tsplus location "@fncts/schema/AST"
  */
 export declare function isStringKeyword(self: AST): self is StringKeyword;
-export declare class NumberKeyword extends AST {
+export declare class NumberKeyword extends AST implements Equatable {
     readonly annotations: ASTAnnotationMap;
     readonly _tag = ASTTag.NumberKeyword;
     constructor(annotations?: ASTAnnotationMap);
     clone(newProperties: Partial<this>): AST;
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ASTOps numberKeyword
@@ -206,11 +220,12 @@ export declare const numberKeyword: NumberKeyword;
  * @tsplus location "@fncts/schema/AST"
  */
 export declare function isNumberKeyword(self: AST): self is NumberKeyword;
-export declare class BooleanKeyword extends AST {
+export declare class BooleanKeyword extends AST implements Equatable {
     readonly annotations: ASTAnnotationMap;
     readonly _tag = ASTTag.BooleanKeyword;
     constructor(annotations?: ASTAnnotationMap);
     clone(newProperties: Partial<this>): AST;
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ASTOps booleanKeyword
@@ -222,11 +237,12 @@ export declare const booleanKeyword: BooleanKeyword;
  * @tsplus location "@fncts/schema/AST"
  */
 export declare function isBooleanKeyword(self: AST): self is BooleanKeyword;
-export declare class BigIntKeyword extends AST {
+export declare class BigIntKeyword extends AST implements Equatable {
     readonly annotations: ASTAnnotationMap;
     readonly _tag = ASTTag.BigIntKeyword;
     constructor(annotations?: ASTAnnotationMap);
     clone(newProperties: Partial<this>): AST;
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ASTOps bigIntKeyword
@@ -238,11 +254,12 @@ export declare const bigIntKeyword: BigIntKeyword;
  * @tsplus location "@fncts/schema/AST"
  */
 export declare function isBigIntKeyword(self: AST): self is BigIntKeyword;
-export declare class SymbolKeyword extends AST {
+export declare class SymbolKeyword extends AST implements Equatable {
     readonly annotations: ASTAnnotationMap;
     readonly _tag = ASTTag.SymbolKeyword;
     constructor(annotations?: ASTAnnotationMap);
     clone(newProperties: Partial<this>): AST;
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ASTOps symbolKeyword
@@ -254,52 +271,57 @@ export declare const symbolKeyword: SymbolKeyword;
  * @tsplus location "@fncts/schema/AST"
  */
 export declare function isSymbolKeyword(self: AST): self is SymbolKeyword;
-export declare class ObjectKeyword extends AST {
+export declare class ObjectKeyword extends AST implements Equatable {
     readonly annotations: ASTAnnotationMap;
     readonly _tag = ASTTag.ObjectKeyword;
     constructor(annotations?: ASTAnnotationMap);
     clone(newProperties: Partial<this>): AST;
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ASTOps objectKeyword
  * @tsplus location "@fncts/schema/AST"
  */
 export declare const objectKeyword: ObjectKeyword;
-export declare class Enum extends AST {
+export declare class Enum extends AST implements Equatable {
     readonly enums: Vector<readonly [string, string | number]>;
     readonly annotations: ASTAnnotationMap;
     readonly _tag = ASTTag.Enum;
     constructor(enums: Vector<readonly [string, string | number]>, annotations?: ASTAnnotationMap);
     clone(newProperties: Partial<this>): AST;
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ASTOps createEnum
  * @tsplus location "@fncts/schema/AST"
  */
 export declare function createEnum(enums: Vector<readonly [string, string | number]>, annotations?: ASTAnnotationMap): Enum;
-export declare class TemplateLiteralSpan {
+export declare class TemplateLiteralSpan implements Equatable {
     readonly type: StringKeyword | NumberKeyword;
     readonly literal: string;
     constructor(type: StringKeyword | NumberKeyword, literal: string);
-    toString(): "${string}" | "${number}";
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
+    toString(): "${number}" | "${string}";
 }
-export declare class TemplateLiteral extends AST {
+export declare class TemplateLiteral extends AST implements Equatable {
     readonly head: string;
     readonly spans: Vector<TemplateLiteralSpan>;
     readonly annotations: ASTAnnotationMap;
     readonly _tag = ASTTag.TemplateLiteral;
     constructor(head: string, spans: Vector<TemplateLiteralSpan>, annotations?: ASTAnnotationMap);
     clone(newProperties: Partial<this>): AST;
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ASTOps createTemplateLiteral
  * @tsplus location "@fncts/schema/AST"
  */
 export declare function createTemplateLiteral(head: string, spans: Vector<TemplateLiteralSpan>, annotations?: ASTAnnotationMap): TemplateLiteral | Literal;
-export declare class Element {
+export declare class Element implements Equatable {
     readonly type: AST;
     readonly isOptional: boolean;
     constructor(type: AST, isOptional: boolean);
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
     toString(): string;
 }
 /**
@@ -307,7 +329,7 @@ export declare class Element {
  * @tsplus location "@fncts/schema/AST"
  */
 export declare function createElement(type: AST, isOptional: boolean): Element;
-export declare class Tuple extends AST {
+export declare class Tuple extends AST implements Equatable {
     readonly elements: Vector<Element>;
     readonly rest: Maybe<Vector<AST>>;
     readonly isReadonly: boolean;
@@ -315,6 +337,7 @@ export declare class Tuple extends AST {
     readonly _tag = ASTTag.Tuple;
     constructor(elements: Vector<Element>, rest: Maybe<Vector<AST>>, isReadonly: boolean, annotations?: ASTAnnotationMap);
     clone(newProperties: Partial<this>): AST;
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ASTOps createTuple
@@ -326,7 +349,7 @@ export declare function createTuple(elements: Vector<Element>, rest: Maybe<Vecto
  * @tsplus location "@fncts/schema/AST"
  */
 export declare const unknownArray: Tuple;
-export declare class PropertySignature {
+export declare class PropertySignature implements Equatable {
     readonly name: PropertyKey;
     readonly type: AST;
     readonly isOptional: boolean;
@@ -334,30 +357,33 @@ export declare class PropertySignature {
     readonly annotations: ASTAnnotationMap;
     constructor(name: PropertyKey, type: AST, isOptional: boolean, isReadonly: boolean, annotations?: ASTAnnotationMap);
     clone(newProperties: Partial<this>): PropertySignature;
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ASTOps createPropertySignature
  * @tsplus location "@fncts/schema/AST"
  */
 export declare function createPropertySignature(name: PropertyKey, type: AST, isOptional: boolean, isReadonly: boolean, annotations?: ASTAnnotationMap): PropertySignature;
-export declare class IndexSignature {
+export declare class IndexSignature implements Equatable {
     readonly parameter: StringKeyword | SymbolKeyword | TemplateLiteral | NumberKeyword | Refinement;
     readonly type: AST;
     readonly isReadonly: boolean;
     constructor(parameter: StringKeyword | SymbolKeyword | TemplateLiteral | NumberKeyword | Refinement, type: AST, isReadonly: boolean);
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ASTOps createIndexSignature
  * @tsplus location "@fncts/schema/AST"
  */
 export declare function createIndexSignature(parameter: StringKeyword | SymbolKeyword | TemplateLiteral | NumberKeyword | Refinement, type: AST, isReadonly: boolean): IndexSignature;
-export declare class TypeLiteral extends AST {
+export declare class TypeLiteral extends AST implements Equatable {
     readonly annotations: ASTAnnotationMap;
     readonly _tag = ASTTag.TypeLiteral;
     readonly propertySignatures: Vector<PropertySignature>;
     readonly indexSignatures: Vector<IndexSignature>;
     constructor(propertySignatures: Vector<PropertySignature>, indexSignatures: Vector<IndexSignature>, annotations?: ASTAnnotationMap);
     clone(newProperties: Partial<this>): AST;
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ASTOps isTypeLiteral
@@ -375,12 +401,13 @@ export declare function createTypeLiteral(propertySignatures: Vector<PropertySig
  * @tsplus location "@fncts/schema/AST"
  */
 export declare const unknownRecord: TypeLiteral;
-export declare class Union extends AST {
+export declare class Union extends AST implements Equatable {
     readonly types: Vector<AST>;
     readonly annotations: ASTAnnotationMap;
     readonly _tag = ASTTag.Union;
     constructor(types: Vector<AST>, annotations?: ASTAnnotationMap);
     clone(newProperties: Partial<this>): AST;
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus fluent fncts.schema.AST isUnion
@@ -392,12 +419,13 @@ export declare function isUnion(self: AST): self is Union;
  * @tsplus location "@fncts/schema/AST"
  */
 export declare function createUnion(candidates: Vector<AST>, annotations?: ASTAnnotationMap): AST;
-export declare class Lazy extends AST {
+export declare class Lazy extends AST implements Equatable {
     readonly getAST: () => AST;
     readonly annotations: ASTAnnotationMap;
     readonly _tag = ASTTag.Lazy;
     constructor(getAST: () => AST, annotations?: ASTAnnotationMap);
     clone(newProperties: Partial<this>): AST;
+    [Symbol.equals](that: unknown): boolean;
 }
 /**
  * @tsplus static fncts.schema.ASTOps createLazy
@@ -409,7 +437,7 @@ export declare function createLazy(getAST: () => AST, annotations?: ASTAnnotatio
  * @tsplus location "@fncts/schema/AST"
  */
 export declare function isLazy(self: AST): self is Lazy;
-export declare class Refinement extends AST {
+export declare class Refinement extends AST implements Equatable {
     readonly from: AST;
     readonly predicate: (input: any) => boolean;
     readonly annotations: ASTAnnotationMap;
@@ -417,6 +445,7 @@ export declare class Refinement extends AST {
     constructor(from: AST, predicate: (input: any) => boolean, annotations?: ASTAnnotationMap);
     decode(input: any, options?: ParseOptions): ParseResult<any>;
     clone(newProperties: Partial<this>): AST;
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ASTOps createRefinement
@@ -428,7 +457,7 @@ export interface ParseOptions {
     readonly isUnexpectedAllowed?: boolean;
     readonly allErrors?: boolean;
 }
-export declare class Transform extends AST {
+export declare class Transform extends AST implements Equatable {
     readonly from: AST;
     readonly to: AST;
     readonly decode: (input: any, options?: ParseOptions) => ParseResult<any>;
@@ -437,19 +466,21 @@ export declare class Transform extends AST {
     readonly _tag = ASTTag.Transform;
     constructor(from: AST, to: AST, decode: (input: any, options?: ParseOptions) => ParseResult<any>, encode: (input: any, options?: ParseOptions) => ParseResult<any>, annotations?: ASTAnnotationMap);
     clone(newProperties: Partial<this>): AST;
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ASTOps createTransform
  * @tsplus location "@fncts/schema/AST"
  */
 export declare function createTransform(from: AST, to: AST, decode: (input: any, options?: ParseOptions) => ParseResult<any>, encode: (input: any, options?: ParseOptions) => ParseResult<any>, annotations?: ASTAnnotationMap): Transform;
-export declare class Validation extends AST {
+export declare class Validation extends AST implements Equatable {
     readonly from: AST;
     readonly validation: Vector<ValidationType<any, string>>;
     readonly annotations: ASTAnnotationMap;
     readonly _tag = ASTTag.Validation;
     constructor(from: AST, validation: Vector<ValidationType<any, string>>, annotations?: ASTAnnotationMap);
     clone(newProperties: Partial<this>): AST;
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ASTOps createValidation

package/ASTAnnotationMap.d.ts

@@ -1,10 +1,13 @@
+import { Equatable } from "@fncts/base/data/Equatable";
 import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import type { ASTAnnotation } from "./ASTAnnotation.js";
-export declare class ASTAnnotationMap {
+import type { EqualsContext } from "@fncts/base/data/Equatable";
+export declare class ASTAnnotationMap implements Equatable {
     readonly map: HashMap<ASTAnnotation<any>, any>;
     constructor(map: HashMap<ASTAnnotation<any>, any>);
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
     combine(that: ASTAnnotationMap): ASTAnnotationMap;
     get<V>(key: ASTAnnotation<V>): Maybe<V>;
     private overwrite;

package/ParseError/ParseError.d.ts

@@ -1,5 +1,7 @@
+import { Equatable } from "@fncts/base/data/Equatable";
 import { AST } from "@fncts/schema/AST";
 import { Vector } from "@fncts/base/collection/immutable/Vector";
+import type { EqualsContext } from "@fncts/base/data/Equatable";
 import type { Declaration, Refinement, Transform, Tuple, TypeLiteral, Union } from "@fncts/schema/AST";
 export declare const enum ParseErrorTag {
     Declaration = 0,
@@ -24,12 +26,13 @@ export type ParseError = DeclarationError | TypeError | RefinementError | Transf
 /**
  * @tsplus companion fncts.schema.ParseError.DeclarationError
  */
-export declare class DeclarationError {
+export declare class DeclarationError implements Equatable {
     readonly ast: Declaration;
     readonly actual: unknown;
     readonly error: ParseError;
     readonly _tag = ParseErrorTag.Declaration;
     constructor(ast: Declaration, actual: unknown, error: ParseError);
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ParseError.DeclarationError __call
@@ -40,11 +43,12 @@ export declare function declarationError(ast: Declaration, actual: unknown, erro
 /**
  * @tsplus companion fncts.schema.ParseError.TypeError
  */
-export declare class TypeError {
+export declare class TypeError implements Equatable {
     readonly ast: AST;
     readonly actual: unknown;
     readonly _tag = ParseErrorTag.Type;
     constructor(ast: AST, actual: unknown);
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ParseError.TypeError __call
@@ -55,7 +59,7 @@ export declare function typeError(expected: AST, actual: unknown): TypeError;
 /**
  * @tsplus companion fncts.schema.ParseError.TypeLiteralError
  */
-export declare class TypeLiteralError {
+export declare class TypeLiteralError implements Equatable {
     readonly ast: TypeLiteral;
     readonly actual: unknown;
     readonly errors: Vector<KeyError>;
@@ -66,6 +70,7 @@ export declare class TypeLiteralError {
     constructor(ast: TypeLiteral, actual: unknown, errors: Vector<KeyError>, output?: {
         readonly [x: string]: unknown;
     });
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ParseError.TypeLiteralError __call
@@ -78,13 +83,14 @@ export declare function typeLiteralError(ast: TypeLiteral, actual: unknown, erro
 /**
  * @tsplus companion fncts.schema.ParseError.TupleError
  */
-export declare class TupleError {
+export declare class TupleError implements Equatable {
     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>);
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ParseError.TupleError __call
@@ -95,11 +101,12 @@ export declare function tupleError(ast: Tuple, actual: unknown, errors: Vector<I
 /**
  * @tsplus companion fncts.schema.ParseError.IndexError
  */
-export declare class IndexError {
+export declare class IndexError implements Equatable {
     readonly index: number;
     readonly error: ParseError | MissingError | UnexpectedError;
     readonly _tag = ParseErrorTag.Index;
     constructor(index: number, error: ParseError | MissingError | UnexpectedError);
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ParseError.IndexError __call
@@ -110,12 +117,13 @@ export declare function indexError(index: number, error: ParseError | MissingErr
 /**
  * @tsplus companion fncts.schema.ParseError.KeyError
  */
-export declare class KeyError {
+export declare class KeyError implements Equatable {
     readonly keyAST: AST;
     readonly key: any;
     readonly error: ParseError | MissingError | UnexpectedError;
     readonly _tag = ParseErrorTag.Key;
     constructor(keyAST: AST, key: any, error: ParseError | MissingError | UnexpectedError);
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ParseError.KeyError __call
@@ -126,8 +134,9 @@ export declare function keyError(keyAST: AST, key: any, error: ParseError | Miss
 /**
  * @tsplus companion fncts.schema.ParseError.MissingError
  */
-export declare class MissingError {
+export declare class MissingError implements Equatable {
     readonly _tag = ParseErrorTag.Missing;
+    [Symbol.equals](that: unknown): boolean;
 }
 /**
  * @tsplus static fncts.schema.ParseErrorOps MissingError
@@ -137,10 +146,11 @@ export declare const missingError: MissingError;
 /**
  * @tsplus companion fncts.schema.ParseError.UnexpectedError
  */
-export declare class UnexpectedError {
+export declare class UnexpectedError implements Equatable {
     readonly actual: unknown;
     readonly _tag = ParseErrorTag.Unexpected;
     constructor(actual: unknown);
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ParseError.UnexpectedError __call
@@ -151,12 +161,13 @@ export declare function unexpectedError(actual: unknown): UnexpectedError;
 /**
  * @tsplus companion fncts.schema.ParseError.UnionError
  */
-export declare class UnionError {
+export declare class UnionError implements Equatable {
     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>);
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ParseError.UnionError __call
@@ -167,11 +178,12 @@ export declare function unionError(ast: Union, actual: unknown, errors: Vector<T
 /**
  * @tsplus companion fncts.schema.ParseError.UnionMemberError
  */
-export declare class UnionMemberError {
+export declare class UnionMemberError implements Equatable {
     readonly ast: AST;
     readonly error: ParseError;
     readonly _tag = ParseErrorTag.UnionMember;
     constructor(ast: AST, error: ParseError);
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ParseError.UnionMemberError __call
@@ -182,13 +194,14 @@ export declare function unionMemberError(ast: AST, error: ParseError): UnionMemb
 /**
  * @tsplus companion fncts.schema.ParseError.RefinementError
  */
-export declare class RefinementError {
+export declare class RefinementError implements Equatable {
     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);
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ParseError.RefinementError __call
@@ -199,13 +212,14 @@ export declare function refinementError(ast: Refinement, actual: unknown, kind:
 /**
  * @tsplus companion fncts.schema.ParseError.TransformationError
  */
-export declare class TransformationError {
+export declare class TransformationError implements Equatable {
     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);
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ParseError.TransformationError __call
@@ -216,12 +230,13 @@ export declare function transformationError(ast: Transform, actual: unknown, kin
 /**
  * @tsplus companion fncts.schema.ParseError.IterableError
  */
-export declare class IterableError {
+export declare class IterableError implements Equatable {
     readonly ast: AST;
     readonly actual: unknown;
     readonly errors: Vector<IndexError | KeyError>;
     readonly _tag = ParseErrorTag.Iterable;
     constructor(ast: AST, actual: unknown, errors: Vector<IndexError | KeyError>);
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.schema.ParseError.IterableError __call