@fncts/schema 0.0.5 → 0.0.6

package/AST.d.ts

@@ -0,0 +1,528 @@
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Vector } from "@fncts/base/collection/immutable/Vector";
+import { ParseResult } from "@fncts/schema/ParseResult";
+import type { Validation as ValidationType } from "@fncts/base/data/Branded";
+import { ASTAnnotation } from "./ASTAnnotation.js";
+import { ASTAnnotationMap } from "./ASTAnnotationMap.js";
+export declare const ASTTypeId: unique symbol;
+export type ASTTypeId = typeof ASTTypeId;
+export declare abstract class Annotated {
+    readonly annotations: ASTAnnotationMap;
+}
+/**
+ * @tsplus type fncts.schema.AST
+ * @tsplus companion fncts.schema.ASTOps
+ */
+export declare abstract class AST extends Annotated {
+    readonly [ASTTypeId]: ASTTypeId;
+    abstract clone(newProperties: Partial<this>): AST;
+}
+export declare namespace AST {
+    interface Compiler<A> {
+        (ast: AST): A;
+    }
+    type Match<A> = {
+        [K in Concrete["_tag"]]: (ast: Extract<Concrete, {
+            _tag: K;
+        }>, compile: Compiler<A>) => A;
+    };
+}
+export declare const enum ASTTag {
+    Declaration = 0,
+    Literal = 1,
+    UniqueSymbol = 2,
+    UndefinedKeyword = 3,
+    VoidKeyword = 4,
+    NeverKeyword = 5,
+    UnknownKeyword = 6,
+    AnyKeyword = 7,
+    StringKeyword = 8,
+    NumberKeyword = 9,
+    BooleanKeyword = 10,
+    BigIntKeyword = 11,
+    SymbolKeyword = 12,
+    ObjectKeyword = 13,
+    Enum = 14,
+    TemplateLiteral = 15,
+    Tuple = 16,
+    TypeLiteral = 17,
+    Union = 18,
+    Lazy = 19,
+    Refinement = 20,
+    Transform = 21,
+    Validation = 22
+}
+export type Concrete = Declaration | Literal | UniqueSymbol | UndefinedKeyword | VoidKeyword | NeverKeyword | UnknownKeyword | AnyKeyword | StringKeyword | NumberKeyword | BooleanKeyword | BigIntKeyword | SymbolKeyword | ObjectKeyword | Enum | TemplateLiteral | Tuple | TypeLiteral | Union | Lazy | Refinement | Transform | Validation;
+/**
+ * @tsplus static fncts.schema.ASTOps concrete
+ * @tsplus macro remove
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function concrete(_: AST): asserts _ is Concrete;
+export declare function getAnnotations<V>(key: ASTAnnotation<V>): (self: Annotated) => Maybe<V>;
+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 annotations: ASTAnnotationMap;
+    readonly _tag = ASTTag.Declaration;
+    constructor(typeParameters: Vector<AST>, type: AST, decode: (...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;
+/**
+ * @tsplus fluent fncts.schema.AST isDeclaration
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function isDeclaration(self: AST): self is Declaration;
+export type LiteralValue = string | number | boolean | null | bigint;
+export declare class Literal extends AST {
+    readonly literal: LiteralValue;
+    readonly annotations: ASTAnnotationMap;
+    readonly _tag = ASTTag.Literal;
+    constructor(literal: LiteralValue, annotations?: ASTAnnotationMap);
+    clone(newProperties: Partial<this>): AST;
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createLiteral
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function createLiteral(literal: LiteralValue, annotations?: ASTAnnotationMap): Literal;
+/**
+ * @tsplus fluent fncts.schema.AST isLiteral
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function isLiteral(self: AST): self is Literal;
+export declare class UniqueSymbol extends AST {
+    readonly symbol: symbol;
+    readonly annotations: ASTAnnotationMap;
+    readonly _tag = ASTTag.UniqueSymbol;
+    constructor(symbol: symbol, annotations?: ASTAnnotationMap);
+    clone(newProperties: Partial<this>): AST;
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createUniqueSymbol
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function createUniqueSymbol(symbol: symbol, annotations?: ASTAnnotationMap): UniqueSymbol;
+/**
+ * @tsplus fluent fncts.schema.AST isUniqueSymbol
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function isUniqueSymbol(self: AST): self is UniqueSymbol;
+export declare class UndefinedKeyword extends AST {
+    readonly annotations: ASTAnnotationMap;
+    readonly _tag = ASTTag.UndefinedKeyword;
+    constructor(annotations?: ASTAnnotationMap);
+    clone(newProperties: Partial<this>): AST;
+}
+/**
+ * @tsplus static fncts.schema.ASTOps undefinedKeyword
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare const undefinedKeyword: UndefinedKeyword;
+export declare class VoidKeyword extends AST {
+    readonly annotations: ASTAnnotationMap;
+    readonly _tag = ASTTag.VoidKeyword;
+    constructor(annotations?: ASTAnnotationMap);
+    clone(newProperties: Partial<this>): AST;
+}
+/**
+ * @tsplus static fncts.schema.ASTOps voidKeyword
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare const voidKeyword: VoidKeyword;
+export declare class NeverKeyword extends AST {
+    readonly annotations: ASTAnnotationMap;
+    readonly _tag = ASTTag.NeverKeyword;
+    constructor(annotations?: ASTAnnotationMap);
+    clone(newProperties: Partial<this>): AST;
+}
+/**
+ * @tsplus static fncts.schema.ASTOps neverKeyword
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare const neverKeyword: NeverKeyword;
+export declare class UnknownKeyword extends AST {
+    readonly annotations: ASTAnnotationMap;
+    readonly _tag = ASTTag.UnknownKeyword;
+    constructor(annotations?: ASTAnnotationMap);
+    clone(newProperties: Partial<this>): AST;
+}
+/**
+ * @tsplus static fncts.schema.ASTOps unknownKeyword
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare const unknownKeyword: UnknownKeyword;
+export declare class AnyKeyword extends AST {
+    readonly annotations: ASTAnnotationMap;
+    readonly _tag = ASTTag.AnyKeyword;
+    constructor(annotations?: ASTAnnotationMap);
+    clone(newProperties: Partial<this>): AST;
+}
+/**
+ * @tsplus static fncts.schema.ASTOps anyKeyword
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare const anyKeyword: AnyKeyword;
+export declare class StringKeyword extends AST {
+    readonly annotations: ASTAnnotationMap;
+    readonly _tag = ASTTag.StringKeyword;
+    constructor(annotations?: ASTAnnotationMap);
+    clone(newProperties: Partial<this>): AST;
+}
+/**
+ * @tsplus static fncts.schema.ASTOps stringKeyword
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare const stringKeyword: StringKeyword;
+/**
+ * @tsplus fluent fncts.schema.AST isStringKeyword
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function isStringKeyword(self: AST): self is StringKeyword;
+export declare class NumberKeyword extends AST {
+    readonly annotations: ASTAnnotationMap;
+    readonly _tag = ASTTag.NumberKeyword;
+    constructor(annotations?: ASTAnnotationMap);
+    clone(newProperties: Partial<this>): AST;
+}
+/**
+ * @tsplus static fncts.schema.ASTOps numberKeyword
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare const numberKeyword: NumberKeyword;
+/**
+ * @tsplus fluent fncts.schema.AST isNumberKeyword
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function isNumberKeyword(self: AST): self is NumberKeyword;
+export declare class BooleanKeyword extends AST {
+    readonly annotations: ASTAnnotationMap;
+    readonly _tag = ASTTag.BooleanKeyword;
+    constructor(annotations?: ASTAnnotationMap);
+    clone(newProperties: Partial<this>): AST;
+}
+/**
+ * @tsplus static fncts.schema.ASTOps booleanKeyword
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare const booleanKeyword: BooleanKeyword;
+/**
+ * @tsplus fluent fncts.schema.AST isBooleanKeyword
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function isBooleanKeyword(self: AST): self is BooleanKeyword;
+export declare class BigIntKeyword extends AST {
+    readonly annotations: ASTAnnotationMap;
+    readonly _tag = ASTTag.BigIntKeyword;
+    constructor(annotations?: ASTAnnotationMap);
+    clone(newProperties: Partial<this>): AST;
+}
+/**
+ * @tsplus static fncts.schema.ASTOps bigIntKeyword
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare const bigIntKeyword: BigIntKeyword;
+/**
+ * @tsplus fluent fncts.schema.AST isBigIntKeyword
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function isBigIntKeyword(self: AST): self is BigIntKeyword;
+export declare class SymbolKeyword extends AST {
+    readonly annotations: ASTAnnotationMap;
+    readonly _tag = ASTTag.SymbolKeyword;
+    constructor(annotations?: ASTAnnotationMap);
+    clone(newProperties: Partial<this>): AST;
+}
+/**
+ * @tsplus static fncts.schema.ASTOps symbolKeyword
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare const symbolKeyword: SymbolKeyword;
+/**
+ * @tsplus fluent fncts.schema.AST isSymbolKeyword
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function isSymbolKeyword(self: AST): self is SymbolKeyword;
+export declare class ObjectKeyword extends AST {
+    readonly annotations: ASTAnnotationMap;
+    readonly _tag = ASTTag.ObjectKeyword;
+    constructor(annotations?: ASTAnnotationMap);
+    clone(newProperties: Partial<this>): AST;
+}
+/**
+ * @tsplus static fncts.schema.ASTOps objectKeyword
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare const objectKeyword: ObjectKeyword;
+export declare class Enum extends AST {
+    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;
+}
+/**
+ * @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 {
+    readonly type: StringKeyword | NumberKeyword;
+    readonly literal: string;
+    constructor(type: StringKeyword | NumberKeyword, literal: string);
+}
+export declare class TemplateLiteral extends AST {
+    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;
+}
+/**
+ * @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 {
+    readonly type: AST;
+    readonly isOptional: boolean;
+    constructor(type: AST, isOptional: boolean);
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createElement
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function createElement(type: AST, isOptional: boolean): Element;
+export declare class Tuple extends AST {
+    readonly elements: Vector<Element>;
+    readonly rest: Maybe<Vector<AST>>;
+    readonly isReadonly: boolean;
+    readonly annotations: ASTAnnotationMap;
+    readonly _tag = ASTTag.Tuple;
+    constructor(elements: Vector<Element>, rest: Maybe<Vector<AST>>, isReadonly: boolean, annotations?: ASTAnnotationMap);
+    clone(newProperties: Partial<this>): AST;
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createTuple
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function createTuple(elements: Vector<Element>, rest: Maybe<Vector<AST>>, isReadonly: boolean, annotations?: ASTAnnotationMap): Tuple;
+export declare class PropertySignature extends AST {
+    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;
+}
+/**
+ * @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 {
+    readonly parameter: StringKeyword | SymbolKeyword | TemplateLiteral | Refinement;
+    readonly type: AST;
+    readonly isReadonly: boolean;
+    constructor(parameter: StringKeyword | SymbolKeyword | TemplateLiteral | Refinement, type: AST, isReadonly: boolean);
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createIndexSignature
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function createIndexSignature(parameter: StringKeyword | SymbolKeyword | TemplateLiteral | Refinement, type: AST, isReadonly: boolean): IndexSignature;
+export declare class TypeLiteral extends AST {
+    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;
+}
+/**
+ * @tsplus static fncts.schema.ASTOps isTypeLiteral
+ * @tsplus fluent fncts.schema.AST isTypeLiteral
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function isTypeLiteral(self: AST): self is TypeLiteral;
+/**
+ * @tsplus static fncts.schema.ASTOps createTypeLiteral
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function createTypeLiteral(propertySignatures: Vector<PropertySignature>, indexSignatures: Vector<IndexSignature>, annotations?: ASTAnnotationMap): TypeLiteral;
+export declare class Union extends AST {
+    readonly types: Vector<AST>;
+    readonly annotations: ASTAnnotationMap;
+    readonly _tag = ASTTag.Union;
+    constructor(types: Vector<AST>, annotations?: ASTAnnotationMap);
+    clone(newProperties: Partial<this>): AST;
+}
+/**
+ * @tsplus fluent fncts.schema.AST isUnion
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function isUnion(self: AST): self is Union;
+/**
+ * @tsplus static fncts.schema.ASTOps createUnion
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function createUnion(candidates: Vector<AST>, annotations?: ASTAnnotationMap): AST;
+export declare class Lazy extends AST {
+    readonly getAST: () => AST;
+    readonly annotations: ASTAnnotationMap;
+    readonly _tag = ASTTag.Lazy;
+    constructor(getAST: () => AST, annotations?: ASTAnnotationMap);
+    clone(newProperties: Partial<this>): AST;
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createLazy
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function createLazy(getAST: () => AST, annotations?: ASTAnnotationMap): Lazy;
+/**
+ * @tsplus fluent fncts.schema.AST isLazy
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function isLazy(self: AST): self is Lazy;
+export declare class Refinement extends AST {
+    readonly from: AST;
+    readonly decode: (input: any, options?: ParseOptions) => ParseResult<any>;
+    readonly isReversed: boolean;
+    readonly annotations: ASTAnnotationMap;
+    readonly _tag = ASTTag.Refinement;
+    constructor(from: AST, decode: (input: any, options?: ParseOptions) => ParseResult<any>, isReversed: boolean, annotations?: ASTAnnotationMap);
+    clone(newProperties: Partial<this>): AST;
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createRefinement
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function createRefinement(from: AST, decode: (input: any, options?: ParseOptions) => ParseResult<any>, isReversed: boolean, annotations?: ASTAnnotationMap): Refinement;
+export declare function isRefinement(self: AST): self is Refinement;
+export interface ParseOptions {
+    readonly isUnexpectedAllowed?: boolean;
+    readonly allErrors?: boolean;
+}
+export declare class Transform extends AST {
+    readonly from: AST;
+    readonly to: AST;
+    readonly decode: (input: any, options?: ParseOptions) => ParseResult<any>;
+    readonly encode: (input: any, options?: ParseOptions) => ParseResult<any>;
+    readonly isReversed: boolean;
+    readonly annotations: ASTAnnotationMap;
+    readonly _tag = ASTTag.Transform;
+    constructor(from: AST, to: AST, decode: (input: any, options?: ParseOptions) => ParseResult<any>, encode: (input: any, options?: ParseOptions) => ParseResult<any>, isReversed: boolean, annotations?: ASTAnnotationMap);
+    clone(newProperties: Partial<this>): AST;
+}
+/**
+ * @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>, isReversed: boolean, annotations?: ASTAnnotationMap): Transform;
+export declare class Validation extends AST {
+    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;
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createValidation
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function createValidation(from: AST, validation: Vector<ValidationType<any, string>>, annotations?: ASTAnnotationMap): Validation;
+/**
+ * @tsplus tailRec
+ */
+export declare function getCardinality(ast: AST): number;
+export declare function getWeight(ast: AST): number;
+/**
+ * @tsplus pipeable fncts.schema.AST combineAnnotations
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function combineAnnotations(annotations: ASTAnnotationMap): (self: AST) => AST;
+/**
+ * @tsplus pipeable fncts.schema.AST setAnnotation
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function setAnnotation<A>(annotation: ASTAnnotation<A>, value: A): (self: AST) => AST;
+/**
+ * @tsplus pipeable fncts.schema.AST appendRestElement
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function appendRestElement(restElement: AST): (self: Tuple) => Tuple;
+/**
+ * @tsplus pipeable fncts.schema.AST appendElement
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function appendElement(element: Element): (self: Tuple) => Tuple;
+export declare function getParameter(x: IndexSignature["parameter"]): StringKeyword | SymbolKeyword | TemplateLiteral;
+/**
+ * @tsplus getter fncts.schema.AST getPropertySignatures
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function getPropertySignatures(self: AST): Vector<PropertySignature>;
+/**
+ * @tsplus getter fncts.schema.AST keysof
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function keysOf(ast: AST): Vector<AST>;
+/**
+ * @tsplus getter fncts.schema.AST keyof
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function keyof(self: AST): AST;
+/**
+ * @tsplus static fncts.schema.ASTOps createRecord
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function createRecord(key: AST, value: AST, isReadonly: boolean): TypeLiteral;
+/**
+ * @tsplus pipeable fncts.schema.AST pick
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function pick(keys: Vector<PropertyKey>): (self: AST) => TypeLiteral;
+/**
+ * @tsplus pipeable fncts.schema.AST omit
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function omit(keys: Vector<PropertyKey>): (self: AST) => TypeLiteral;
+/**
+ * @tsplus getter fncts.schema.AST partial
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function partial(self: AST): AST;
+/**
+ * @tsplus static fncts.schema.AST createKey
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function createKey(key: PropertyKey): AST;
+/**
+ * @tsplus getter fncts.schema.AST getFrom
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function getFrom(ast: AST): AST;
+/**
+ * @tsplus getter fncts.schema.AST getTo
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function getTo(ast: AST): AST;
+/**
+ * @tsplus getter fncts.schema.AST reverse
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function reverse(ast: AST): AST;
+/**
+ * @tsplus static fncts.schema.AST getCompiler
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare function getCompiler<A>(match: AST.Match<A>): AST.Compiler<A>;

package/ASTAnnotation.d.ts

@@ -0,0 +1,82 @@
+import { Hashable } from "@fncts/base/data/Hashable";
+import { Equatable } from "@fncts/base/data/Equatable";
+import { Tag } from "@fncts/base/data/Tag/definition";
+import { Vector } from "@fncts/base/collection/immutable/Vector";
+import type { Validation } from "@fncts/base/data/Branded";
+export declare const ASTAnnotationVariance: unique symbol;
+export type ASTAnnotationVariance = typeof ASTAnnotationVariance;
+export declare const ASTAnnotationTypeId: unique symbol;
+export type ASTAnnotationTypeId = typeof ASTAnnotationTypeId;
+/**
+ * @tsplus type fncts.schema.ASTAnnotation
+ * @tsplus companion fncts.schema.ASTAnnotationOps
+ */
+export declare class ASTAnnotation<V> implements Hashable, Equatable {
+    readonly tag: Tag<V>;
+    readonly identifier: string;
+    readonly combine: (v1: V, v2: V) => V;
+    readonly [ASTAnnotationTypeId]: ASTAnnotationTypeId;
+    [ASTAnnotationVariance]: {
+        readonly _V: (_: never) => V;
+    };
+    constructor(tag: Tag<V>, identifier: string, combine: (v1: V, v2: V) => V);
+    get [Symbol.hash](): number;
+    [Symbol.equals](that: unknown): boolean;
+}
+export declare function isASTAnnotation(u: unknown): u is ASTAnnotation<unknown>;
+export declare const TitleTag: import("@fncts/base/data/Tag").Tag<string>;
+/**
+ * @tsplus static fncts.schema.ASTAnnotationOps Title
+ * @tsplus location "@fncts/schema/ASTAnnotation"
+ */
+export declare const Title: ASTAnnotation<string>;
+export declare const IdentifierTag: import("@fncts/base/data/Tag").Tag<string>;
+/**
+ * @tsplus static fncts.schema.ASTAnnotationOps Identifier
+ * @tsplus location "@fncts/schema/ASTAnnotation"
+ */
+export declare const Identifier: ASTAnnotation<string>;
+export declare const DescriptionTag: import("@fncts/base/data/Tag").Tag<string>;
+/**
+ * @tsplus static fncts.schema.ASTAnnotationOps Description
+ * @tsplus location "@fncts/schema/ASTAnnotation"
+ */
+export declare const Description: ASTAnnotation<string>;
+export declare const MessageTag: import("@fncts/base/data/Tag").Tag<(_: unknown) => string>;
+/**
+ * @tsplus static fncts.schema.ASTAnnotationOps Message
+ * @tsplus location "@fncts/schema/ASTAnnotation"
+ */
+export declare const Message: ASTAnnotation<(_: unknown) => string>;
+export declare const BrandTag: import("@fncts/base/data/Tag").Tag<import("@fncts/base/collection/immutable/Vector").Vector<Validation<any, any>>>;
+/**
+ * @tsplus static fncts.schema.ASTAnnotationOps Brand
+ * @tsplus location "@fncts/schema/ASTAnnotation"
+ */
+export declare const Brand: ASTAnnotation<import("@fncts/base/collection/immutable/Vector").Vector<Validation<any, any>>>;
+export declare const OptionalTag: import("@fncts/base/data/Tag").Tag<boolean>;
+/**
+ * @tsplus static fncts.schema.ASTAnnotationOps Optional
+ * @tsplus location "@fncts/schema/ASTAnnotation"
+ */
+export declare const Optional: ASTAnnotation<boolean>;
+export declare const ParseOptionalTag: import("@fncts/base/data/Tag").Tag<boolean>;
+/**
+ * @tsplus static fncts.schema.ASTAnnotationOps ParseOptional
+ * @tsplus location "@fncts/schema/ASTAnnotation"
+ */
+export declare const ParseOptional: ASTAnnotation<boolean>;
+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>>;
+/**
+ * @tsplus static fncts.schema.ASTAnnotationOps ParserHook
+ * @tsplus location "@fncts/schema/ASTAnnotation"
+ */
+export declare const ParserHook: ASTAnnotation<Hook<any>>;
+export declare const GenHookTag: import("@fncts/base/data/Tag").Tag<Hook<any>>;
+/**
+ * @tsplus static fncts.schema.ASTAnnotationOps GenHook
+ * @tsplus location "@fncts/schema/ASTAnnotation"
+ */
+export declare const GenHook: ASTAnnotation<Hook<any>>;

package/ASTAnnotationMap.d.ts

@@ -0,0 +1,14 @@
+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 {
+    readonly map: HashMap<ASTAnnotation<any>, any>;
+    constructor(map: HashMap<ASTAnnotation<any>, any>);
+    combine(that: ASTAnnotationMap): ASTAnnotationMap;
+    get<V>(key: ASTAnnotation<V>): Maybe<V>;
+    private overwrite;
+    private update;
+    annotate<V>(key: ASTAnnotation<V>, value: V): ASTAnnotationMap;
+    static empty: ASTAnnotationMap;
+}

package/Gen.d.ts

@@ -0,0 +1,15 @@
+import { Schema } from "@fncts/schema/Schema/definition";
+import { Gen } from "@fncts/test/control/Gen";
+import { AST } from "@fncts/schema/AST";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import type { Sized } from "@fncts/test/control/Sized";
+/**
+ * @tsplus getter fncts.schema.Schema genFrom
+ * @tsplus location "@fncts/schema/Gen"
+ */
+export declare function genFrom<A>(self: Schema<A>): Gen<Sized, unknown>;
+/**
+ * @tsplus getter fncts.schema.Schema genTo
+ * @tsplus location "@fncts/schema/Gen"
+ */
+export declare function genTo<A>(self: Schema<A>): Gen<Sized, A>;

package/InvalidInterpretationError.d.ts

@@ -0,0 +1,5 @@
+export declare const InvalidInterpretationErrorTypeId: unique symbol;
+export type InvalidInterpretationErrorTypeId = typeof InvalidInterpretationErrorTypeId;
+export declare class InvalidInterpretationError extends Error {
+    readonly [InvalidInterpretationErrorTypeId]: InvalidInterpretationErrorTypeId;
+}