import type { Refinement } from "@effect-ts/core/Function";
import type * as fc from "fast-check";
import type { Parser, ParserEnv } from "../Parser.js";
import type * as Th from "../These.js";
import type { Annotation } from "./annotation.js";
import type { AnyError } from "./error.js";
export declare const SchemaSym: unique symbol;
export type SchemaSym = typeof SchemaSym;
/**
 * A `Schema` is a functional representation of a data model of type `ParsedShape`
 * that can be:
 *
 * 1) parsed from a `ParsedShape` starting from an input of type `ParserInput`
 *    maybe failing for a reason `ParserError`
 *
 * 2) constructed smartly starting from an input of type `ConstructorInput`
 *
 * 3) encoded into an `Encoded` value
 *
 * 4) interacted with via `Api`
 */
/**
 * @tsplus type ets/Schema/Schema
 * @tsplus companion ets/Schema/SchemaOps
 */
export declare abstract class Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api> {
    readonly [SchemaSym]: SchemaSym;
    readonly _ParserInput: (_: ParserInput, env?: ParserEnv) => void;
    readonly _ParserError: () => any;
    readonly _ParsedShape: () => ParsedShape;
    readonly _ConstructorInput: (_: ConstructorInput) => void;
    readonly _ConstructorError: () => any;
    readonly _Encoded: () => Encoded;
    abstract readonly Api: Api;
    readonly [">>>"]: <ThatParsedShape, ThatConstructorInput, ThatApi>(that: Schema<ParsedShape, ThatParsedShape, ThatConstructorInput, ParsedShape, ThatApi>) => Schema<ParserInput, ThatParsedShape, ThatConstructorInput, Encoded, ThatApi>;
    readonly annotate: <Meta>(identifier: Annotation<Meta>, meta: Meta) => Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api>;
}
export type SchemaAny = Schema<any, any, any, any, any>;
export type SchemaUPI = Schema<unknown, any, any, any, any>;
export type Standard<A, Enc = unknown> = Schema<unknown, A, A, Enc, {}>;
export interface ApiSelfType<AS = unknown> {
    _AS: AS;
}
export type GetApiSelfType<T extends ApiSelfType<unknown>, D> = unknown extends T["_AS"] ? D : T["_AS"];
export declare const SchemaContinuationSymbol: unique symbol;
export type SchemaContinuationSymbol = typeof SchemaContinuationSymbol;
export interface HasContinuation {
    readonly [SchemaContinuationSymbol]: Schema<unknown, unknown, unknown, unknown, unknown>;
}
export declare function hasContinuation<ParserInput, ParsedShape, ConstructorInput, Encoded, Api>(schema: Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api>): schema is Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api> & HasContinuation;
export type ParserInputOf<X extends Schema<any, any, any, any, any>> = [X] extends [
    Schema<infer Y, any, any, any, any>
] ? Y : never;
export type ParserErrorOf<X extends Schema<any, any, any, any, any>> = [X] extends [
    Schema<any, any, any, any, any>
] ? any : never;
export type ConstructorInputOf<X extends Schema<any, any, any, any, any>> = [
    X
] extends [Schema<any, any, infer Y, any, any>] ? Y : never;
export type ConstructorErrorOf<X extends Schema<any, any, any, any, any>> = [
    X
] extends [Schema<any, any, any, any, any>] ? any : never;
export type EncodedOf<X extends Schema<any, any, any, any, any>> = [X] extends [
    Schema<any, any, any, infer Y, any>
] ? Y : never;
export type ParsedShapeOf<X extends Schema<any, any, any, any, any>> = [X] extends [
    Schema<any, infer Y, any, any, any>
] ? Y : never;
export type ApiOf<X extends Schema<any, any, any, any, any>> = [X] extends [
    Schema<any, any, any, any, infer Y>
] ? Y : never;
export declare class SchemaIdentity<A> extends Schema<A, A, A, A, {}> {
    readonly guard: (_: unknown) => _ is A;
    readonly Api: {};
    constructor(guard: (_: unknown) => _ is A);
}
export declare class SchemaConstructor<NewConstructorInput, ParserInput, ParsedShape, ConstructorInput, Encoded, Api> extends Schema<ParserInput, ParsedShape, NewConstructorInput, Encoded, Api> implements HasContinuation {
    readonly self: Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api>;
    readonly of: (i: NewConstructorInput) => Th.These<any, ParsedShape>;
    get Api(): Api;
    readonly [SchemaContinuationSymbol]: SchemaAny;
    constructor(self: Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api>, of: (i: NewConstructorInput) => Th.These<any, ParsedShape>);
}
export declare class SchemaParser<NewParserInput, ParserInput, ParsedShape, ConstructorInput, Encoded, Api> extends Schema<NewParserInput, ParsedShape, ConstructorInput, Encoded, Api> implements HasContinuation {
    readonly self: Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api>;
    readonly parser: Parser<NewParserInput, any, ParsedShape>;
    get Api(): Api;
    readonly [SchemaContinuationSymbol]: SchemaAny;
    constructor(self: Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api>, parser: Parser<NewParserInput, any, ParsedShape>);
}
export declare class SchemaArbitrary<ParserInput, ParsedShape, ConstructorInput, Encoded, Api> extends Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api> implements HasContinuation {
    readonly self: Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api>;
    readonly arbitrary: (_: typeof fc) => fc.Arbitrary<ParsedShape>;
    get Api(): Api;
    readonly [SchemaContinuationSymbol]: SchemaAny;
    constructor(self: Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api>, arbitrary: (_: typeof fc) => fc.Arbitrary<ParsedShape>);
}
export declare class SchemaEncoder<ParserInput, ParsedShape, ConstructorInput, Encoded, Api, Encoded2> extends Schema<ParserInput, ParsedShape, ConstructorInput, Encoded2, Api> implements HasContinuation {
    readonly self: Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api>;
    readonly encoder: (_: ParsedShape) => Encoded2;
    get Api(): Api;
    readonly [SchemaContinuationSymbol]: SchemaAny;
    constructor(self: Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api>, encoder: (_: ParsedShape) => Encoded2);
}
export declare class SchemaRefinement<E extends AnyError, NewParsedShape extends ParsedShape, ParserInput, ParsedShape, ConstructorInput, Encoded, Api> extends Schema<ParserInput, NewParsedShape, ConstructorInput, Encoded, Api> {
    readonly self: Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api>;
    readonly refinement: Refinement<ParsedShape, NewParsedShape>;
    readonly error: (value: ParsedShape) => E;
    get Api(): Api;
    constructor(self: Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api>, refinement: Refinement<ParsedShape, NewParsedShape>, error: (value: ParsedShape) => E);
}
export declare class SchemaPipe<ParserInput, ParsedShape, ConstructorInput, Encoded, Api, ThatParsedShape, ThatConstructorInput, ThatApi> extends Schema<ParserInput, ThatParsedShape, ThatConstructorInput, Encoded, ThatApi> implements HasContinuation {
    readonly self: Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api>;
    readonly that: Schema<ParsedShape, ThatParsedShape, ThatConstructorInput, ParsedShape, ThatApi>;
    get Api(): ThatApi;
    readonly [SchemaContinuationSymbol]: SchemaAny;
    constructor(self: Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api>, that: Schema<ParsedShape, ThatParsedShape, ThatConstructorInput, ParsedShape, ThatApi>);
}
export declare class SchemaMapParserError<ParserInput, ParsedShape, ConstructorInput, Encoded, Api> extends Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api> implements HasContinuation {
    readonly self: Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api>;
    readonly mapError: (_: any) => any;
    get Api(): Api;
    readonly [SchemaContinuationSymbol]: SchemaAny;
    constructor(self: Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api>, mapError: (_: any) => any);
}
export declare class SchemaMapConstructorError<ParserInput, ParsedShape, ConstructorInput, Encoded, Api> extends Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api> implements HasContinuation {
    readonly self: Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api>;
    readonly mapError: (_: any) => any;
    get Api(): Api;
    readonly [SchemaContinuationSymbol]: SchemaAny;
    constructor(self: Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api>, mapError: (_: any) => any);
}
export declare class SchemaMapApi<ParserInput, ParsedShape, ConstructorInput, Encoded, Api, Api2> extends Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api2> implements HasContinuation {
    readonly self: Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api>;
    readonly mapApi: (_: Api) => Api2;
    get Api(): Api2;
    readonly [SchemaContinuationSymbol]: SchemaAny;
    constructor(self: Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api>, mapApi: (_: Api) => Api2);
}
export declare class SchemaNamed<ParserInput, ParsedShape, ConstructorInput, Encoded, Api, Name extends string> extends Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api> implements HasContinuation {
    readonly self: Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api>;
    readonly name: Name;
    get Api(): Api;
    readonly [SchemaContinuationSymbol]: SchemaAny;
    constructor(self: Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api>, name: Name);
}
export declare const Identifiable: unique symbol;
export declare function isAnnotated<Self extends SchemaAny, A>(self: Self, annotation: Annotation<A>): self is Self & {
    readonly self: Self extends {
        self: infer X;
    } ? X : SchemaAny;
    readonly annotation: Annotation<A>;
    readonly meta: A;
};
export declare function isAnnotatedSchema<Self extends SchemaAny>(self: Self): self is Self & {
    readonly self: Self extends {
        self: infer X;
    } ? X : SchemaAny;
    readonly annotation: Annotation<any>;
    readonly meta: any;
};
export declare class SchemaAnnotated<ParserInput, ParsedShape, ConstructorInput, Encoded, Api, Meta> extends Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api> implements HasContinuation {
    readonly self: Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api>;
    readonly annotation: Annotation<Meta>;
    readonly meta: Meta;
    get Api(): Api;
    readonly [Identifiable]: symbol;
    readonly [SchemaContinuationSymbol]: SchemaAny;
    constructor(self: Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api>, annotation: Annotation<Meta>, meta: Meta);
}
export declare class SchemaGuard<ParserInput, ParsedShape, ConstructorInput, Encoded, Api> extends Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api> implements HasContinuation {
    readonly self: Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api>;
    readonly guard: (u: unknown) => u is ParsedShape;
    get Api(): Api;
    readonly [SchemaContinuationSymbol]: SchemaAny;
    constructor(self: Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api>, guard: (u: unknown) => u is ParsedShape);
}
export declare class SchemaLazy<ParserInput, ParsedShape, ConstructorInput, Encoded, Api> extends Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, {}> implements HasContinuation {
    readonly self: () => Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api>;
    readonly Api: {};
    get [SchemaContinuationSymbol](): SchemaAny;
    get lazy(): Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api>;
    constructor(self: () => Schema<ParserInput, ParsedShape, ConstructorInput, Encoded, Api>);
}
//# sourceMappingURL=schema.d.ts.map