/**
 * @since 1.0.0
 */
import * as BigDecimal from "effect/BigDecimal";
import * as Brand from "effect/Brand";
import * as Cause from "effect/Cause";
import * as Chunk from "effect/Chunk";
import * as Data from "effect/Data";
import * as Duration from "effect/Duration";
import * as Effect from "effect/Effect";
import * as Either from "effect/Either";
import * as Equivalence from "effect/Equivalence";
import * as Exit from "effect/Exit";
import * as FiberId from "effect/FiberId";
import type { LazyArg } from "effect/Function";
import * as HashMap from "effect/HashMap";
import * as HashSet from "effect/HashSet";
import * as List from "effect/List";
import * as Option from "effect/Option";
import type { Pipeable } from "effect/Pipeable";
import * as Predicate from "effect/Predicate";
import * as ReadonlyArray from "effect/ReadonlyArray";
import * as Request from "effect/Request";
import * as Secret from "effect/Secret";
import type { Covariant, Equals, Invariant, Mutable, NoInfer, Simplify } from "effect/Types";
import type { Arbitrary } from "./Arbitrary.js";
import type { ParseOptions } from "./AST.js";
import * as AST from "./AST.js";
import * as ParseResult from "./ParseResult.js";
import * as Pretty from "./Pretty.js";
import type * as Serializable from "./Serializable.js";
/**
 * @since 1.0.0
 * @category symbol
 */
export declare const TypeId: unique symbol;
/**
 * @since 1.0.0
 * @category symbol
 */
export type TypeId = typeof TypeId;
/**
 * @category model
 * @since 1.0.0
 */
export interface Schema<out R, in out From, in out To = From> extends Schema.Variance<R, From, To>, Pipeable {
    readonly ast: AST.AST;
}
/**
 * @category hashing
 * @since 1.0.0
 */
export declare const hash: <R, I, A>(schema: Schema<R, I, A>) => number;
/**
 * @category formatting
 * @since 1.0.0
 */
export declare const format: <R, I, A>(schema: Schema<R, I, A>) => string;
/**
 * @since 1.0.0
 */
export declare namespace Schema {
    /**
     * @since 1.0.0
     */
    interface Variance<R, From, To> {
        readonly [TypeId]: {
            readonly R: Covariant<R>;
            readonly From: Invariant<From>;
            readonly To: Invariant<To>;
        };
    }
    /**
     * @since 1.0.0
     */
    type Context<S> = S extends Schema.Variance<infer R, any, any> ? R : never;
    /**
     * @since 1.0.0
     */
    type From<S> = S extends Schema.Variance<any, infer From, any> ? From : never;
    /**
     * @since 1.0.0
     */
    type To<S> = S extends Schema.Variance<any, any, infer To> ? To : never;
    /**
     * @since 1.0.0
     */
    type ToAsserts<S extends Schema<never, any>> = (input: unknown, options?: AST.ParseOptions) => asserts input is Schema.To<S>;
}
/**
 * @since 1.0.0
 */
export declare const from: <R, I, A>(schema: Schema<R, I, A>) => Schema<never, I, I>;
/**
 * @since 1.0.0
 */
export declare const to: <R, I, A>(schema: Schema<R, I, A>) => Schema<never, A, A>;
export { 
/**
 * @category validation
 * @since 1.0.0
 */
asserts, 
/**
 * @category decoding
 * @since 1.0.0
 */
decodeOption, 
/**
 * @category decoding
 * @since 1.0.0
 */
decodeSync, 
/**
 * @category decoding
 * @since 1.0.0
 */
decodeUnknownOption, 
/**
 * @category decoding
 * @since 1.0.0
 */
decodeUnknownSync, 
/**
 * @category encoding
 * @since 1.0.0
 */
encodeOption, 
/**
 * @category encoding
 * @since 1.0.0
 */
encodeSync, 
/**
 * @category encoding
 * @since 1.0.0
 */
encodeUnknownOption, 
/**
 * @category encoding
 * @since 1.0.0
 */
encodeUnknownSync, 
/**
 * @category validation
 * @since 1.0.0
 */
is, 
/**
 * @category validation
 * @since 1.0.0
 */
validateOption, 
/**
 * @category validation
 * @since 1.0.0
 */
validateSync } from "./Parser.js";
/**
 * @category encoding
 * @since 1.0.0
 */
export declare const encodeUnknown: <R, I, A>(schema: Schema<R, I, A>, options?: ParseOptions) => (u: unknown, overrideOptions?: ParseOptions) => Effect.Effect<R, ParseResult.ParseError, I>;
/**
 * @category encoding
 * @since 1.0.0
 */
export declare const encodeUnknownEither: <I, A>(schema: Schema<never, I, A>, options?: ParseOptions) => (u: unknown, overrideOptions?: ParseOptions) => Either.Either<ParseResult.ParseError, I>;
/**
 * @category encoding
 * @since 1.0.0
 */
export declare const encodeUnknownPromise: <I, A>(schema: Schema<never, I, A>, options?: ParseOptions) => (u: unknown, overrideOptions?: ParseOptions) => Promise<I>;
/**
 * @category encoding
 * @since 1.0.0
 */
export declare const encode: <R, I, A>(schema: Schema<R, I, A>, options?: ParseOptions) => (a: A, overrideOptions?: ParseOptions) => Effect.Effect<R, ParseResult.ParseError, I>;
/**
 * @category encoding
 * @since 1.0.0
 */
export declare const encodeEither: <I, A>(schema: Schema<never, I, A>, options?: ParseOptions) => (a: A, overrideOptions?: ParseOptions) => Either.Either<ParseResult.ParseError, I>;
/**
 * @category encoding
 * @since 1.0.0
 */
export declare const encodePromise: <I, A>(schema: Schema<never, I, A>, options?: ParseOptions) => (a: A, overrideOptions?: ParseOptions) => Promise<I>;
/**
 * @category decoding
 * @since 1.0.0
 */
export declare const decodeUnknown: <R, I, A>(schema: Schema<R, I, A>, options?: ParseOptions) => (u: unknown, overrideOptions?: ParseOptions) => Effect.Effect<R, ParseResult.ParseError, A>;
/**
 * @category decoding
 * @since 1.0.0
 */
export declare const decodeUnknownEither: <I, A>(schema: Schema<never, I, A>, options?: ParseOptions) => (u: unknown, overrideOptions?: ParseOptions) => Either.Either<ParseResult.ParseError, A>;
/**
 * @category decoding
 * @since 1.0.0
 */
export declare const decodeUnknownPromise: <I, A>(schema: Schema<never, I, A>, options?: ParseOptions) => (u: unknown, overrideOptions?: ParseOptions) => Promise<A>;
/**
 * @category decoding
 * @since 1.0.0
 */
export declare const decode: <R, I, A>(schema: Schema<R, I, A>, options?: ParseOptions) => (i: I, overrideOptions?: ParseOptions) => Effect.Effect<R, ParseResult.ParseError, A>;
/**
 * @category decoding
 * @since 1.0.0
 */
export declare const decodeEither: <I, A>(schema: Schema<never, I, A>, options?: ParseOptions) => (i: I, overrideOptions?: ParseOptions) => Either.Either<ParseResult.ParseError, A>;
/**
 * @category decoding
 * @since 1.0.0
 */
export declare const decodePromise: <I, A>(schema: Schema<never, I, A>, options?: ParseOptions) => (i: I, overrideOptions?: ParseOptions) => Promise<A>;
/**
 * @category validation
 * @since 1.0.0
 */
export declare const validate: <R, I, A>(schema: Schema<R, I, A>, options?: ParseOptions) => (u: unknown, overrideOptions?: ParseOptions) => Effect.Effect<R, ParseResult.ParseError, A>;
/**
 * @category validation
 * @since 1.0.0
 */
export declare const validateEither: <I, A>(schema: Schema<never, I, A>, options?: ParseOptions) => (u: unknown, overrideOptions?: ParseOptions) => Either.Either<ParseResult.ParseError, A>;
/**
 * @category validation
 * @since 1.0.0
 */
export declare const validatePromise: <I, A>(schema: Schema<never, I, A>, options?: ParseOptions) => (u: unknown, overrideOptions?: ParseOptions) => Promise<A>;
/**
 * Tests if a value is a `Schema`.
 *
 * @category guards
 * @since 1.0.0
 */
export declare const isSchema: (u: unknown) => u is Schema<unknown, unknown, unknown>;
/**
 * @category constructors
 * @since 1.0.0
 */
export declare const make: <R, I, A>(ast: AST.AST) => Schema<R, I, A>;
/**
 * @category constructors
 * @since 1.0.0
 */
export declare const literal: <Literals extends readonly AST.LiteralValue[]>(...literals: Literals) => Schema<never, Literals[number], Literals[number]>;
/**
 * @category constructors
 * @since 1.0.0
 */
export declare const uniqueSymbol: <S extends symbol>(symbol: S, annotations?: AST.Annotations) => Schema<never, S, S>;
/**
 * @category constructors
 * @since 1.0.0
 */
export declare const enums: <A extends {
    [x: string]: string | number;
}>(enums: A) => Schema<never, A[keyof A], A[keyof A]>;
/**
 * @since 1.0.0
 */
export type Join<T> = T extends [infer Head, ...infer Tail] ? `${Head & (string | number | bigint | boolean | null | undefined)}${Tail extends [] ? "" : Join<Tail>}` : never;
/**
 * @category constructors
 * @since 1.0.0
 */
export declare const templateLiteral: <T extends [Schema<never, any, any>, ...Schema<never, any, any>[]]>(...[head, ...tail]: T) => Schema<never, Join<{ [K in keyof T]: Schema.To<T[K]>; }>, Join<{ [K in keyof T]: Schema.To<T[K]>; }>>;
/**
 * @since 1.0.0
 */
export interface DeclareAnnotations<P extends ReadonlyArray<any>, A> extends DocAnnotations {
    readonly message?: AST.MessageAnnotation<A>;
    readonly typeId?: AST.TypeAnnotation | {
        id: AST.TypeAnnotation;
        annotation: unknown;
    };
    readonly arbitrary?: (...arbitraries: {
        readonly [K in keyof P]: Arbitrary<P[K]>;
    }) => Arbitrary<A>;
    readonly pretty?: (...pretties: {
        readonly [K in keyof P]: Pretty.Pretty<P[K]>;
    }) => Pretty.Pretty<A>;
    readonly equivalence?: (...equivalences: {
        readonly [K in keyof P]: Equivalence.Equivalence<P[K]>;
    }) => Equivalence.Equivalence<A>;
}
/**
 * The constraint `R extends Schema.Context<P[number]>` enforces dependencies solely from `typeParameters`.
 * This ensures that when you call `Schema.to` or `Schema.from`, you receive a schema with a `never` context.
 *
 * @category constructors
 * @since 1.0.0
 */
export declare const declare: {
    <A>(is: (input: unknown) => input is A, annotations?: DeclareAnnotations<readonly [], A>): Schema<never, A>;
    <const P extends ReadonlyArray<Schema<any, any>>, R extends Schema.Context<P[number]>, I, A>(typeParameters: P, decodeUnknown: (...typeParameters: P) => (input: unknown, options: ParseOptions, ast: AST.Declaration) => Effect.Effect<R, ParseResult.ParseIssue, A>, encodeUnknown: (...typeParameters: P) => (input: unknown, options: ParseOptions, ast: AST.Declaration) => Effect.Effect<R, ParseResult.ParseIssue, I>, annotations?: DeclareAnnotations<{
        readonly [K in keyof P]: Schema.To<P[K]>;
    }, A>): Schema<Schema.Context<P[number]>, I, A>;
};
/**
 * @category type id
 * @since 1.0.0
 */
export declare const BrandTypeId: unique symbol;
/**
 * @category constructors
 * @since 1.0.0
 */
export declare const fromBrand: <C extends Brand.Brand<string | symbol>>(constructor: Brand.Brand.Constructor<C>, options?: FilterAnnotations<Brand.Brand.Unbranded<C>> | undefined) => <R, I, A extends Brand.Brand.Unbranded<C>>(self: Schema<R, I, A>) => Schema<R, I, A & C>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const InstanceOfTypeId: unique symbol;
/**
 * @category constructors
 * @since 1.0.0
 */
export declare const instanceOf: <A extends abstract new (...args: any) => any>(constructor: A, options?: DeclareAnnotations<[], InstanceType<A>> | undefined) => Schema<never, InstanceType<A>, InstanceType<A>>;
declare const _undefined: Schema<never, undefined>;
declare const _void: Schema<never, void>;
declare const _null: Schema<never, null>;
export { 
/**
 * @category primitives
 * @since 1.0.0
 */
_null as null, 
/**
 * @category primitives
 * @since 1.0.0
 */
_undefined as undefined, 
/**
 * @category primitives
 * @since 1.0.0
 */
_void as void };
/**
 * @category primitives
 * @since 1.0.0
 */
export declare const never: Schema<never, never>;
/**
 * @category primitives
 * @since 1.0.0
 */
export declare const unknown: Schema<never, unknown>;
/**
 * @category primitives
 * @since 1.0.0
 */
export declare const any: Schema<never, any>;
/**
 * @category primitives
 * @since 1.0.0
 */
export declare const string: Schema<never, string>;
/**
 * @category primitives
 * @since 1.0.0
 */
export declare const number: Schema<never, number>;
/**
 * @category primitives
 * @since 1.0.0
 */
export declare const boolean: Schema<never, boolean>;
/**
 * @category primitives
 * @since 1.0.0
 */
export declare const bigintFromSelf: Schema<never, bigint>;
/**
 * @category primitives
 * @since 1.0.0
 */
export declare const symbolFromSelf: Schema<never, symbol>;
/**
 * @category primitives
 * @since 1.0.0
 */
export declare const object: Schema<never, object>;
/**
 * @category combinators
 * @since 1.0.0
 */
export declare const union: <Members extends readonly Schema<any, any, any>[]>(...members: Members) => Schema<Schema.Context<Members[number]>, Schema.From<Members[number]>, Schema.To<Members[number]>>;
/**
 * @category combinators
 * @since 1.0.0
 */
export declare const nullable: <R, I, A>(self: Schema<R, I, A>) => Schema<R, I | null, A | null>;
/**
 * @category combinators
 * @since 1.0.0
 */
export declare const orUndefined: <R, I, A>(self: Schema<R, I, A>) => Schema<R, I | undefined, A | undefined>;
/**
 * @category combinators
 * @since 1.0.0
 */
export declare const nullish: <R, I, A>(self: Schema<R, I, A>) => Schema<R, I | null | undefined, A | null | undefined>;
/**
 * @category combinators
 * @since 1.0.0
 */
export declare const keyof: <R, I, A>(schema: Schema<R, I, A>) => Schema<never, keyof A, keyof A>;
/**
 * @category combinators
 * @since 1.0.0
 */
export declare const tuple: <Elements extends readonly Schema<any, any, any>[]>(...elements: Elements) => Schema<Schema.Context<Elements[number]>, { readonly [K in keyof Elements]: Schema.From<Elements[K]>; }, { readonly [K_1 in keyof Elements]: Schema.To<Elements[K_1]>; }>;
/**
 * @category combinators
 * @since 1.0.0
 */
export declare const rest: <R2, IB, B>(rest: Schema<R2, IB, B>) => <R1, I extends readonly any[], A extends readonly any[]>(self: Schema<R1, I, A>) => Schema<R2 | R1, readonly [...I, ...IB[]], readonly [...A, ...B[]]>;
/**
 * @category combinators
 * @since 1.0.0
 */
export declare const element: <R2, IB, B>(element: Schema<R2, IB, B>) => <R1, I extends readonly any[], A extends readonly any[]>(self: Schema<R1, I, A>) => Schema<R2 | R1, readonly [...I, IB], readonly [...A, B]>;
/**
 * @category combinators
 * @since 1.0.0
 */
export declare const optionalElement: <R2, IB, B>(element: Schema<R2, IB, B>) => <R1, I extends readonly any[], A extends readonly any[]>(self: Schema<R1, I, A>) => Schema<R2 | R1, readonly [...I, IB?], readonly [...A, B?]>;
/**
 * @category combinators
 * @since 1.0.0
 */
export declare const array: <R, I, A>(item: Schema<R, I, A>) => Schema<R, readonly I[], readonly A[]>;
/**
 * @category combinators
 * @since 1.0.0
 */
export declare const nonEmptyArray: <R, I, A>(item: Schema<R, I, A>) => Schema<R, readonly [I, ...I[]], readonly [A, ...A[]]>;
/**
 * @since 1.0.0
 */
export interface PropertySignature<R, From, FromIsOptional, To, ToIsOptional> extends Schema.Variance<R, From, To>, Pipeable {
    readonly FromIsOptional: FromIsOptional;
    readonly ToIsOptional: ToIsOptional;
}
/**
 * @since 1.0.0
 */
export declare const propertySignatureAnnotations: (annotations: DocAnnotations) => <S extends Schema<any, any, any> | Schema<any, never, never> | PropertySignature<any, any, boolean, any, boolean> | PropertySignature<any, never, boolean, never, boolean> | ConstructorPropertyDescriptor<any, any, any> | MapFromPropertyDescriptor<any, any, any, any>>(self: S) => S extends Schema<infer R, infer I, infer A> ? PropertySignature<R, I, false, A, false> : S;
/**
 * @category optional
 * @since 1.0.0
 */
export declare const optionalToRequired: <R, I, A, B>(from: Schema<R, I, A>, to: Schema<never, B, B>, decode: (o: Option.Option<A>) => B, encode: (b: B) => Option.Option<A>, options?: DocAnnotations) => PropertySignature<R, I, true, B, false>;
/**
 * @since 1.0.0
 */
export declare const optional: {
    <R, I, A>(schema: Schema<R, I, A>, options: {
        readonly exact: true;
        readonly default: () => A;
        readonly nullable: true;
    }): PropertySignature<R, I | null, true, A, false>;
    <R, I, A>(schema: Schema<R, I, A>, options: {
        readonly exact: true;
        readonly default: () => A;
    }): PropertySignature<R, I, true, A, false>;
    <R, I, A>(schema: Schema<R, I, A>, options: {
        readonly exact: true;
        readonly nullable: true;
        readonly as: "Option";
    }): PropertySignature<R, I | null, true, Option.Option<A>, false>;
    <R, I, A>(schema: Schema<R, I, A>, options: {
        readonly exact: true;
        readonly as: "Option";
    }): PropertySignature<R, I, true, Option.Option<A>, false>;
    <R, I, A>(schema: Schema<R, I, A>, options: {
        readonly exact: true;
    }): PropertySignature<R, I, true, A, true>;
    <R, I, A>(schema: Schema<R, I, A>, options: {
        readonly default: () => A;
        readonly nullable: true;
    }): PropertySignature<R, I | null | undefined, true, A, false>;
    <R, I, A>(schema: Schema<R, I, A>, options: {
        readonly nullable: true;
        readonly as: "Option";
    }): PropertySignature<R, I | undefined | null, true, Option.Option<A>, false>;
    <R, I, A>(schema: Schema<R, I, A>, options: {
        readonly as: "Option";
    }): PropertySignature<R, I | undefined, true, Option.Option<A>, false>;
    <R, I, A>(schema: Schema<R, I, A>, options: {
        readonly default: () => A;
    }): PropertySignature<R, I | undefined, true, A, false>;
    <R, I, A>(schema: Schema<R, I, A>): PropertySignature<R, I | undefined, true, A | undefined, true>;
};
/**
 * @since 1.0.0
 */
export type FromOptionalKeys<Fields> = {
    [K in keyof Fields]: Fields[K] extends PropertySignature<any, any, true, any, boolean> | PropertySignature<any, never, true, never, boolean> ? K : never;
}[keyof Fields];
/**
 * @since 1.0.0
 */
export type ToOptionalKeys<Fields> = {
    [K in keyof Fields]: Fields[K] extends PropertySignature<any, any, boolean, any, true> | PropertySignature<any, never, boolean, never, true> ? K : never;
}[keyof Fields];
/**
 * @since 1.0.0
 */
export type StructFields = Record<PropertyKey, Schema<any, any, any> | Schema<any, never, never> | PropertySignature<any, any, boolean, any, boolean> | PropertySignature<any, never, boolean, never, boolean> | ConstructorPropertyDescriptor<any, any, any> | MapFromPropertyDescriptor<any, any, any, any>>;
type GetKey<K extends keyof T, T extends StructFields> = T[K] extends MapFromPropertyDescriptor<any, any, any, any> ? T[K]["mapFrom"] : K;
/**
 * @since 1.0.0
 */
export type FromStruct<Fields extends StructFields> = {
    readonly [K in Exclude<keyof Fields, FromOptionalKeys<Fields>> as GetKey<K, Fields>]: Schema.From<Fields[K]>;
} & {
    readonly [K in FromOptionalKeys<Fields> as GetKey<K, Fields>]?: Schema.From<Fields[K]>;
};
/**
 * @since 1.0.0
 */
export type ToStruct<Fields extends StructFields> = {
    readonly [K in Exclude<keyof Fields, ToOptionalKeys<Fields>>]: Schema.To<Fields[K]>;
} & {
    readonly [K in ToOptionalKeys<Fields>]?: Schema.To<Fields[K]>;
};
/**
 * @category combinators
 * @since 1.0.0
 */
export declare const struct: <Fields extends StructFields>(fields: Fields) => Schema<Schema.Context<Fields[keyof Fields]>, Simplify<FromStruct<Fields>>, Simplify<ToStruct<Fields>>>;
/**
 * @category struct transformations
 * @since 1.0.0
 */
export declare const pick: <A, Keys extends readonly (keyof A)[]>(...keys: Keys) => <R, I extends { [K in keyof A]?: any; }>(self: Schema<R, I, A>) => Schema<R, Simplify<Pick<I, Keys[number]>>, Simplify<Pick<A, Keys[number]>>>;
/**
 * @category struct transformations
 * @since 1.0.0
 */
export declare const omit: <A, Keys extends readonly (keyof A)[]>(...keys: Keys) => <R, I extends { [K in keyof A]?: any; }>(self: Schema<R, I, A>) => Schema<R, Simplify<Omit<I, Keys[number]>>, Simplify<Omit<A, Keys[number]>>>;
/**
 * @category struct transformations
 * @since 1.0.0
 */
export declare const pluck: {
    <A, K extends keyof A>(key: K): <R, I>(schema: Schema<R, I, A>) => Schema<R, I, A[K]>;
    <R, I, A, K extends keyof A>(schema: Schema<R, I, A>, key: K): Schema<R, I, A[K]>;
};
/**
 * @category model
 * @since 1.0.0
 */
export interface BrandSchema<R, I, A extends Brand.Brand<any>> extends Schema<R, I, A>, Brand.Brand.Constructor<A> {
}
/**
 * Returns a nominal branded schema by applying a brand to a given schema.
 *
 * ```
 * Schema<A> + B -> Schema<A & Brand<B>>
 * ```
 *
 * @param self - The input schema to be combined with the brand.
 * @param brand - The brand to apply.
 *
 * @example
 * import * as Schema from "@effect/schema/Schema"
 *
 * const Int = Schema.number.pipe(Schema.int(), Schema.brand("Int"))
 * type Int = Schema.Schema.To<typeof Int> // number & Brand<"Int">
 *
 * @category combinators
 * @since 1.0.0
 */
export declare const brand: <B extends string | symbol, A>(brand: B, options?: DocAnnotations) => <I>(self: Schema<never, I, A>) => BrandSchema<never, I, A & Brand.Brand<B>>;
/**
 * @category combinators
 * @since 1.0.0
 */
export declare const partial: <R, I, A>(self: Schema<R, I, A>) => Schema<R, Simplify<Partial<I>>, Simplify<Partial<A>>>;
/**
 * @category combinators
 * @since 1.0.0
 */
export declare const required: <R, I, A>(self: Schema<R, I, A>) => Schema<R, Simplify<Required<I>>, Simplify<Required<A>>>;
/**
 * Creates a new schema with shallow mutability applied to its properties.
 *
 * @param schema - The original schema to make properties mutable (shallowly).
 *
 * @category combinators
 * @since 1.0.0
 */
export declare const mutable: <R, I, A>(schema: Schema<R, I, A>) => Schema<R, Simplify<Mutable<I>>, Simplify<Mutable<A>>>;
/**
 * @category combinators
 * @since 1.0.0
 */
export declare const record: <R1, IK extends string | symbol, AK extends IK, R2, IV, AV>(key: Schema<R1, IK, AK>, value: Schema<R2, IV, AV>) => Schema<R1 | R2, { readonly [k in IK]: IV; }, { readonly [k_1 in AK]: AV; }>;
/**
 * @category combinators
 * @since 1.0.0
 */
export declare const extend: {
    <R2, IB, B>(that: Schema<R2, IB, B>): <R1, I, A>(self: Schema<R1, I, A>) => Schema<R1 | R2, Simplify<I & IB>, Simplify<A & B>>;
    <R1, I, A, R2, IB, B>(self: Schema<R1, I, A>, that: Schema<R2, IB, B>): Schema<R1 | R2, Simplify<I & IB>, Simplify<A & B>>;
};
/**
 * @category combinators
 * @since 1.0.0
 */
export declare const compose: {
    <R2, B, C>(bc: Schema<R2, B, C>): <R1, A>(ab: Schema<R1, A, B>) => Schema<R1 | R2, A, C>;
    <R2, C, D>(bc: Schema<R2, C, D>, options: {
        strict: false;
    }): <R1, A, B>(ab: Schema<R1, A, B>) => Schema<R1 | R2, A, D>;
    <R1, A, B, R2, C>(ab: Schema<R1, A, B>, cd: Schema<R2, B, C>): Schema<R1 | R2, A, C>;
    <R1, A, B, R2, C, D>(ab: Schema<R1, A, B>, cd: Schema<R2, C, D>, options: {
        strict: false;
    }): Schema<R1 | R2, A, D>;
};
/**
 * @category combinators
 * @since 1.0.0
 */
export declare const suspend: <R, I, A = I>(f: () => Schema<R, I, A>, annotations?: AST.Annotations) => Schema<R, I, A>;
/**
 * @category combinators
 * @since 1.0.0
 */
export declare function filter<A>(f: (a: A, options: ParseOptions, self: AST.Refinement) => Option.Option<ParseResult.ParseIssue>, options?: FilterAnnotations<A>): <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
export declare function filter<C extends A, B extends A, A = C>(refinement: Predicate.Refinement<A, B>, options?: FilterAnnotations<A>): <R, I>(self: Schema<R, I, C>) => Schema<R, I, C & B>;
export declare function filter<A>(predicate: Predicate.Predicate<NoInfer<A>>, options?: FilterAnnotations<NoInfer<A>>): <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * Create a new `Schema` by transforming the input and output of an existing `Schema`
 * using the provided decoding functions.
 *
 * @category combinators
 * @since 1.0.0
 */
export declare const transformOrFail: {
    <R2, C, D, B, R3, R4>(to: Schema<R2, C, D>, decode: (b: B, options: ParseOptions, ast: AST.Transform) => Effect.Effect<R3, ParseResult.ParseIssue, C>, encode: (c: C, options: ParseOptions, ast: AST.Transform) => Effect.Effect<R4, ParseResult.ParseIssue, B>): <R1, A>(self: Schema<R1, A, B>) => Schema<R1 | R2 | R3 | R4, A, D>;
    <R2, C, D, B, R3, R4>(to: Schema<R2, C, D>, decode: (b: B, options: ParseOptions, ast: AST.Transform) => Effect.Effect<R3, ParseResult.ParseIssue, unknown>, encode: (c: C, options: ParseOptions, ast: AST.Transform) => Effect.Effect<R4, ParseResult.ParseIssue, unknown>, options: {
        strict: false;
    }): <R1, A>(self: Schema<R1, A, B>) => Schema<R1 | R2 | R3 | R4, A, D>;
    <R1, A, B, R2, C, D, R3, R4>(from: Schema<R1, A, B>, to: Schema<R2, C, D>, decode: (b: B, options: ParseOptions, ast: AST.Transform) => Effect.Effect<R3, ParseResult.ParseIssue, C>, encode: (c: C, options: ParseOptions, ast: AST.Transform) => Effect.Effect<R4, ParseResult.ParseIssue, B>): Schema<R1 | R2 | R3 | R4, A, D>;
    <R1, A, B, R2, C, D, R3, R4>(from: Schema<R1, A, B>, to: Schema<R2, C, D>, decode: (b: B, options: ParseOptions, ast: AST.Transform) => Effect.Effect<R3, ParseResult.ParseIssue, unknown>, encode: (c: C, options: ParseOptions, ast: AST.Transform) => Effect.Effect<R4, ParseResult.ParseIssue, unknown>, options: {
        strict: false;
    }): Schema<R1 | R2 | R3 | R4, A, D>;
};
/**
 * Create a new `Schema` by transforming the input and output of an existing `Schema`
 * using the provided mapping functions.
 *
 * @category combinators
 * @since 1.0.0
 */
export declare const transform: {
    <R2, C, D, B>(to: Schema<R2, C, D>, decode: (b: B) => C, encode: (c: C) => B): <R1, A>(self: Schema<R1, A, B>) => Schema<R1 | R2, A, D>;
    <R2, C, D, B>(to: Schema<R2, C, D>, decode: (b: B) => unknown, encode: (c: C) => unknown, options: {
        strict: false;
    }): <R1, A>(self: Schema<R1, A, B>) => Schema<R1 | R2, A, D>;
    <R1, A, B, R2, C, D>(from: Schema<R1, A, B>, to: Schema<R2, C, D>, decode: (b: B) => C, encode: (c: C) => B): Schema<R1 | R2, A, D>;
    <R1, A, B, R2, C, D>(from: Schema<R1, A, B>, to: Schema<R2, C, D>, decode: (b: B) => unknown, encode: (c: C) => unknown, options: {
        strict: false;
    }): Schema<R1 | R2, A, D>;
};
/**
 * Creates a new `Schema` which transforms literal values.
 *
 * @example
 * import * as S from "@effect/schema/Schema"
 *
 * const schema = S.transformLiteral(0, "a")
 *
 * assert.deepStrictEqual(S.decodeSync(schema)(0), "a")
 *
 * @category constructors
 * @since 1.0.0
 */
export declare const transformLiteral: <From extends AST.LiteralValue, To extends AST.LiteralValue>(from: From, to: To) => Schema<never, From, To>;
/**
 * Creates a new `Schema` which maps between corresponding literal values.
 *
 * @example
 * import * as S from "@effect/schema/Schema"
 *
 * const Animal = S.transformLiterals(
 *   [0, "cat"],
 *   [1, "dog"],
 *   [2, "cow"]
 * )
 *
 * assert.deepStrictEqual(S.decodeSync(Animal)(1), "dog")
 *
 * @category constructors
 * @since 1.0.0
 */
export declare const transformLiterals: <const A extends readonly (readonly [from: AST.LiteralValue, to: AST.LiteralValue])[]>(...pairs: A) => Schema<never, A[number][0], A[number][1]>;
/**
 * Attaches a property signature with the specified key and value to the schema.
 * This API is useful when you want to add a property to your schema which doesn't describe the shape of the input,
 * but rather maps to another schema, for example when you want to add a discriminant to a simple union.
 *
 * @param self - The input schema.
 * @param key - The name of the property to add to the schema.
 * @param value - The value of the property to add to the schema.
 *
 * @example
 * import * as S from "@effect/schema/Schema"
 * import { pipe } from "effect/Function"
 *
 * const Circle = S.struct({ radius: S.number })
 * const Square = S.struct({ sideLength: S.number })
 * const Shape = S.union(
 *   Circle.pipe(S.attachPropertySignature("kind", "circle")),
 *   Square.pipe(S.attachPropertySignature("kind", "square"))
 * )
 *
 * assert.deepStrictEqual(S.decodeSync(Shape)({ radius: 10 }), {
 *   kind: "circle",
 *   radius: 10
 * })
 *
 * @category combinators
 * @since 1.0.0
 */
export declare const attachPropertySignature: {
    <K extends PropertyKey, V extends AST.LiteralValue | symbol>(key: K, value: V, options?: DocAnnotations): <R, I, A extends object>(schema: Schema<R, I, A>) => Schema<R, I, Simplify<A & {
        readonly [k in K]: V;
    }>>;
    <R, I, A, K extends PropertyKey, V extends AST.LiteralValue | symbol>(schema: Schema<R, I, A>, key: K, value: V, options?: DocAnnotations): Schema<R, I, Simplify<A & {
        readonly [k in K]: V;
    }>>;
};
/**
 * @since 1.0.0
 */
export interface DocAnnotations extends AST.Annotations {
    readonly identifier?: AST.IdentifierAnnotation;
    readonly title?: AST.TitleAnnotation;
    readonly description?: AST.DescriptionAnnotation;
    readonly examples?: AST.ExamplesAnnotation;
    readonly default?: AST.DefaultAnnotation;
    readonly documentation?: AST.DocumentationAnnotation;
}
/**
 * @since 1.0.0
 */
export interface FilterAnnotations<A> extends DeclareAnnotations<readonly [A], A> {
    /**
     * Attaches a JSON Schema annotation to this refinement.
     *
     * If the schema is composed of more than one refinement, the corresponding annotations will be merged.
     */
    readonly jsonSchema?: AST.JSONSchemaAnnotation;
}
/**
 * @category annotations
 * @since 1.0.0
 */
export declare const annotations: (annotations: AST.Annotations) => <R, I, A>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category annotations
 * @since 1.0.0
 */
export declare const message: (message: AST.MessageAnnotation<unknown>) => <R, I, A>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category annotations
 * @since 1.0.0
 */
export declare const identifier: (identifier: AST.IdentifierAnnotation) => <R, I, A>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category annotations
 * @since 1.0.0
 */
export declare const title: (title: AST.TitleAnnotation) => <R, I, A>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category annotations
 * @since 1.0.0
 */
export declare const description: (description: AST.DescriptionAnnotation) => <R, I, A>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category annotations
 * @since 1.0.0
 */
export declare const examples: (examples: AST.ExamplesAnnotation) => <R, I, A>(self: Schema<R, I, A>) => Schema<R, I, A>;
declare const _default: <A>(value: A) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
export { 
/**
 * @category annotations
 * @since 1.0.0
 */
_default as default };
/**
 * @category annotations
 * @since 1.0.0
 */
export declare const documentation: (documentation: AST.DocumentationAnnotation) => <R, I, A>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * Attaches a JSON Schema annotation to a schema that represents a refinement.
 *
 * If the schema is composed of more than one refinement, the corresponding annotations will be merged.
 *
 * @category annotations
 * @since 1.0.0
 */
export declare const jsonSchema: (jsonSchema: AST.JSONSchemaAnnotation) => <R, I, A>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category annotations
 * @since 1.0.0
 */
export declare const equivalence: <A>(equivalence: Equivalence.Equivalence<A>) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
type Rename<A, M> = {
    [K in keyof A as K extends keyof M ? M[K] extends PropertyKey ? M[K] : never : K]: A[K];
};
/**
 * @category renaming
 * @since 1.0.0
 */
export declare const rename: {
    <A, const M extends {
        readonly [K in keyof A]?: PropertyKey;
    } & {
        readonly [K in Exclude<keyof M, keyof A>]: never;
    }>(mapping: M): <R, I>(self: Schema<R, I, A>) => Schema<R, I, Simplify<Rename<A, M>>>;
    <R, I, A, const M extends {
        readonly [K in keyof A]?: PropertyKey;
    } & {
        readonly [K in Exclude<keyof M, keyof A>]: never;
    }>(self: Schema<R, I, A>, mapping: M): Schema<R, I, Simplify<Rename<A, M>>>;
};
/**
 * @category type id
 * @since 1.0.0
 */
export declare const TrimmedTypeId: unique symbol;
/**
 * Verifies that a string contains no leading or trailing whitespaces.
 *
 * Note. This combinator does not make any transformations, it only validates.
 * If what you were looking for was a combinator to trim strings, then check out the `trim` combinator.
 *
 * @category string filters
 * @since 1.0.0
 */
export declare const trimmed: <A extends string>(options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const MaxLengthTypeId: unique symbol;
/**
 * @category type id
 * @since 1.0.0
 */
export type MaxLengthTypeId = typeof MaxLengthTypeId;
/**
 * @category string filters
 * @since 1.0.0
 */
export declare const maxLength: <A extends string>(maxLength: number, options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const MinLengthTypeId: unique symbol;
/**
 * @category type id
 * @since 1.0.0
 */
export type MinLengthTypeId = typeof MinLengthTypeId;
/**
 * @category string filters
 * @since 1.0.0
 */
export declare const minLength: <A extends string>(minLength: number, options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const PatternTypeId: unique symbol;
/**
 * @category string filters
 * @since 1.0.0
 */
export declare const pattern: <A extends string>(regex: RegExp, options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const StartsWithTypeId: unique symbol;
/**
 * @category string filters
 * @since 1.0.0
 */
export declare const startsWith: <A extends string>(startsWith: string, options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const EndsWithTypeId: unique symbol;
/**
 * @category string filters
 * @since 1.0.0
 */
export declare const endsWith: <A extends string>(endsWith: string, options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const IncludesTypeId: unique symbol;
/**
 * @category string filters
 * @since 1.0.0
 */
export declare const includes: <A extends string>(searchString: string, options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const LowercasedTypeId: unique symbol;
/**
 * Verifies that a string is lowercased.
 *
 * @category string filters
 * @since 1.0.0
 */
export declare const lowercased: <A extends string>(options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category string constructors
 * @since 1.0.0
 */
export declare const Lowercased: Schema<never, string>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const UppercasedTypeId: unique symbol;
/**
 * Verifies that a string is uppercased.
 *
 * @category string filters
 * @since 1.0.0
 */
export declare const uppercased: <A extends string>(options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category string constructors
 * @since 1.0.0
 */
export declare const Uppercased: Schema<never, string>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const LengthTypeId: unique symbol;
/**
 * @category type id
 * @since 1.0.0
 */
export type LengthTypeId = typeof LengthTypeId;
/**
 * @category string filters
 * @since 1.0.0
 */
export declare const length: <A extends string>(length: number, options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * A schema representing a single character.
 *
 * @category string constructors
 * @since 1.0.0
 */
export declare const Char: Schema<never, string, string>;
/**
 * @category string filters
 * @since 1.0.0
 */
export declare const nonEmpty: <A extends string>(options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * This schema converts a string to lowercase.
 *
 * @category string transformations
 * @since 1.0.0
 */
export declare const Lowercase: Schema<never, string>;
/**
 * This schema converts a string to uppercase.
 *
 * @category string transformations
 * @since 1.0.0
 */
export declare const Uppercase: Schema<never, string>;
/**
 * @category string constructors
 * @since 1.0.0
 */
export declare const Trimmed: Schema<never, string>;
/**
 * This schema allows removing whitespaces from the beginning and end of a string.
 *
 * @category string transformations
 * @since 1.0.0
 */
export declare const Trim: Schema<never, string>;
/**
 * Returns a achema that allows splitting a string into an array of strings.
 *
 * @category string transformations
 * @since 1.0.0
 */
export declare const split: (separator: string) => Schema<never, string, ReadonlyArray<string>>;
/**
 * @since 1.0.0
 */
export type ParseJsonOptions = {
    readonly reviver?: Parameters<typeof JSON.parse>[1];
    readonly replacer?: Parameters<typeof JSON.stringify>[1];
    readonly space?: Parameters<typeof JSON.stringify>[2];
};
/**
 * The `parseJson` combinator provides a method to convert JSON strings into the `unknown` type using the underlying
 * functionality of `JSON.parse`. It also utilizes `JSON.stringify` for encoding.
 *
 * You can optionally provide a `ParseJsonOptions` to configure both `JSON.parse` and `JSON.stringify` executions.
 *
 * Optionally, you can pass a schema `Schema<R, I, A>` to obtain an `A` type instead of `unknown`.
 *
 * @example
 * import * as S from "@effect/schema/Schema"
 *
 * assert.deepStrictEqual(S.decodeUnknownSync(S.parseJson())(`{"a":"1"}`), { a: "1" })
 * assert.deepStrictEqual(S.decodeUnknownSync(S.parseJson(S.struct({ a: S.NumberFromString })))(`{"a":"1"}`), { a: 1 })
 *
 * @category string transformations
 * @since 1.0.0
 */
export declare const parseJson: {
    <R, I, A>(schema: Schema<R, I, A>, options?: ParseJsonOptions): Schema<R, string, A>;
    (options?: ParseJsonOptions): Schema<never, string, unknown>;
};
/**
 * @category string constructors
 * @since 1.0.0
 */
export declare const NonEmpty: Schema<never, string>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const UUIDTypeId: unique symbol;
/**
 * Represents a Universally Unique Identifier (UUID).
 *
 * This schema ensures that the provided string adheres to the standard UUID format.
 *
 * @category string constructors
 * @since 1.0.0
 */
export declare const UUID: Schema<never, string>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const ULIDTypeId: unique symbol;
/**
 * Represents a Universally Unique Lexicographically Sortable Identifier (ULID).
 *
 * ULIDs are designed to be compact, URL-safe, and ordered, making them suitable for use as identifiers.
 * This schema ensures that the provided string adheres to the standard ULID format.
 *
 * @category string constructors
 * @since 1.0.0
 */
export declare const ULID: Schema<never, string>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const FiniteTypeId: unique symbol;
/**
 * Ensures that the provided value is a finite number.
 *
 * This schema filters out non-finite numeric values, allowing only finite numbers to pass through.
 *
 * @category number filters
 * @since 1.0.0
 */
export declare const finite: <A extends number>(options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const GreaterThanTypeId: unique symbol;
/**
 * @category type id
 * @since 1.0.0
 */
export type GreaterThanTypeId = typeof GreaterThanTypeId;
/**
 * This filter checks whether the provided number is greater than the specified minimum.
 *
 * @category number filters
 * @since 1.0.0
 */
export declare const greaterThan: <A extends number>(min: number, options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const GreaterThanOrEqualToTypeId: unique symbol;
/**
 * @category type id
 * @since 1.0.0
 */
export type GreaterThanOrEqualToTypeId = typeof GreaterThanOrEqualToTypeId;
/**
 * This filter checks whether the provided number is greater than or equal to the specified minimum.
 *
 * @category number filters
 * @since 1.0.0
 */
export declare const greaterThanOrEqualTo: <A extends number>(min: number, options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const MultipleOfTypeId: unique symbol;
/**
 * @category number filters
 * @since 1.0.0
 */
export declare const multipleOf: <A extends number>(divisor: number, options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const IntTypeId: unique symbol;
/**
 * @category type id
 * @since 1.0.0
 */
export type IntTypeId = typeof IntTypeId;
/**
 * @category number filters
 * @since 1.0.0
 */
export declare const int: <A extends number>(options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const LessThanTypeId: unique symbol;
/**
 * @category type id
 * @since 1.0.0
 */
export type LessThanTypeId = typeof LessThanTypeId;
/**
 * This filter checks whether the provided number is less than the specified maximum.
 *
 * @category number filters
 * @since 1.0.0
 */
export declare const lessThan: <A extends number>(max: number, options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const LessThanOrEqualToTypeId: unique symbol;
/**
 * @category type id
 * @since 1.0.0
 */
export type LessThanOrEqualToTypeId = typeof LessThanOrEqualToTypeId;
/**
 * This schema checks whether the provided number is less than or equal to the specified maximum.
 *
 * @category number filters
 * @since 1.0.0
 */
export declare const lessThanOrEqualTo: <A extends number>(max: number, options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const BetweenTypeId: unique symbol;
/**
 * @category type id
 * @since 1.0.0
 */
export type BetweenTypeId = typeof BetweenTypeId;
/**
 * This filter checks whether the provided number falls within the specified minimum and maximum values.
 *
 * @category number filters
 * @since 1.0.0
 */
export declare const between: <A extends number>(min: number, max: number, options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const NonNaNTypeId: unique symbol;
/**
 * @category number filters
 * @since 1.0.0
 */
export declare const nonNaN: <A extends number>(options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category number filters
 * @since 1.0.0
 */
export declare const positive: <A extends number>(options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category number filters
 * @since 1.0.0
 */
export declare const negative: <A extends number>(options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category number filters
 * @since 1.0.0
 */
export declare const nonPositive: <A extends number>(options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category number filters
 * @since 1.0.0
 */
export declare const nonNegative: <A extends number>(options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * Clamps a number between a minimum and a maximum value.
 *
 * @category number transformations
 * @since 1.0.0
 */
export declare const clamp: (minimum: number, maximum: number) => <R, I, A extends number>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * This schema transforms a `string` into a `number` by parsing the string using the `Number` function.
 *
 * It returns an error if the value can't be converted (for example when non-numeric characters are provided).
 *
 * The following special string values are supported: "NaN", "Infinity", "-Infinity".
 *
 * @category number constructors
 * @since 1.0.0
 */
export declare const NumberFromString: Schema<never, string, number>;
/**
 * @category number constructors
 * @since 1.0.0
 */
export declare const Finite: Schema<never, number>;
/**
 * @category number constructors
 * @since 1.0.0
 */
export declare const Int: Schema<never, number>;
/**
 * @category number constructors
 * @since 1.0.0
 */
export declare const NonNaN: Schema<never, number>;
/**
 * @category number constructors
 * @since 1.0.0
 */
export declare const Positive: Schema<never, number>;
/**
 * @category number constructors
 * @since 1.0.0
 */
export declare const Negative: Schema<never, number>;
/**
 * @category number constructors
 * @since 1.0.0
 */
export declare const NonPositive: Schema<never, number>;
/**
 * @category number constructors
 * @since 1.0.0
 */
export declare const NonNegative: Schema<never, number>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const JsonNumberTypeId: unique symbol;
/**
 * The `JsonNumber` is a schema for representing JSON numbers. It ensures that the provided value is a valid
 * number by filtering out `NaN` and `(+/-) Infinity`. This is useful when you want to validate and represent numbers in JSON
 * format.
 *
 * @example
 * import * as S from "@effect/schema/Schema"
 *
 * const is = S.is(S.JsonNumber)
 *
 * assert.deepStrictEqual(is(42), true)
 * assert.deepStrictEqual(is(Number.NaN), false)
 * assert.deepStrictEqual(is(Number.POSITIVE_INFINITY), false)
 * assert.deepStrictEqual(is(Number.NEGATIVE_INFINITY), false)
 *
 * @category number constructors
 * @since 1.0.0
 */
export declare const JsonNumber: Schema<never, number>;
/**
 * @category boolean transformations
 * @since 1.0.0
 */
export declare const Not: Schema<never, boolean>;
/**
 * This schema transforms a `string` into a `symbol`.
 *
 * @category symbol transformations
 * @since 1.0.0
 */
export declare const symbol: Schema<never, string, symbol>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const GreaterThanBigintTypeId: unique symbol;
/**
 * @category type id
 * @since 1.0.0
 */
export type GreaterThanBigintTypeId = typeof GreaterThanBigintTypeId;
/**
 * @category bigint filters
 * @since 1.0.0
 */
export declare const greaterThanBigint: <A extends bigint>(min: bigint, options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const GreaterThanOrEqualToBigintTypeId: unique symbol;
/**
 * @category type id
 * @since 1.0.0
 */
export type GreaterThanOrEqualToBigintTypeId = typeof GreaterThanOrEqualToBigintTypeId;
/**
 * @category bigint filters
 * @since 1.0.0
 */
export declare const greaterThanOrEqualToBigint: <A extends bigint>(min: bigint, options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const LessThanBigintTypeId: unique symbol;
/**
 * @category type id
 * @since 1.0.0
 */
export type LessThanBigintTypeId = typeof LessThanBigintTypeId;
/**
 * @category bigint filters
 * @since 1.0.0
 */
export declare const lessThanBigint: <A extends bigint>(max: bigint, options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const LessThanOrEqualToBigintTypeId: unique symbol;
/**
 * @category type id
 * @since 1.0.0
 */
export type LessThanOrEqualToBigintTypeId = typeof LessThanOrEqualToBigintTypeId;
/**
 * @category bigint filters
 * @since 1.0.0
 */
export declare const lessThanOrEqualToBigint: <A extends bigint>(max: bigint, options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const BetweenBigintTypeId: unique symbol;
/**
 * @category type id
 * @since 1.0.0
 */
export type BetweenBigintTypeId = typeof BetweenBigintTypeId;
/**
 * @category bigint filters
 * @since 1.0.0
 */
export declare const betweenBigint: <A extends bigint>(min: bigint, max: bigint, options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category bigint filters
 * @since 1.0.0
 */
export declare const positiveBigint: <A extends bigint>(options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category bigint filters
 * @since 1.0.0
 */
export declare const negativeBigint: <A extends bigint>(options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category bigint filters
 * @since 1.0.0
 */
export declare const nonNegativeBigint: <A extends bigint>(options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category bigint filters
 * @since 1.0.0
 */
export declare const nonPositiveBigint: <A extends bigint>(options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * Clamps a bigint between a minimum and a maximum value.
 *
 * @category bigint transformations
 * @since 1.0.0
 */
export declare const clampBigint: (minimum: bigint, maximum: bigint) => <R, I, A extends bigint>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * This schema transforms a `string` into a `bigint` by parsing the string using the `BigInt` function.
 *
 * It returns an error if the value can't be converted (for example when non-numeric characters are provided).
 *
 * @category bigint transformations
 * @since 1.0.0
 */
export declare const bigint: Schema<never, string, bigint>;
/**
 * @category bigint constructors
 * @since 1.0.0
 */
export declare const PositiveBigintFromSelf: Schema<never, bigint>;
/**
 * @category bigint constructors
 * @since 1.0.0
 */
export declare const PositiveBigint: Schema<never, string, bigint>;
/**
 * @category bigint constructors
 * @since 1.0.0
 */
export declare const NegativeBigintFromSelf: Schema<never, bigint>;
/**
 * @category bigint constructors
 * @since 1.0.0
 */
export declare const NegativeBigint: Schema<never, string, bigint>;
/**
 * @category bigint constructors
 * @since 1.0.0
 */
export declare const NonPositiveBigintFromSelf: Schema<never, bigint>;
/**
 * @category bigint constructors
 * @since 1.0.0
 */
export declare const NonPositiveBigint: Schema<never, string, bigint>;
/**
 * @category bigint constructors
 * @since 1.0.0
 */
export declare const NonNegativeBigintFromSelf: Schema<never, bigint>;
/**
 * @category bigint constructors
 * @since 1.0.0
 */
export declare const NonNegativeBigint: Schema<never, string, bigint>;
/**
 * This schema transforms a `number` into a `bigint` by parsing the number using the `BigInt` function.
 *
 * It returns an error if the value can't be safely encoded as a `number` due to being out of range.
 *
 * @category bigint transformations
 * @since 1.0.0
 */
export declare const BigintFromNumber: Schema<never, number, bigint>;
/**
 * @category Secret constructors
 * @since 1.0.0
 */
export declare const SecretFromSelf: Schema<never, Secret.Secret>;
declare const _Secret: Schema<never, string, Secret.Secret>;
export { 
/**
 * A schema that transforms a `string` into a `Secret`.
 *
 * @category Secret transformations
 * @since 1.0.0
 */
_Secret as Secret };
/**
 * @category Duration constructors
 * @since 1.0.0
 */
export declare const DurationFromSelf: Schema<never, Duration.Duration>;
/**
 * A schema that transforms a `bigint` tuple into a `Duration`.
 * Treats the value as the number of nanoseconds.
 *
 * @category Duration transformations
 * @since 1.0.0
 */
export declare const DurationFromNanos: Schema<never, bigint, Duration.Duration>;
/**
 * A schema that transforms a `number` tuple into a `Duration`.
 * Treats the value as the number of milliseconds.
 *
 * @category Duration transformations
 * @since 1.0.0
 */
export declare const DurationFromMillis: Schema<never, number, Duration.Duration>;
declare const _Duration: Schema<never, readonly [seconds: number, nanos: number], Duration.Duration>;
export { 
/**
 * A schema that transforms a `[number, number]` tuple into a `Duration`.
 *
 * @category Duration transformations
 * @since 1.0.0
 */
_Duration as Duration };
/**
 * Clamps a `Duration` between a minimum and a maximum value.
 *
 * @category Duration transformations
 * @since 1.0.0
 */
export declare const clampDuration: (minimum: Duration.DurationInput, maximum: Duration.DurationInput) => <R, I, A extends Duration.Duration>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const LessThanDurationTypeId: unique symbol;
/**
 * @category Duration filters
 * @since 1.0.0
 */
export declare const lessThanDuration: <A extends Duration.Duration>(max: Duration.DurationInput, options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const LessThanOrEqualToDurationTypeId: unique symbol;
/**
 * @category Duration filters
 * @since 1.0.0
 */
export declare const lessThanOrEqualToDuration: <A extends Duration.Duration>(max: Duration.DurationInput, options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const GreaterThanDurationTypeId: unique symbol;
/**
 * @category Duration filters
 * @since 1.0.0
 */
export declare const greaterThanDuration: <A extends Duration.Duration>(min: Duration.DurationInput, options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const GreaterThanOrEqualToDurationTypeId: unique symbol;
/**
 * @category Duration filters
 * @since 1.0.0
 */
export declare const greaterThanOrEqualToDuration: <A extends Duration.Duration>(min: Duration.DurationInput, options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const BetweenDurationTypeId: unique symbol;
/**
 * @category Duration filters
 * @since 1.0.0
 */
export declare const betweenDuration: <A extends Duration.Duration>(minimum: Duration.DurationInput, maximum: Duration.DurationInput, options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category Uint8Array constructors
 * @since 1.0.0
 */
export declare const Uint8ArrayFromSelf: Schema<never, Uint8Array>;
declare const _Uint8Array: Schema<never, ReadonlyArray<number>, Uint8Array>;
export { 
/**
 * A schema that transforms a `number` array into a `Uint8Array`.
 *
 * @category Uint8Array transformations
 * @since 1.0.0
 */
_Uint8Array as Uint8Array };
/**
 * @category Encoding transformations
 * @since 1.0.0
 */
export declare const Base64: Schema<never, string, Uint8Array>;
/**
 * @category Encoding transformations
 * @since 1.0.0
 */
export declare const Base64Url: Schema<never, string, Uint8Array>;
/**
 * @category Encoding transformations
 * @since 1.0.0
 */
export declare const Hex: Schema<never, string, Uint8Array>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const MinItemsTypeId: unique symbol;
/**
 * @category type id
 * @since 1.0.0
 */
export type MinItemsTypeId = typeof MinItemsTypeId;
/**
 * @category ReadonlyArray filters
 * @since 1.0.0
 */
export declare const minItems: <A>(n: number, options?: FilterAnnotations<readonly A[]> | undefined) => <R, I>(self: Schema<R, I, readonly A[]>) => Schema<R, I, readonly A[]>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const MaxItemsTypeId: unique symbol;
/**
 * @category type id
 * @since 1.0.0
 */
export type MaxItemsTypeId = typeof MaxItemsTypeId;
/**
 * @category ReadonlyArray filters
 * @since 1.0.0
 */
export declare const maxItems: <A>(n: number, options?: FilterAnnotations<readonly A[]> | undefined) => <R, I>(self: Schema<R, I, readonly A[]>) => Schema<R, I, readonly A[]>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const ItemsCountTypeId: unique symbol;
/**
 * @category type id
 * @since 1.0.0
 */
export type ItemsCountTypeId = typeof ItemsCountTypeId;
/**
 * @category ReadonlyArray filters
 * @since 1.0.0
 */
export declare const itemsCount: <A>(n: number, options?: FilterAnnotations<readonly A[]> | undefined) => <R, I>(self: Schema<R, I, readonly A[]>) => Schema<R, I, readonly A[]>;
/**
 * @category ReadonlyArray transformations
 * @since 1.0.0
 */
export declare const getNumberIndexedAccess: <R, I extends readonly any[], A extends readonly any[]>(self: Schema<R, I, A>) => Schema<R, I[number], A[number]>;
/**
 * Get the first element of a `ReadonlyArray`, or `None` if the array is empty.
 *
 * @category ReadonlyArray transformations
 * @since 1.0.0
 */
export declare const head: <R, I, A>(self: Schema<R, I, readonly A[]>) => Schema<R, I, Option.Option<A>>;
/**
 * Retrieves the first element of a `ReadonlyArray`.
 *
 * If the array is empty, it returns the `fallback` argument if provided; otherwise, it fails.
 *
 * @category ReadonlyArray transformations
 * @since 1.0.0
 */
export declare const headOr: <R, I, A>(self: Schema<R, I, readonly A[]>, fallback?: LazyArg<A> | undefined) => Schema<R, I, A>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const ValidDateTypeId: unique symbol;
/**
 * A filter that **excludes invalid** dates (e.g., `new Date("Invalid Date")` is rejected).
 *
 * @category Date filters
 * @since 1.0.0
 */
export declare const validDate: (options?: FilterAnnotations<Date>) => <R, I>(self: Schema<R, I, Date>) => Schema<R, I, Date>;
/**
 * Represents a schema for handling potentially **invalid** `Date` instances (e.g., `new Date("Invalid Date")` is not rejected).
 *
 * @category Date constructors
 * @since 1.0.0
 */
export declare const DateFromSelf: Schema<never, Date>;
/**
 * Represents a schema for handling only **valid** dates. For example, `new Date("Invalid Date")` is rejected, even though it is an instance of `Date`.
 *
 * @category Date constructors
 * @since 1.0.0
 */
export declare const ValidDateFromSelf: Schema<never, Date>;
/**
 * Represents a schema that converts a `string` into a (potentially invalid) `Date` (e.g., `new Date("Invalid Date")` is not rejected).
 *
 * @category Date transformations
 * @since 1.0.0
 */
export declare const DateFromString: Schema<never, string, Date>;
declare const _Date: Schema<never, string, Date>;
export { 
/**
 * A schema that transforms a `string` into a **valid** `Date`, ensuring that invalid dates, such as `new Date("Invalid Date")`, are rejected.
 *
 * @category Date transformations
 * @since 1.0.0
 */
_Date as Date };
/**
 * @category Option utils
 * @since 1.0.0
 */
export type OptionFrom<I> = {
    readonly _tag: "None";
} | {
    readonly _tag: "Some";
    readonly value: I;
};
/**
 * @category Option transformations
 * @since 1.0.0
 */
export declare const optionFromSelf: <R, I, A>(value: Schema<R, I, A>) => Schema<R, Option.Option<I>, Option.Option<A>>;
/**
 * @category Option transformations
 * @since 1.0.0
 */
export declare const option: <R, I, A>(value: Schema<R, I, A>) => Schema<R, OptionFrom<I>, Option.Option<A>>;
/**
 * @category Option transformations
 * @since 1.0.0
 */
export declare const optionFromNullable: <R, I, A>(value: Schema<R, I, A>) => Schema<R, I | null, Option.Option<A>>;
/**
 * @category Option transformations
 * @since 1.0.0
 */
export declare const optionFromNullish: <R, I, A>(value: Schema<R, I, A>, onNoneEncoding: null | undefined) => Schema<R, I | null | undefined, Option.Option<A>>;
/**
 * @category Option transformations
 * @since 1.0.0
 */
export declare const optionFromOrUndefined: <R, I, A>(value: Schema<R, I, A>) => Schema<R, I | undefined, Option.Option<A>>;
/**
 * @category Either utils
 * @since 1.0.0
 */
export type RightFrom<IA> = {
    readonly _tag: "Right";
    readonly right: IA;
};
/**
 * @category Either utils
 * @since 1.0.0
 */
export type LeftFrom<IE> = {
    readonly _tag: "Left";
    readonly left: IE;
};
/**
 * @category Either utils
 * @since 1.0.0
 */
export type EitherFrom<IE, IA> = LeftFrom<IE> | RightFrom<IA>;
/**
 * @category Either transformations
 * @since 1.0.0
 */
export declare const eitherFromSelf: <RE, IE, E, RA, IA, A>(left: Schema<RE, IE, E>, right: Schema<RA, IA, A>) => Schema<RE | RA, Either.Either<IE, IA>, Either.Either<E, A>>;
/**
 * @category Either transformations
 * @since 1.0.0
 */
export declare const either: <R1, IE, E, R2, IA, A>(left: Schema<R1, IE, E>, right: Schema<R2, IA, A>) => Schema<R1 | R2, EitherFrom<IE, IA>, Either.Either<E, A>>;
/**
 * @example
 * import * as Schema from "@effect/schema/Schema"
 *
 * // Schema<string | number, Either<string, number>>
 * Schema.eitherFromUnion(Schema.string, Schema.number)
 *
 * @category Either transformations
 * @since 1.0.0
 */
export declare const eitherFromUnion: <R1, EI, EA, R2, AI, AA>(left: Schema<R1, EI, EA>, right: Schema<R2, AI, AA>) => Schema<R1 | R2, EI | AI, Either.Either<EA, AA>>;
/**
 * @category ReadonlyMap transformations
 * @since 1.0.0
 */
export declare const readonlyMapFromSelf: <RK, IK, K, RV, IV, V>(key: Schema<RK, IK, K>, value: Schema<RV, IV, V>) => Schema<RK | RV, ReadonlyMap<IK, IV>, ReadonlyMap<K, V>>;
/**
 * @category ReadonlyMap transformations
 * @since 1.0.0
 */
export declare const readonlyMap: <R1, IK, K, R2, IV, V>(key: Schema<R1, IK, K>, value: Schema<R2, IV, V>) => Schema<R1 | R2, readonly (readonly [IK, IV])[], ReadonlyMap<K, V>>;
/**
 * @category ReadonlySet transformations
 * @since 1.0.0
 */
export declare const readonlySetFromSelf: <R, I, A>(item: Schema<R, I, A>) => Schema<R, ReadonlySet<I>, ReadonlySet<A>>;
/**
 * @category ReadonlySet transformations
 * @since 1.0.0
 */
export declare const readonlySet: <R, I, A>(item: Schema<R, I, A>) => Schema<R, readonly I[], ReadonlySet<A>>;
/**
 * @category BigDecimal constructors
 * @since 1.0.0
 */
export declare const BigDecimalFromSelf: Schema<never, BigDecimal.BigDecimal>;
declare const _BigDecimal: Schema<never, string, BigDecimal.BigDecimal>;
export { 
/**
 * @category BigDecimal transformations
 * @since 1.0.0
 */
_BigDecimal as BigDecimal };
/**
 * A schema that transforms a `number` into a `BigDecimal`.
 * When encoding, this Schema will produce incorrect results if the BigDecimal exceeds the 64-bit range of a number.
 *
 * @category BigDecimal transformations
 * @since 1.0.0
 */
export declare const BigDecimalFromNumber: Schema<never, number, BigDecimal.BigDecimal>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const GreaterThanBigDecimalTypeId: unique symbol;
/**
 * @category BigDecimal filters
 * @since 1.0.0
 */
export declare const greaterThanBigDecimal: <A extends BigDecimal.BigDecimal>(min: BigDecimal.BigDecimal, options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const GreaterThanOrEqualToBigDecimalTypeId: unique symbol;
/**
 * @category BigDecimal filters
 * @since 1.0.0
 */
export declare const greaterThanOrEqualToBigDecimal: <A extends BigDecimal.BigDecimal>(min: BigDecimal.BigDecimal, options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const LessThanBigDecimalTypeId: unique symbol;
/**
 * @category BigDecimal filters
 * @since 1.0.0
 */
export declare const lessThanBigDecimal: <A extends BigDecimal.BigDecimal>(max: BigDecimal.BigDecimal, options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const LessThanOrEqualToBigDecimalTypeId: unique symbol;
/**
 * @category BigDecimal filters
 * @since 1.0.0
 */
export declare const lessThanOrEqualToBigDecimal: <A extends BigDecimal.BigDecimal>(max: BigDecimal.BigDecimal, options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const PositiveBigDecimalTypeId: unique symbol;
/**
 * @category BigDecimal filters
 * @since 1.0.0
 */
export declare const positiveBigDecimal: <A extends BigDecimal.BigDecimal>(options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category BigDecimal constructors
 * @since 1.0.0
 */
export declare const PositiveBigDecimalFromSelf: Schema<never, BigDecimal.BigDecimal, BigDecimal.BigDecimal>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const NonNegativeBigDecimalTypeId: unique symbol;
/**
 * @category BigDecimal filters
 * @since 1.0.0
 */
export declare const nonNegativeBigDecimal: <A extends BigDecimal.BigDecimal>(options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category BigDecimal constructors
 * @since 1.0.0
 */
export declare const NonNegativeBigDecimalFromSelf: Schema<never, BigDecimal.BigDecimal, BigDecimal.BigDecimal>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const NegativeBigDecimalTypeId: unique symbol;
/**
 * @category BigDecimal filters
 * @since 1.0.0
 */
export declare const negativeBigDecimal: <A extends BigDecimal.BigDecimal>(options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category BigDecimal constructors
 * @since 1.0.0
 */
export declare const NegativeBigDecimalFromSelf: Schema<never, BigDecimal.BigDecimal, BigDecimal.BigDecimal>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const NonPositiveBigDecimalTypeId: unique symbol;
/**
 * @category BigDecimal filters
 * @since 1.0.0
 */
export declare const nonPositiveBigDecimal: <A extends BigDecimal.BigDecimal>(options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category BigDecimal constructors
 * @since 1.0.0
 */
export declare const NonPositiveBigDecimalFromSelf: Schema<never, BigDecimal.BigDecimal, BigDecimal.BigDecimal>;
/**
 * @category type id
 * @since 1.0.0
 */
export declare const BetweenBigDecimalTypeId: unique symbol;
/**
 * @category BigDecimal filters
 * @since 1.0.0
 */
export declare const betweenBigDecimal: <A extends BigDecimal.BigDecimal>(minimum: BigDecimal.BigDecimal, maximum: BigDecimal.BigDecimal, options?: FilterAnnotations<A> | undefined) => <R, I>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * Clamps a `BigDecimal` between a minimum and a maximum value.
 *
 * @category BigDecimal transformations
 * @since 1.0.0
 */
export declare const clampBigDecimal: (minimum: BigDecimal.BigDecimal, maximum: BigDecimal.BigDecimal) => <R, I, A extends BigDecimal.BigDecimal>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * Negates a `BigDecimal`.
 *
 * @category BigDecimal transformations
 * @since 1.0.0
 */
export declare const negateBigDecimal: <R, I, A extends BigDecimal.BigDecimal>(self: Schema<R, I, A>) => Schema<R, I, A>;
/**
 * @category Chunk transformations
 * @since 1.0.0
 */
export declare const chunkFromSelf: <R, I, A>(item: Schema<R, I, A>) => Schema<R, Chunk.Chunk<I>, Chunk.Chunk<A>>;
/**
 * @category Chunk transformations
 * @since 1.0.0
 */
export declare const chunk: <R, I, A>(item: Schema<R, I, A>) => Schema<R, readonly I[], Chunk.Chunk<A>>;
/**
 * @category Data transformations
 * @since 1.0.0
 */
export declare const dataFromSelf: <R, I extends readonly any[] | Readonly<Record<string, any>>, A extends readonly any[] | Readonly<Record<string, any>>>(item: Schema<R, I, A>) => Schema<R, Data.Data<I>, Data.Data<A>>;
/**
 * @category Data transformations
 * @since 1.0.0
 */
export declare const data: <R, I extends readonly any[] | Readonly<Record<string, any>>, A extends readonly any[] | Readonly<Record<string, any>>>(item: Schema<R, I, A>) => Schema<R, I, Data.Data<A>>;
type MissingSelfGeneric<Usage extends string, Params extends string = ""> = `Missing \`Self\` generic - use \`class Self extends ${Usage}<Self>()(${Params}{ ... })\``;
type _OptionalKeys<O> = {
    [K in keyof O]-?: {} extends Pick<O, K> ? K : never;
}[keyof O];
type FilterOptionalKeys<A> = Omit<A, _OptionalKeys<A>>;
/**
 * @category classes
 * @since 1.0.0
 */
export interface Class<R, I, A, C, Self, Fields, Inherited> extends Schema<R, I, Self> {
    new (...args: [R] extends [never] ? [
        props: Equals<C, {}> extends true ? void | {} : Equals<FilterOptionalKeys<C>, {}> extends true ? void | C : C,
        disableValidation?: boolean | undefined
    ] : [
        props: Equals<C, {}> extends true ? void | {} : Equals<FilterOptionalKeys<C>, {}> extends true ? void | C : C,
        disableValidation: true
    ]): A & Omit<Inherited, keyof A>;
    readonly struct: Schema<R, I, A>;
    readonly fields: Fields;
    readonly extend: <Extended>() => <FieldsB extends StructFields>(fields: FieldsB) => [unknown] extends [Extended] ? MissingSelfGeneric<"Base.extend"> : Class<R | Schema.Context<FieldsB[keyof FieldsB]>, Simplify<Omit<I, keyof FieldsB> & FromStruct<FieldsB>>, Simplify<Omit<A, keyof FieldsB> & ToStruct<FieldsB>>, Simplify<Omit<C, keyof FieldsB> & ToStructConstructor<FieldsB>>, Extended, Simplify<Omit<Fields, keyof FieldsB> & FieldsB>, Self>;
    readonly transformOrFail: <Transformed>() => <FieldsB extends StructFields, R2, R3>(fields: FieldsB, decode: (input: A, options: ParseOptions, ast: AST.Transform) => Effect.Effect<R2, ParseResult.ParseIssue, Omit<A, keyof FieldsB> & ToStruct<FieldsB>>, encode: (input: Simplify<Omit<A, keyof FieldsB> & ToStruct<FieldsB>>, options: ParseOptions, ast: AST.Transform) => Effect.Effect<R3, ParseResult.ParseIssue, A>) => [unknown] extends [Transformed] ? MissingSelfGeneric<"Base.transform"> : Class<R | Schema.Context<FieldsB[keyof FieldsB]> | R2 | R3, I, Simplify<Omit<A, keyof FieldsB> & ToStruct<FieldsB>>, Simplify<Omit<C, keyof FieldsB> & ToStructConstructor<FieldsB>>, Transformed, Simplify<Omit<Fields, keyof FieldsB> & FieldsB>, Self>;
    readonly transformOrFailFrom: <Transformed>() => <FieldsB extends StructFields, R2, R3>(fields: FieldsB, decode: (input: I, options: ParseOptions, ast: AST.Transform) => Effect.Effect<R2, ParseResult.ParseIssue, Omit<I, keyof FieldsB> & FromStruct<FieldsB>>, encode: (input: Simplify<Omit<I, keyof FieldsB> & FromStruct<FieldsB>>, options: ParseOptions, ast: AST.Transform) => Effect.Effect<R3, ParseResult.ParseIssue, I>) => [unknown] extends [Transformed] ? MissingSelfGeneric<"Base.transformFrom"> : Class<R | Schema.Context<FieldsB[keyof FieldsB]> | R2 | R3, I, Simplify<Omit<A, keyof FieldsB> & ToStruct<FieldsB>>, Simplify<Omit<C, keyof FieldsB> & ToStructConstructor<FieldsB>>, Transformed, Simplify<Omit<Fields, keyof FieldsB> & FieldsB>, Self>;
}
/**
 * @category classes
 * @since 1.0.0
 */
export declare const Class: <Self>() => <Fields extends StructFields>(fields: Fields) => [unknown] extends [Self] ? "Missing `Self` generic - use `class Self extends Class<Self>()({ ... })`" : Class<Schema.Context<Fields[keyof Fields]>, Simplify<FromStruct<Fields>>, Simplify<ToStruct<Fields>>, Simplify<ToStructConstructor<Fields>>, Self, Fields, {}>;
/**
 * @since 1.0.0
 */
export interface ConstructorPropertyDescriptor<R, From, To> extends Schema.Variance<R, From, To>, Pipeable {
    make: () => To;
}
/**
 * @since 1.0.0
 */
export interface MapFromPropertyDescriptor<R, From, To, FromKey extends PropertyKey = never> extends Schema.Variance<R, From, To>, Pipeable {
    mapFrom: FromKey;
}
/**
 * @category classes
 * @since 1.0.0
 */
export declare const withDefaultConstructor: {
    <S extends Schema<any, any, any>>(make: () => Schema.To<S>): (s: S) => S & ConstructorPropertyDescriptor<Schema.Context<S>, Schema.From<S>, Schema.To<S>>;
    <S extends Schema<any, any, any>>(s: S, make: () => Schema.To<S>): S & ConstructorPropertyDescriptor<Schema.Context<S>, Schema.From<S>, Schema.To<S>>;
};
/**
 * @category classes
 * @since 1.0.0
 */
export declare const mapFrom: {
    <S extends Schema<any, any, any>, FromKey extends PropertyKey>(from: FromKey): (s: S) => S & MapFromPropertyDescriptor<Schema.Context<S>, Schema.From<S>, Schema.To<S>, FromKey>;
    <S extends Schema<any, any, any>, FromKey extends PropertyKey>(s: S, from: FromKey): S & MapFromPropertyDescriptor<Schema.Context<S>, Schema.From<S>, Schema.To<S>, FromKey>;
};
/**
 * @since 1.0.0
 */
export type ToOptionalConstructorKeys<Fields> = {
    [K in keyof Fields]: Fields[K] extends ConstructorPropertyDescriptor<any, any, any> ? K : never;
}[keyof Fields];
/**
 * @since 1.0.0
 */
export type ToStructConstructor<Fields extends StructFields> = {
    readonly [K in Exclude<keyof Fields, ToOptionalKeys<Fields> | ToOptionalConstructorKeys<Fields>>]: Schema.To<Fields[K]>;
} & {
    readonly [K in ToOptionalKeys<Fields>]?: Schema.To<Fields[K]>;
} & {
    readonly [K in ToOptionalConstructorKeys<Fields>]?: Schema.To<Fields[K]>;
};
/**
 * @category classes
 * @since 1.0.0
 */
export declare const TaggedClass: <Self>() => <Tag extends string, Fields extends StructFields>(tag: Tag, fields: Fields) => [unknown] extends [Self] ? "Missing `Self` generic - use `class Self extends TaggedClass<Self>()(\"Tag\", { ... })`" : Class<Schema.Context<Fields[keyof Fields]>, Simplify<{
    readonly _tag: Tag;
} & { readonly [K in Exclude<keyof Fields, FromOptionalKeys<Fields>> as GetKey<K, Fields>]: Schema.From<Fields[K]>; } & { readonly [K_1 in FromOptionalKeys<Fields> as GetKey<K_1, Fields>]?: Schema.From<Fields[K_1]>; }>, Simplify<{
    readonly _tag: Tag;
} & { readonly [K_2 in Exclude<keyof Fields, ToOptionalKeys<Fields>>]: Schema.To<Fields[K_2]>; } & { readonly [K_3 in ToOptionalKeys<Fields>]?: Schema.To<Fields[K_3]>; }>, Simplify<ToStructConstructor<Fields>>, Self, Fields, {}>;
/**
 * @category classes
 * @since 1.0.0
 */
export declare const TaggedError: <Self>() => <Tag extends string, Fields extends StructFields>(tag: Tag, fields: Fields) => [unknown] extends [Self] ? "Missing `Self` generic - use `class Self extends TaggedError<Self>()(\"Tag\", { ... })`" : Class<Schema.Context<Fields[keyof Fields]>, Simplify<{
    readonly _tag: Tag;
} & { readonly [K in Exclude<keyof Fields, FromOptionalKeys<Fields>> as GetKey<K, Fields>]: Schema.From<Fields[K]>; } & { readonly [K_1 in FromOptionalKeys<Fields> as GetKey<K_1, Fields>]?: Schema.From<Fields[K_1]>; }>, Simplify<{
    readonly _tag: Tag;
} & { readonly [K_2 in Exclude<keyof Fields, ToOptionalKeys<Fields>>]: Schema.To<Fields[K_2]>; } & { readonly [K_3 in ToOptionalKeys<Fields>]?: Schema.To<Fields[K_3]>; }>, Simplify<ToStructConstructor<Fields>>, Self, Fields, Effect.Effect<never, Self, never> & Error>;
/**
 * @category classes
 * @since 1.0.0
 */
export interface TaggedRequest<Tag extends string, R, IS, S, RR, IE, E, IA, A> extends Request.Request<E, A>, Serializable.SerializableWithResult<R, IS, S, RR, IE, E, IA, A> {
    readonly _tag: Tag;
}
/**
 * @category classes
 * @since 1.0.0
 */
export declare namespace TaggedRequest {
    /**
     * @category classes
     * @since 1.0.0
     */
    type Any = TaggedRequest<string, any, any, any, any, any, any, any, any> | TaggedRequest<string, any, any, any, any, never, never, any, any>;
}
/**
 * @category classes
 * @since 1.0.0
 */
export declare const TaggedRequest: <Self>() => <Tag extends string, Fields extends StructFields, ER, EI, EA, AR, AI, AA>(tag: Tag, Failure: Schema<ER, EI, EA>, Success: Schema<AR, AI, AA>, fields: Fields) => [unknown] extends [Self] ? "Missing `Self` generic - use `class Self extends TaggedRequest<Self>()(\"Tag\", SuccessSchema, FailureSchema, { ... })`" : Class<Schema.Context<Fields[keyof Fields]>, Simplify<{
    readonly _tag: Tag;
} & { readonly [K in Exclude<keyof Fields, FromOptionalKeys<Fields>> as GetKey<K, Fields>]: Schema.From<Fields[K]>; } & { readonly [K_1 in FromOptionalKeys<Fields> as GetKey<K_1, Fields>]?: Schema.From<Fields[K_1]>; }>, Simplify<{
    readonly _tag: Tag;
} & { readonly [K_2 in Exclude<keyof Fields, ToOptionalKeys<Fields>>]: Schema.To<Fields[K_2]>; } & { readonly [K_3 in ToOptionalKeys<Fields>]?: Schema.To<Fields[K_3]>; }>, Simplify<ToStructConstructor<Fields>>, Self, Fields, TaggedRequest<Tag, Schema.Context<Fields[keyof Fields]>, Simplify<{
    readonly _tag: Tag;
} & { readonly [K in Exclude<keyof Fields, FromOptionalKeys<Fields>> as GetKey<K, Fields>]: Schema.From<Fields[K]>; } & { readonly [K_1 in FromOptionalKeys<Fields> as GetKey<K_1, Fields>]?: Schema.From<Fields[K_1]>; }>, Self, ER | AR, EI, EA, AI, AA>>;
/**
 * @category FiberId
 * @since 1.0.0
 */
export type FiberIdFrom = {
    readonly _tag: "Composite";
    readonly left: FiberIdFrom;
    readonly right: FiberIdFrom;
} | {
    readonly _tag: "None";
} | {
    readonly _tag: "Runtime";
    readonly id: number;
    readonly startTimeMillis: number;
};
/**
 * @category FiberId constructors
 * @since 1.0.0
 */
export declare const FiberIdFromSelf: Schema<never, FiberId.FiberId, FiberId.FiberId>;
declare const _FiberId: Schema<never, FiberIdFrom, FiberId.FiberId>;
export { 
/**
 * @category FiberId transformations
 * @since 1.0.0
 */
_FiberId as FiberId };
/**
 * @category Cause utils
 * @since 1.0.0
 */
export type CauseFrom<E> = {
    readonly _tag: "Die";
    readonly defect: unknown;
} | {
    readonly _tag: "Empty";
} | {
    readonly _tag: "Fail";
    readonly error: E;
} | {
    readonly _tag: "Interrupt";
    readonly fiberId: FiberIdFrom;
} | {
    readonly _tag: "Parallel";
    readonly left: CauseFrom<E>;
    readonly right: CauseFrom<E>;
} | {
    readonly _tag: "Sequential";
    readonly left: CauseFrom<E>;
    readonly right: CauseFrom<E>;
};
/**
 * @category Cause transformations
 * @since 1.0.0
 */
export declare const causeFromSelf: <R1, I, A, R2 = never>(error: Schema<R1, I, A>, defect?: Schema<R2, unknown, unknown>) => Schema<R1 | R2, Cause.Cause<I>, Cause.Cause<A>>;
/**
 * @category Cause transformations
 * @since 1.0.0
 */
export declare const cause: <R1, EI, E, R2 = never>(error: Schema<R1, EI, E>, defect?: Schema<R2, unknown, unknown>) => Schema<R1 | R2, CauseFrom<EI>, Cause.Cause<E>>;
/**
 * @category Exit utils
 * @since 1.0.0
 */
export type ExitFrom<E, A> = {
    readonly _tag: "Failure";
    readonly cause: CauseFrom<E>;
} | {
    readonly _tag: "Success";
    readonly value: A;
};
/**
 * @category Exit transformations
 * @since 1.0.0
 */
export declare const exitFromSelf: <RE, IE, E, RA, IA, A>(error: Schema<RE, IE, E>, value: Schema<RA, IA, A>, defect?: Schema<never, unknown, unknown>) => Schema<RE | RA, Exit.Exit<IE, IA>, Exit.Exit<E, A>>;
/**
 * @category Exit transformations
 * @since 1.0.0
 */
export declare const exit: <R1, IE, E, R2, IA, A, R3 = never>(error: Schema<R1, IE, E>, value: Schema<R2, IA, A>, defect?: Schema<R3, unknown, unknown>) => Schema<R1 | R2 | R3, ExitFrom<IE, IA>, Exit.Exit<E, A>>;
/**
 * @category HashSet transformations
 * @since 1.0.0
 */
export declare const hashSetFromSelf: <R, I, A>(item: Schema<R, I, A>) => Schema<R, HashSet.HashSet<I>, HashSet.HashSet<A>>;
/**
 * @category HashSet transformations
 * @since 1.0.0
 */
export declare const hashSet: <R, I, A>(item: Schema<R, I, A>) => Schema<R, readonly I[], HashSet.HashSet<A>>;
/**
 * @category HashMap transformations
 * @since 1.0.0
 */
export declare const hashMapFromSelf: <RK, IK, K, RV, IV, V>(key: Schema<RK, IK, K>, value: Schema<RV, IV, V>) => Schema<RK | RV, HashMap.HashMap<IK, IV>, HashMap.HashMap<K, V>>;
/**
 * @category HashMap transformations
 * @since 1.0.0
 */
export declare const hashMap: <R1, IK, K, R2, IV, V>(key: Schema<R1, IK, K>, value: Schema<R2, IV, V>) => Schema<R1 | R2, readonly (readonly [IK, IV])[], HashMap.HashMap<K, V>>;
/**
 * @category List transformations
 * @since 1.0.0
 */
export declare const listFromSelf: <R, I, A>(item: Schema<R, I, A>) => Schema<R, List.List<I>, List.List<A>>;
/**
 * @category List transformations
 * @since 1.0.0
 */
export declare const list: <R, I, A>(item: Schema<R, I, A>) => Schema<R, readonly I[], List.List<A>>;
//# sourceMappingURL=Schema.d.ts.map