import { Either } from "@fp-ts/data/Either";
import { Lens } from "@effect-ts-app/boilerplate-prelude";
import type { AnyError, ConstructorErrorOf, ConstructorInputOf, DefaultSchema, EncodedOf, ParsedShapeOf, PropertyRecord, Schema, SchemaAny, schemaField, SchemaUPI, UnionApi } from "@effect-ts-app/schema";
import { LongString, Parser, ReasonableString } from "@effect-ts-app/schema";
import type * as Th from "@effect-ts-app/schema/custom/These";
import type { EnforceNonEmptyRecord } from "@effect-ts/core/Utils";
import type * as faker from "faker";
import * as S from "@effect-ts-app/schema";
export { matchTag } from "@effect-ts/core/Utils";
/**
 * A little helper to allow writing `interface X extends Identity<typeof Y>`
 * so you don't need an intermediate type for `typeof Y`
 */
export type Identity<T> = T;
export declare function fitIntoReasonableString(str: string): ReasonableString;
export declare function fitIntoLongString(str: string): LongString;
export declare class CustomSchemaException extends Error {
    readonly _tag = "ValidationError";
    readonly errors: ReadonlyArray<unknown>;
    constructor(error: S.AnyError);
    toJSON(): {
        message: string;
        errors: readonly unknown[];
    };
}
export declare const fakerArb: (gen: (fake: typeof faker) => () => string) => (a: any) => S.Arbitrary.Arbitrary<string>;
/**
 * The Effect fails with `CustomSchemaException` when the parser produces an invalid result.
 * Otherwise succeeds with the valid result.
 */
export declare function condemnCustom_<X, A>(self: Parser.Parser<X, AnyError, A>, a: X, env?: Parser.ParserEnv): import("@effect/io/Effect").Effect<never, CustomSchemaException, A>;
/**
 * The Effect fails with the generic `E` type when the parser produces an invalid result
 * Otherwise success with the valid result.
 */
export declare function condemn_<X, E, A>(self: Parser.Parser<X, E, A>, x: X, env?: Parser.ParserEnv): import("@effect/io/Effect").Effect<never, unknown, A>;
export declare function condemnCustom<X, A>(self: Parser.Parser<X, AnyError, A>): (a: X, env?: Parser.ParserEnv) => import("@effect/io/Effect").Effect<never, CustomSchemaException, A>;
export declare function condemnLeft_<X, A>(self: Parser.Parser<X, AnyError, A>, a: X, env?: Parser.ParserEnv): Either<CustomSchemaException, A>;
export declare function condemnLeft<X, A>(self: Parser.Parser<X, AnyError, A>): (a: X, env?: Parser.ParserEnv) => import("@fp-ts/data/Either").Either<CustomSchemaException, A>;
export declare function parseCondemnCustom_<A, B, C, D, E>(self: Schema<A, B, C, D, E>, a: A, env?: Parser.ParserEnv, __trace?: string): import("@effect/io/Effect").Effect<never, CustomSchemaException, B>;
export declare function parseECondemnCustom_<B, C, D, E>(self: Schema<unknown, B, C, D, E>, a: D, env?: Parser.ParserEnv, __trace?: string): import("@effect/io/Effect").Effect<never, CustomSchemaException, B>;
/**
 * The Effect dies with `ThrowableCondemnException` when the parser produces an invalid result.
 * Otherwise succeeds with the valid result.
 */
export declare function condemnDie_<X, A>(self: Parser.Parser<X, AnyError, A>, a: X, env?: Parser.ParserEnv, __trace?: string): import("@effect/io/Effect").Effect<never, never, A>;
export declare function parseCondemnDie_<A, B, C, D, E>(self: Schema<A, B, C, D, E>, a: A, env?: Parser.ParserEnv, __trace?: string): import("@effect/io/Effect").Effect<never, never, B>;
export declare function parseECondemnDie_<B, C, D, E>(self: Schema<unknown, B, C, D, E>, a: D, env?: Parser.ParserEnv, __trace?: string): import("@effect/io/Effect").Effect<never, never, B>;
export declare function parseECondemnDie<B, C, D, E>(self: Schema<unknown, B, C, D, E>): (a: D, env?: Parser.ParserEnv) => import("@effect/io/Effect").Effect<never, never, B>;
export declare function parseECondemnFail<B, C, D, E>(self: Schema<unknown, B, C, D, E>): (a: D, env?: Parser.ParserEnv) => import("@effect/io/Effect").Effect<never, CustomSchemaException, B>;
export declare function parseECondemnLeft<B, C, D, E>(self: Schema<unknown, B, C, D, E>): (a: D, env?: Parser.ParserEnv) => import("@fp-ts/data/Either").Either<CustomSchemaException, B>;
export declare function parseECondemnCustom<B, C, D, E>(self: Schema<unknown, B, C, D, E>): (a: D, env?: Parser.ParserEnv) => import("@effect/io/Effect").Effect<never, CustomSchemaException, B>;
export declare function parseCondemnDie<A, B, C, D, E>(self: Schema<A, B, C, D, E>): (a: A, env?: Parser.ParserEnv) => import("@effect/io/Effect").Effect<never, never, B>;
export declare function parseCondemnFail<A, B, C, D, E>(self: Schema<A, B, C, D, E>): (a: A, env?: Parser.ParserEnv) => import("@effect/io/Effect").Effect<never, CustomSchemaException, B>;
export declare function parseCondemnLeft<A, B, C, D, E>(self: Schema<A, B, C, D, E>): (a: A, env?: Parser.ParserEnv) => import("@fp-ts/data/Either").Either<CustomSchemaException, B>;
export declare function parseCondemnCustom<A, B, C, D, E>(self: Schema<A, B, C, D, E>): (a: A, env?: Parser.ParserEnv) => import("@effect/io/Effect").Effect<never, CustomSchemaException, B>;
export declare function parseCondemn<A, B, C, D, E>(self: Schema<A, B, C, D, E>): (a: A, env?: Parser.ParserEnv) => import("@effect/io/Effect").Effect<never, unknown, B>;
export declare function parseECondemn_<B, C, D, E>(self: Schema<unknown, B, C, D, E>, a: D, env?: Parser.ParserEnv, __trace?: string): import("@effect/io/Effect").Effect<never, unknown, B>;
export declare function parseECondemn<B, C, D, E>(self: Schema<unknown, B, C, D, E>): (a: D, env?: Parser.ParserEnv) => import("@effect/io/Effect").Effect<never, unknown, B>;
export declare function parseUnsafe<A, B, C, D, E>(self: Schema<A, B, C, D, E>): (a: A, env?: Parser.ParserEnv) => B;
export declare function parseEUnsafe<B, C, D, E>(self: Schema<unknown, B, C, D, E>): (a: D, env?: Parser.ParserEnv) => B;
/**
 * The Effect fails with `ThrowableCondemnException` when the parser produces an invalid result.
 * Otherwise succeeds with the valid result.
 */
export declare function condemnFail_<X, A>(self: Parser.Parser<X, AnyError, A>, a: X, env?: Parser.ParserEnv, __trace?: string): import("@effect/io/Effect").Effect<never, CustomSchemaException, A>;
export declare function parseCondemnFail_<A, B, C, D, E>(self: Schema<A, B, C, D, E>, a: A, env?: Parser.ParserEnv, __trace?: string): import("@effect/io/Effect").Effect<never, CustomSchemaException, B>;
export declare function parseECondemnFail_<B, C, D, E>(self: Schema<unknown, B, C, D, E>, a: D, env?: Parser.ParserEnv, __trace?: string): import("@effect/io/Effect").Effect<never, CustomSchemaException, B>;
export declare function parseCondemnLeft_<A, B, C, D, E>(self: Schema<A, B, C, D, E>, a: A, env?: Parser.ParserEnv): import("@fp-ts/data/Either").Either<CustomSchemaException, B>;
export declare function parseECondemnLeft_<B, C, D, E>(self: Schema<unknown, B, C, D, E>, a: D, env?: Parser.ParserEnv): import("@fp-ts/data/Either").Either<CustomSchemaException, B>;
export declare function tryParse<X, A>(self: Parser.Parser<X, AnyError, A>): (a: X, env?: Parser.ParserEnv) => import("@fp-ts/data/Option").None | import("@fp-ts/data/Option").Some<A>;
export declare function isSchema(p: S.SchemaAny | S.AnyProperty): p is S.SchemaAny;
export declare function getMetadataFromSchemaOrProp(p: S.SchemaAny | S.AnyProperty): {
    minLength: number | undefined;
    maxLength: number | undefined;
    required: boolean;
};
export declare function getMetadataFromProp<Prop extends S.AnyProperty>(p: Prop): {
    minLength: number | undefined;
    maxLength: number | undefined;
    required: boolean;
};
export declare function getMetadataFromSchema<Self extends S.SchemaAny>(self: Self): {
    minLength: number | undefined;
    maxLength: number | undefined;
    required: boolean;
};
export declare function getRegisterFromSchemaOrProp(p: S.SchemaAny | S.AnyProperty): {
    transform: {
        output: (value: any) => any;
        input: <A>(a: A) => A;
    };
};
export declare function getRegisterFromProp<Prop extends S.AnyProperty>(p: Prop): {
    transform: {
        output: (value: any) => any;
        input: <A>(a: A) => A;
    };
};
export declare function getRegisterFromSchema<Self extends S.SchemaAny>(self: Self): {
    transform: {
        output: (value: any) => any;
        input: <A>(a: A) => A;
    };
};
export type SchemaFrom<Cls extends {
    Model: SchemaAny;
}> = Cls["Model"];
export type GetProps<Cls extends {
    Api: {
        props: PropertyRecord;
    };
}> = Cls["Api"]["props"];
export type GetProvidedProps<Cls extends {
    [schemaField]: {
        Api: {
            props: PropertyRecord;
        };
    };
}> = GetProps<Cls[schemaField]>;
export type EncodedFromApi<Cls extends {
    [schemaField]: SchemaAny;
}> = EncodedOf<Cls[schemaField]>;
export type ConstructorInputFromApi<Cls extends {
    [schemaField]: SchemaAny;
}> = ConstructorInputOf<Cls[schemaField]>;
export type OpaqueEncoded<OpaqueE, Schema> = Schema extends DefaultSchema<unknown, infer A, infer B, OpaqueE, infer C> ? DefaultSchema<unknown, A, B, OpaqueE, C> : never;
export declare function smartClassUnion<T extends Record<PropertyKey, SchemaUPI & {
    new (i: any): any;
}>>(members: T & EnforceNonEmptyRecord<T>, name?: string): S.SchemaDefaultSchema<any, (T & EnforceNonEmptyRecord<T> extends infer T_1 extends Record<PropertyKey, SchemaUPI> ? { [k in keyof T_1]: ParsedShapeOf<(T & EnforceNonEmptyRecord<T>)[k]>; } : never)[keyof T | keyof EnforceNonEmptyRecord<T>], (T & EnforceNonEmptyRecord<T> extends infer T_2 extends Record<PropertyKey, SchemaUPI> ? { [k_1 in keyof T_2]: ParsedShapeOf<(T & EnforceNonEmptyRecord<T>)[k_1]>; } : never)[keyof T | keyof EnforceNonEmptyRecord<T>], (T & EnforceNonEmptyRecord<T> extends infer T_3 extends Record<PropertyKey, SchemaUPI> ? { [k_2 in keyof T_3]: EncodedOf<(T & EnforceNonEmptyRecord<T>)[k_2]>; } : never)[keyof T | keyof EnforceNonEmptyRecord<T>], UnionApi<T & EnforceNonEmptyRecord<T>>> & {
    matchW: S.MatchW<T & EnforceNonEmptyRecord<T>, (T & EnforceNonEmptyRecord<T> extends infer T_4 extends Record<PropertyKey, SchemaUPI> ? { [k_3 in keyof T_4]: ParsedShapeOf<(T & EnforceNonEmptyRecord<T>)[k_3]>; } : never)[keyof T | keyof EnforceNonEmptyRecord<T>]>;
} & {
    matchS: S.MatchS<T & EnforceNonEmptyRecord<T>, (T & EnforceNonEmptyRecord<T> extends infer T_5 extends Record<PropertyKey, SchemaUPI> ? { [k_4 in keyof T_5]: ParsedShapeOf<(T & EnforceNonEmptyRecord<T>)[k_4]>; } : never)[keyof T | keyof EnforceNonEmptyRecord<T>]>;
} & SmartClassUnion<T & EnforceNonEmptyRecord<T>, (T & EnforceNonEmptyRecord<T> extends infer T_3 extends Record<PropertyKey, SchemaUPI> ? { [k_2 in keyof T_3]: EncodedOf<(T & EnforceNonEmptyRecord<T>)[k_2]>; } : never)[keyof T | keyof EnforceNonEmptyRecord<T>], (T & EnforceNonEmptyRecord<T> extends infer T_1 extends Record<PropertyKey, SchemaUPI> ? { [k in keyof T_1]: ParsedShapeOf<(T & EnforceNonEmptyRecord<T>)[k]>; } : never)[keyof T | keyof EnforceNonEmptyRecord<T>]>;
export declare function enhanceClassUnion<T extends Record<PropertyKey, SchemaUPI & {
    new (i: any): any;
}>, A, E, CI>(u: DefaultSchema<any, A, CI, E, UnionApi<T>>, name?: string): S.SchemaDefaultSchema<any, A, CI, E, UnionApi<T>> & {
    matchW: S.MatchW<T, { [k in keyof T]: ParsedShapeOf<T[k]>; }[keyof T]>;
} & {
    matchS: S.MatchS<T, { [k_1 in keyof T]: ParsedShapeOf<T[k_1]>; }[keyof T]>;
} & SmartClassUnion<T, E, A>;
export interface SmartClassUnion<T extends Record<PropertyKey, SchemaUPI & {
    new (i: any): any;
}>, Encoded, ParsedShape> {
    members: T;
    cas: {
        [Key in keyof T]: {
            new (i: ConstructorInputOf<T[Key]>): ParsedShape;
        };
    };
    mem: {
        [Key in keyof T]: T[Key];
    };
    of: {
        [Key in keyof T]: (i: ConstructorInputOf<T[Key]>) => InstanceType<T[Key]>;
    };
    of_: (i: ParsedShape) => ParsedShape;
    as: {
        [Key in keyof T]: (i: ConstructorInputOf<T[Key]>) => ParsedShape;
    };
    EParser: Parser.Parser<Encoded, any, ParsedShape>;
}
export declare function smartUnion<T extends Record<PropertyKey, SchemaUPI>>(members: T & EnforceNonEmptyRecord<T>): S.SchemaDefaultSchema<any, (T & EnforceNonEmptyRecord<T> extends infer T_1 extends Record<PropertyKey, SchemaUPI> ? { [k in keyof T_1]: ParsedShapeOf<(T & EnforceNonEmptyRecord<T>)[k]>; } : never)[keyof T | keyof EnforceNonEmptyRecord<T>], (T & EnforceNonEmptyRecord<T> extends infer T_2 extends Record<PropertyKey, SchemaUPI> ? { [k_1 in keyof T_2]: ParsedShapeOf<(T & EnforceNonEmptyRecord<T>)[k_1]>; } : never)[keyof T | keyof EnforceNonEmptyRecord<T>], (T & EnforceNonEmptyRecord<T> extends infer T_3 extends Record<PropertyKey, SchemaUPI> ? { [k_2 in keyof T_3]: EncodedOf<(T & EnforceNonEmptyRecord<T>)[k_2]>; } : never)[keyof T | keyof EnforceNonEmptyRecord<T>], UnionApi<T & EnforceNonEmptyRecord<T>>> & {
    matchW: S.MatchW<T & EnforceNonEmptyRecord<T>, (T & EnforceNonEmptyRecord<T> extends infer T_4 extends Record<PropertyKey, SchemaUPI> ? { [k_3 in keyof T_4]: ParsedShapeOf<(T & EnforceNonEmptyRecord<T>)[k_3]>; } : never)[keyof T | keyof EnforceNonEmptyRecord<T>]>;
} & {
    matchS: S.MatchS<T & EnforceNonEmptyRecord<T>, (T & EnforceNonEmptyRecord<T> extends infer T_5 extends Record<PropertyKey, SchemaUPI> ? { [k_4 in keyof T_5]: ParsedShapeOf<(T & EnforceNonEmptyRecord<T>)[k_4]>; } : never)[keyof T | keyof EnforceNonEmptyRecord<T>]>;
} & SmartUnion<T & EnforceNonEmptyRecord<T>, (T & EnforceNonEmptyRecord<T> extends infer T_3 extends Record<PropertyKey, SchemaUPI> ? { [k_2 in keyof T_3]: EncodedOf<(T & EnforceNonEmptyRecord<T>)[k_2]>; } : never)[keyof T | keyof EnforceNonEmptyRecord<T>], (T & EnforceNonEmptyRecord<T> extends infer T_1 extends Record<PropertyKey, SchemaUPI> ? { [k in keyof T_1]: ParsedShapeOf<(T & EnforceNonEmptyRecord<T>)[k]>; } : never)[keyof T | keyof EnforceNonEmptyRecord<T>]>;
export declare function enhanceUnion<T extends Record<PropertyKey, SchemaUPI>, A, E, CI>(u: DefaultSchema<any, A, CI, E, UnionApi<T>>): S.SchemaDefaultSchema<any, A, CI, E, UnionApi<T>> & {
    matchW: S.MatchW<T, { [k in keyof T]: ParsedShapeOf<T[k]>; }[keyof T]>;
} & {
    matchS: S.MatchS<T, { [k_1 in keyof T]: ParsedShapeOf<T[k_1]>; }[keyof T]>;
} & SmartUnion<T, E, A>;
export interface SmartUnion<T extends Record<PropertyKey, SchemaUPI>, Encoded, ParsedShape> {
    members: T;
    mem: {
        [Key in keyof T]: T[Key];
    };
    of: {
        [Key in keyof T]: (i: ConstructorInputOf<T[Key]>) => ParsedShapeOf<T[Key]>;
    };
    of_: (i: ParsedShape) => ParsedShape;
    as: {
        [Key in keyof T]: (i: ConstructorInputOf<T[Key]>) => Th.These<ConstructorErrorOf<T[Key]>, ParsedShape>;
    };
    EParser: Parser.Parser<Encoded, any, ParsedShape>;
}
/**
 * The Either's left is returned with the parser errors when the parser produces an invalid result
 * Otherwise right with the valid result.
 */
export declare function validate<X, A>(self: (a: X) => Th.These<any, A>): (a: X) => Either<CustomSchemaException, A>;
/**
 * Value: The value you want to submit after validation. e.g for text input: `ReasonableString`
 * InputValue: The internal value of the input, e.g for text input: `string`
 */
export type InputSchema<Value, InputValue> = DefaultSchema<unknown, Value, any, InputValue, any>;
/**
 * The Either's left is returned with the parser errors when the parser produces an invalid result
 * Otherwise right with the valid result.
 */
export declare function makeValidator<Value, InputValue>(self: InputSchema<Value, InputValue>): (a: InputValue) => import("@fp-ts/data/Either").Either<CustomSchemaException, Value>;
/**
 * The Either's left is returned with the parser errors when the parser produces an invalid result
 * Otherwise right with the valid result.
 */
export declare function makeValidatorFromUnknown<Value, InputValue>(self: InputSchema<Value, InputValue>): (a: unknown) => import("@fp-ts/data/Either").Either<CustomSchemaException, Value>;
export type ParsedShapeOfCustom<X extends Schema<any, any, any, any, any>> = ReturnType<X["_ParsedShape"]>;
export declare function OpaqueSchema<A, E = A, CI = A>(): {
    <OriginalA, ParserInput, Api>(self: DefaultSchema<any, OriginalA, any, any, Api>): S.SchemaDefaultSchema<ParserInput, A, CI, E, Api> & import("@effect-ts/system/Utils").UnionToIntersection<{ [k in keyof Api]: k extends "matchW" | "matchS" | "props" ? { [h in k]: Api[h]; } : never; }[keyof Api]> & {
        original: OriginalA;
    };
    <OriginalA_1, ParserInput_1, Api_1, A1 extends Record<PropertyKey, SchemaUPI & (new (i: any) => any)>, A2, A3>(self: S.SchemaDefaultSchema<any, OriginalA_1, any, any, Api_1> & import("@effect-ts/system/Utils").UnionToIntersection<{ [k_1 in keyof Api_1]: k_1 extends "matchW" | "matchS" | "props" ? { [h_1 in k_1]: Api_1[h_1]; } : never; }[keyof Api_1]> & SmartClassUnion<A1, A2, A3>): S.SchemaDefaultSchema<ParserInput_1, A, CI, E, Api_1> & import("@effect-ts/system/Utils").UnionToIntersection<{ [k_1 in keyof Api_1]: k_1 extends "matchW" | "matchS" | "props" ? { [h_1 in k_1]: Api_1[h_1]; } : never; }[keyof Api_1]> & SmartClassUnion<A1, A2, A3> & {
        original: OriginalA_1;
    };
};
export interface UnionBrand {
}
/**
 * Currently does not implement composition, but is useful as a quick set/modify.
 * @tsplus type PreparedLens
 */
export declare class PreparedLens<S, T> {
    private readonly s;
    readonly lens: Lens<S, T>;
    constructor(s: S, lens: Lens<S, T>);
    get: () => T;
    set: (t: T) => S;
}
/**
 * @tsplus fluent PreparedLens modify
 * @tsplus location "@effect-ts-app/boilerplate-prelude/schema/_schema"
 */
export declare function modify<S, T>(l: PreparedLens<S, T>, mod: (t: T) => T): S;
export declare function makePreparedLenses<S, Props extends PropertyRecord>(props: Props, s: S): {
    [K in keyof Props]: PreparedLens<S, ParsedShapeOf<Props[K]["_schema"]>>;
};
export * from "@effect-ts-app/schema";
export * from "./overrides.js";
export { array, nonEmptyArray, set } from "./overrides.js";
//# sourceMappingURL=_schema.d.ts.map