@fncts/schema 0.0.5 → 0.0.7

package/ParseError.d.ts

@@ -0,0 +1,107 @@
+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";
+export declare const enum ParseErrorTag {
+    Type = 0,
+    Index = 1,
+    Key = 2,
+    Missing = 3,
+    Unexpected = 4,
+    UnionMember = 5
+}
+/**
+ * @tsplus type fncts.schema.ParseError
+ * @tsplus companion fncts.schema.ParseErrorOps
+ */
+export type ParseError = TypeError | IndexError | KeyError | MissingError | UnexpectedError | UnexpectedError | UnionMemberError;
+/**
+ * @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.IndexError __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 static fncts.schema.ParseErrorOps format
+ * @tsplus location "@fncts/schema/ParseError"
+ */
+export declare function format(errors: Vector<ParseError>): string;

package/ParseResult.d.ts

@@ -0,0 +1,24 @@
+import { Either } from "@fncts/base/data/Either/definition";
+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<Vector<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"
+ */
+export declare function fail<A = never>(value: ParseError): ParseResult<A>;

package/Parser/api.d.ts

@@ -0,0 +1,42 @@
+import { Schema } from "@fncts/schema/Schema/definition";
+import { Parser } from "@fncts/schema/Parser/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { ParseResult } from "@fncts/schema/ParseResult";
+import { AST } from "@fncts/schema/AST";
+import type { ParseOptions } from "../AST.js";
+/**
+ * @tsplus getter fncts.schema.Schema decode
+ * @tsplus getter fncts.schema.Parser decode
+ * @tsplus location "@fncts/schema/Parser/api"
+ */
+export declare function decode<A>(schema: Schema<A>): Parser<A>;
+/**
+ * @tsplus getter fncts.schema.Schema decodeMaybe
+ * @tsplus getter fncts.schema.Parser decodeMaybe
+ * @tsplus location "@fncts/schema/Parser/api"
+ */
+export declare function decodeMaybe<A>(schema: Schema<A>): <A>(input: A, options?: ParseOptions) => Maybe<A>;
+/**
+ * @tsplus getter fncts.schema.Schema encode
+ * @tsplus getter fncts.schema.Parser encode
+ * @tsplus location "@fncts/schema/Parser/api"
+ */
+export declare function encode<A>(schema: Schema<A>): <A>(input: A, options?: ParseOptions) => ParseResult<unknown>;
+/**
+ * @tsplus getter fncts.schema.Schema encodeMaybe
+ * @tsplus getter fncts.schema.Parser encodeMaybe
+ * @tsplus location "@fncts/schema/Parser/api"
+ */
+export declare function encodeMaybe<A>(schema: Schema<A>): <A>(input: A, options?: ParseOptions) => Maybe<unknown>;
+/**
+ * @tsplus getter fncts.schema.Schema is
+ * @tsplus getter fncts.schema.Parser is
+ * @tsplus location "@fncts/schema/Parser/api"
+ */
+export declare function is<A>(schema: Schema<A>): (input: unknown, options?: ParseOptions) => input is A;
+/**
+ * @tsplus getter fncts.schema.Schema asserts
+ * @tsplus getter fncts.schema.Parser asserts
+ * @tsplus location "@fncts/schema/Parser/api"
+ */
+export declare function asserts<A>(schema: Schema<A>): (input: unknown, options?: ParseOptions) => asserts input is A;

package/Parser/definition.d.ts

@@ -0,0 +1,22 @@
+import { ParseResult } from "@fncts/schema/ParseResult";
+import { AST } from "@fncts/schema/AST";
+import { Refinement } from "@fncts/base/data/Refinement/definition";
+import type { ParseOptions } from "../AST.js";
+/**
+ * @tsplus type fncts.schema.Parser
+ * @tsplus companion fncts.schema.ParserOps
+ * @tsplus no-inherit fncts.schema.Schema fncts.schema.SchemaOps
+ */
+export interface Parser<in out A> {
+    (input: unknown, options?: ParseOptions): ParseResult<A>;
+}
+/**
+ * @tsplus static fncts.schema.ParserOps make
+ * @tsplus location "@fncts/schema/Parser/definition"
+ */
+export declare function make<A>(parse: Parser<A>): Parser<A>;
+/**
+ * @tsplus static fncts.schema.ParserOps fromRefinement
+ * @tsplus location "@fncts/schema/Parser/definition"
+ */
+export declare function fromRefinement<A>(ast: AST, refinement: Refinement<unknown, A>): Parser<A>;

package/Parser/interpreter.d.ts

@@ -0,0 +1,6 @@
+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";
+import { Vector } from "@fncts/base/collection/immutable/Vector";
+export declare function parserFor(ast: AST): Parser<any>;

package/Parser.d.ts

@@ -0,0 +1,3 @@
+export * from "./Parser/api.js";
+export * from "./Parser/definition.js";
+export * from "./Parser/interpreter.js";

package/Schema/api/conc.d.ts

@@ -0,0 +1,18 @@
+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>>;
+/**
+ * @tsplus static fncts.schema.SchemaOps concFromArray
+ * @tsplus location "@fncts/schema/Schema/api/conc"
+ */
+export declare function concFromArray<A>(value: Schema<A>): Schema<Conc<A>>;
+/**
+ * @tsplus derive fncts.schema.Schema[fncts.Conc]<_> 10
+ * @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/either.d.ts

@@ -0,0 +1,19 @@
+import { Schema } from "@fncts/schema/Schema/definition";
+import { Either } from "@fncts/base/data/Either/definition";
+import { Check } from "@fncts/typelevel";
+import { Parser } from "@fncts/schema/Parser/definition";
+/**
+ * @tsplus static fncts.schema.SchemaOps either
+ * @tsplus location "@fncts/schema/Schema/api/either"
+ */
+export declare function either<E, A>(left: Schema<E>, right: Schema<A>): Schema<Either<E, A>>;
+/**
+ * @tsplus static fncts.schema.SchemaOps eitherFromJson
+ * @tsplus location "@fncts/schema/Schema/api/either"
+ */
+export declare function eitherFromJson<E, A>(left: Schema<E>, right: Schema<A>): Schema<Either<E, A>>;
+/**
+ * @tsplus derive fncts.schema.Schema[fncts.Either]<_> 10
+ * @tsplus location "@fncts/schema/Schema/api/either"
+ */
+export declare function deriveEither<A extends Either<any, any>>(...[left, right]: [A] extends [Either<infer _E, infer _A>] ? Check<Check.IsEqual<A, Either<_E, _A>>> extends Check.True ? [left: Schema<_E>, right: Schema<_A>] : never : never): Schema<A>;

package/Schema/api/hashMap.d.ts

@@ -0,0 +1,21 @@
+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";
+/**
+ * @tsplus static fncts.schema.SchemaOps hashMap
+ * @tsplus location "@fncts/schema/Schema/api/hashMap"
+ */
+export declare function hashMap<K, V>(key: Schema<K>, value: Schema<V>): Schema<HashMap<K, V>>;
+/**
+ * @tsplus static fncts.schema.SchemaOps hashMapFromRecord
+ * @tsplus location "@fncts/schema/Schema/api/hashMap"
+ */
+export declare function hashMapFromRecord<K extends string | symbol, V>(key: Schema<K>, value: Schema<V>): Schema<HashMap<K, V>>;
+/**
+ * @tsplus derive fncts.schema.Schema[fncts.HashMap]<_> 10
+ * @tsplus location "@fncts/schema/Schema/api/hashMap"
+ */
+export declare function deriveHashMap<A extends HashMap<any, any>>(...[key, value]: [A] extends [HashMap<infer K, infer V>] ? Check<Check.IsEqual<A, HashMap<K, V>> & Check.Extends<K, string | symbol>> extends Check.True ? [key: Schema<K>, value: Schema<V>] : never : never): Schema<A>;

package/Schema/api/immutableArray.d.ts

@@ -0,0 +1,23 @@
+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";
+/**
+ * @tsplus getter fncts.schema.Schema immutableArray
+ * @tsplus static fncts.schema.SchemaOps immutableArray
+ * @tsplus location "@fncts/schema/Schema/api/immutableArray"
+ */
+export declare function immutableArray<A>(value: Schema<A>): Schema<ImmutableArray<A>>;
+/**
+ * @tsplus getter fncts.schema.Schema immutableArrayFromArray
+ * @tsplus static fncts.schema.SchemaOps immutableArrayFromArray
+ * @tsplus location "@fncts/schema/Schema/api/immutableArray"
+ */
+export declare function immutableArrayFromArray<A>(value: Schema<A>): Schema<ImmutableArray<A>>;
+/**
+ * @tsplus derive fncts.schema.Schema[fncts.ImmutableArray]<_> 10
+ * @tsplus location "@fncts/schema/Schema/api/immutableArray"
+ */
+export declare function deriveImmutableArray<A extends ImmutableArray<any>>(...[value]: [A] extends [ImmutableArray<infer _A>] ? Check<Check.IsEqual<A, ImmutableArray<_A>>> extends Check.True ? [value: Schema<_A>] : never : never): Schema<A>;

package/Schema/api/list.d.ts

@@ -0,0 +1,23 @@
+import { Schema } from "@fncts/schema/Schema/definition";
+import { List, Nil, Cons } 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
+ * @tsplus getter fncts.Schema.Schema list
+ * @tsplus location "@fncts/schema/Schema/api/list"
+ */
+export declare function list<A>(value: Schema<A>): Schema<List<A>>;
+/**
+ * @tsplus static fncts.schema.SchemaOps listFromArray
+ * @tsplus getter fncts.Schema.Schema listFromArray
+ * @tsplus location "@fncts/schema/Schema/api/list"
+ */
+export declare function listFromArray<A>(value: Schema<A>): Schema<List<A>>;
+/**
+ * @tsplus derive fncts.schema.Schema[fncts.List]<_> 10
+ * @tsplus location "@fncts/schema/Schema/api/list"
+ */
+export declare function deriveList<A extends List<any>>(...[value]: [A] extends [List<infer _A>] ? Check<Check.IsEqual<A, List<_A>>> extends Check.True ? [value: Schema<_A>] : never : never): Schema<A>;

package/Schema/api/maybe.d.ts

@@ -0,0 +1,21 @@
+import { Schema } from "@fncts/schema/Schema/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Parser } from "@fncts/schema/Parser/definition";
+import type { Check } from "@fncts/typelevel";
+/**
+ * @tsplus static fncts.schema.SchemaOps maybe
+ * @tsplus getter fncts.schema.Schema maybe
+ * @tsplus location "@fncts/schema/Schema/api/maybe"
+ */
+export declare function maybe<A>(value: Schema<A>): Schema<Maybe<A>>;
+/**
+ * @tsplus static fncts.schema.SchemaOps maybeFromNullable
+ * @tsplus getter fncts.schema.Schema maybeFromNullable
+ * @tsplus location "@fncts/schema/Schema/api/maybe"
+ */
+export declare function maybeFromNullable<A>(value: Schema<A>): Schema<Maybe<A>>;
+/**
+ * @tsplus derive fncts.schema.Schema[fncts.Maybe]<_> 10
+ * @tsplus location "@fncts/schema/Schema/api/maybe"
+ */
+export declare function deriveMaybe<A extends Maybe<any>>(...[value]: [A] extends [Maybe<infer _A>] ? Check<Check.IsEqual<A, Maybe<_A>>> extends Check.True ? [value: Schema<_A>] : never : never): Schema<A>;

package/Schema/api.d.ts

@@ -0,0 +1,243 @@
+import { AST, LiteralValue } from "@fncts/schema/AST";
+import { Schema, OptionalSchema } from "@fncts/schema/Schema/definition";
+import { ASTAnnotation } from "@fncts/schema/ASTAnnotation";
+import { Vector } from "@fncts/base/collection/immutable/Vector";
+import { Parser } from "@fncts/schema/Parser/definition";
+import { ASTAnnotationMap } from "@fncts/schema/ASTAnnotationMap";
+import { Refinement } from "@fncts/base/data/Refinement/definition";
+import { Predicate } from "@fncts/base/data/Predicate/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { ParseResult } from "@fncts/schema/ParseResult";
+import type { ParseOptions } from "../AST.js";
+import type { Brand, Validation } from "@fncts/base/data/Branded";
+/**
+ * @tsplus static fncts.schema.SchemaOps fromAST
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare function make<A>(ast: AST): Schema<A>;
+/**
+ * @tsplus pipeable fncts.schema.Schema annotate
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare function annotate<V>(annotation: ASTAnnotation<V>, value: V): <A>(self: import("./definition.js").Schema<A>) => import("./definition.js").Schema<A>;
+/**
+ * @tsplus static fncts.schema.SchemaOps declaration
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare function declaration(typeParameters: Vector<Schema<any>>, type: Schema<any>, decode: (...typeParameters: ReadonlyArray<Schema<any>>) => Parser<any>, annotations?: ASTAnnotationMap): Schema<any>;
+/**
+ * @tsplus pipeable fncts.schema.Schema filter
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare function filter<A, B extends A>(refinement: Refinement<A, B>): (self: Schema<A>) => Schema<B>;
+export declare function filter<A>(predicate: Predicate<A>): (self: Schema<A>) => Schema<A>;
+/**
+ * @tsplus pipeable fncts.schema.Schema brand
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare function brand<A, K extends string>(validation: Validation<A, K>): (self: Schema<A>) => Schema<A & Brand.Valid<A, K>>;
+/**
+ * @tsplus static fncts.schema.SchemaOps literal
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare function literal<Literals extends ReadonlyArray<LiteralValue>>(...literals: Literals): Schema<Literals[number]>;
+/**
+ * @tsplus static fncts.schema.SchemaOps never
+ * @tsplus implicit
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare const never: Schema<never>;
+/**
+ * @tsplus static fncts.schema.SchemaOps unknown
+ * @tsplus implicit
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare const unknown: Schema<unknown>;
+/**
+ * @tsplus static fncts.schema.SchemaOps any
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare const any: Schema<any>;
+/**
+ * @tsplus static fncts.schema.SchemaOps undefined
+ * @tsplus implicit
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare const _undefined: Schema<undefined>;
+export { _undefined as undefined };
+/**
+ * @tsplus static fncts.schema.SchemaOps null
+ * @tsplus implicit
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare const _null: Schema<null>;
+export { _null as null };
+/**
+ * @tsplus static fncts.schema.SchemaOps void
+ * @tsplus implicit
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare const _void: Schema<void>;
+export { _void as void };
+/**
+ * @tsplus static fncts.schema.SchemaOps string
+ * @tsplus implicit
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare const string: Schema<string>;
+/**
+ * @tsplus static fncts.schema.SchemaOps number
+ * @tsplus implicit
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare const number: Schema<number>;
+/**
+ * @tsplus static fncts.schema.SchemaOps boolean
+ * @tsplus implicit
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare const boolean: Schema<boolean>;
+/**
+ * @tsplus static fncts.schema.SchemaOps bigint
+ * @tsplus implicit
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare const bigint: Schema<bigint>;
+/**
+ * @tsplus static fncts.schema.SchemaOps symbol
+ * @tsplus implicit
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare const symbol: Schema<symbol>;
+/**
+ * @tsplus static fncts.schema.SchemaOps object
+ * @tsplus implicit
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare const object: Schema<object>;
+/**
+ * @tsplus static fncts.schema.SchemaOps union
+ * @tsplus derive fncts.schema.Schema<|> 30
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare function union<A extends ReadonlyArray<unknown>>(...members: {
+    [K in keyof A]: Schema<A[K]>;
+}): Schema<A[number]>;
+/**
+ * @tsplus getter fncts.schema.Schema nullable
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare function nullable<A>(self: Schema<A>): Schema<A | null>;
+/**
+ * @tsplus static fncts.schema.SchemaOps uniqueSymbol
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare function uniqueSymbol<S extends symbol>(symbol: S, annotations?: ASTAnnotationMap): Schema<S>;
+/**
+ * @tsplus getter fncts.schema.Schema optional
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare function optional<A>(self: Schema<A>): OptionalSchema<A>;
+/**
+ * @tsplus fluent fncts.schema.Schema isOptional
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare function isOptional<A>(self: Schema<A>): self is OptionalSchema<A>;
+export type OptionalSchemaKeys<T> = {
+    [K in keyof T]: T[K] extends OptionalSchema<any> ? K : never;
+}[keyof T];
+/**
+ * @tsplus getter fncts.schema.Schema parseOptional
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare function parseOptional<A>(self: Schema<A>): Schema<Maybe<A>>;
+/**
+ * @tsplus fluent fncts.schema.Schema isParseOptional
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare function isParseOptional<A>(self: Schema<A>): boolean;
+export type Spread<A> = {
+    [K in keyof A]: A[K];
+} extends infer B ? B : never;
+/**
+ * @tsplus static fncts.schema.SchemaOps struct
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare function struct<Fields extends Record<PropertyKey, Schema<any>>>(fields: Fields): Schema<Spread<{
+    readonly [K in Exclude<keyof Fields, OptionalSchemaKeys<Fields>>]: Schema.Infer<Fields[K]>;
+} & {
+    readonly [K in OptionalSchemaKeys<Fields>]?: Schema.Infer<Fields[K]>;
+}>>;
+/**
+ * @tsplus static fncts.schema.SchemaOps tuple
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare function tuple<Elements extends ReadonlyArray<Schema<any>>>(...elements: Elements): Schema<{
+    readonly [K in keyof Elements]: Schema.Infer<Elements[K]>;
+}>;
+/**
+ * @tsplus static fncts.schema.SchemaOps lazy
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare function lazy<A>(f: () => Schema<A>, annotations?: ASTAnnotationMap): Schema<A>;
+/**
+ * @tsplus static fncts.schema.SchemaOps array
+ * @tsplus getter fncts.schema.Schema array
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare function array<A>(item: Schema<A>): Schema<ReadonlyArray<A>>;
+/**
+ * @tsplus static fncts.schema.SchemaOps mutableArray
+ * @tsplus getter fncts.schema.Schema mutableArray
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare function mutableArray<A>(item: Schema<A>): Schema<Array<A>>;
+/**
+ * @tsplus static fncts.schema.SchemaOps record
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare function record<K extends string | symbol, V>(key: Schema<K>, value: Schema<V>): Schema<{
+    readonly [k in K]: V;
+}>;
+/**
+ * @tsplus static fncts.schema.SchemaOps enum
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare function enum_<A extends {
+    [x: string]: string | number;
+}>(enums: A): Schema<A[keyof A]>;
+export { enum_ as enum };
+type Join<T> = T extends [infer Head, ...infer Tail] ? `${Head & (string | number | bigint | boolean | null | undefined)}${Tail extends [] ? "" : Join<Tail>}` : never;
+/**
+ * @tsplus static fncts.schema.SchemaOps templateLiteral
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare function templateLiteral<T extends [Schema<any>, ...Array<Schema<any>>]>(...[head, ...tail]: T): Schema<Join<{
+    [K in keyof T]: Schema.Infer<T[K]>;
+}>>;
+/**
+ * @tsplus static fncts.schema.SchemaOps keyof
+ * @tsplus getter fncts.schema.Schema keyof
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare function keyof<A>(self: Schema<A>): Schema<keyof A>;
+/**
+ * @tsplus pipeable fncts.schema.Schema extend
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare function extend<B>(that: Schema<B>): <A>(self: import("./definition.js").Schema<A>) => import("./definition.js").Schema<Spread<A & B>>;
+/**
+ * @tsplus pipeable fncts.schema.Schema instanceOf
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare function instanceOf<A extends abstract new (...args: any) => any>(constructor: A): (self: Schema<object>) => Schema<InstanceType<A>>;
+/**
+ * @tsplus pipeable fncts.schema.Schema transformOrFail
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare function transformOrFail<A, B>(to: Schema<B>, decode: (input: A, options?: ParseOptions) => ParseResult<B>, encode: (input: B, options?: ParseOptions) => ParseResult<A>): (from: Schema<A>) => Schema<B>;
+/**
+ * @tsplus pipeable fncts.schema.Schema transform
+ * @tsplus location "@fncts/schema/Schema/api"
+ */
+export declare function transform<A, B>(to: Schema<B>, decode: (input: A, options?: ParseOptions) => B, encode: (input: B, options?: ParseOptions) => A): (from: Schema<A>) => Schema<B>;

package/Schema/definition.d.ts

@@ -0,0 +1,29 @@
+import { HKT } from "@fncts/typelevel/HKT";
+import { AST } from "@fncts/schema/AST";
+export declare const SchemaVariance: unique symbol;
+export type SchemaVariance = typeof SchemaVariance;
+export declare const SchemaTypeId: unique symbol;
+export type SchemaTypeId = typeof SchemaTypeId;
+export declare const OptionalSchemaSymbol: unique symbol;
+export type OptionalSchemaSymbol = typeof OptionalSchemaSymbol;
+export interface SchemaF extends HKT {
+    readonly type: Schema<this["A"]>;
+}
+/**
+ * @tsplus type fncts.schema.Schema
+ * @tsplus companion fncts.schema.SchemaOps
+ */
+export declare class Schema<in out A> {
+    readonly ast: AST;
+    readonly [SchemaTypeId]: SchemaTypeId;
+    [SchemaVariance]: {
+        _A: (_: A) => A;
+    };
+    constructor(ast: AST);
+}
+export interface OptionalSchema<in out A> extends Schema<A> {
+    [OptionalSchemaSymbol]: OptionalSchemaSymbol;
+}
+export declare namespace Schema {
+    type Infer<S extends Schema<any>> = Parameters<S[SchemaVariance]["_A"]>[0];
+}