/**
 * Describes data shapes and how unknown input becomes trusted values.
 *
 * A schema can validate input, decode it into an application type, and encode
 * that value back to another representation. This module contains the main
 * schema, codec, decoder, and encoder APIs, together with schemas for common
 * JavaScript values and Effect data types. It also supports refinements,
 * transformations, defaults, classes, JSON Schema generation, test data
 * generation, formatting, equivalence, optics, and differs derived from schema
 * definitions.
 *
 * @stability stable
 * @since 4.0.0
 */
import * as BigDecimal_ from "./BigDecimal.ts";
import type * as Brand from "./Brand.ts";
import * as ByteSize_ from "./ByteSize.ts";
import * as Cause_ from "./Cause.ts";
import * as Chunk_ from "./Chunk.ts";
import * as DateTime from "./DateTime.ts";
import type { Differ } from "./Differ.ts";
import * as Duration_ from "./Duration.ts";
import * as Effect from "./Effect.ts";
import type * as Equivalence from "./Equivalence.ts";
import * as Exit_ from "./Exit.ts";
import type { Formatter } from "./Formatter.ts";
import type * as Graph_ from "./Graph.ts";
import * as HashMap_ from "./HashMap.ts";
import * as HashSet_ from "./HashSet.ts";
import * as Cookies_ from "./http/Cookies.ts";
import * as Headers_ from "./http/Headers.ts";
import * as UrlParams_ from "./http/UrlParams.ts";
import { NodeInspectSymbol } from "./Inspectable.ts";
import { SchemaErrorTypeId } from "./internal/schemaError.ts";
import type * as JsonPatch from "./JsonPatch.ts";
import type * as JsonSchema from "./JsonSchema.ts";
import * as Dns_ from "./net/Dns.ts";
import * as Host_ from "./net/Host.ts";
import * as IpInterface_ from "./net/IpInterface.ts";
import * as IpNetwork_ from "./net/IpNetwork.ts";
import * as NetAddress_ from "./net/NetAddress.ts";
import type * as Optic_ from "./Optic.ts";
import * as Option_ from "./Option.ts";
import * as Order from "./Order.ts";
import * as Pipeable from "./Pipeable.ts";
import * as Record_ from "./Record.ts";
import * as Redacted_ from "./Redacted.ts";
import * as Result_ from "./Result.ts";
import * as SchemaAST from "./SchemaAST.ts";
import * as SchemaGetter from "./SchemaGetter.ts";
import * as SchemaIssue from "./SchemaIssue.ts";
import * as SchemaParser from "./SchemaParser.ts";
import type * as SchemaRepresentation from "./SchemaRepresentation.ts";
import * as SemVer_ from "./SemVer.ts";
import * as SemVerRange_ from "./SemVerRange.ts";
import type { StandardJSONSchemaV1, StandardSchemaV1 } from "./StandardSchema.ts";
import type { Assign, Lambda, Mutable, Simplify } from "./Struct.ts";
import * as Struct_ from "./Struct.ts";
import type { IsUnion, RequiredKeys } from "./Types.ts";
import type { Unify } from "./Unify.ts";
declare const TypeId = "~effect/Schema/Schema";
/**
 * Whether a schema field is required or optional within a struct.
 *
 * @see {@link optionalKey} — mark a struct field as optional
 * @see {@link optional} — mark a struct field as optional with `| undefined`
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export type Optionality = "required" | "optional";
/**
 * Whether a schema field is readonly or mutable within a struct.
 *
 * @see {@link mutableKey} — mark a struct field as mutable
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export type Mutability = "readonly" | "mutable";
/**
 * Whether a schema field has a constructor default value.
 *
 * @see {@link withConstructorDefault} — add a default to a schema field
 * @see {@link tag} — creates a literal field with a constructor default
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export type ConstructorDefault = "no-default" | "with-default";
/**
 * Options for `makeEffect`, `make`, and Class constructors.
 *
 * **When to use**
 *
 * Use when passing `disableChecks: true` to skip filters and checks while still
 * parsing types and structure. Pass `parseOptions` to control parsing behavior.
 *
 * @see {@link BottomWithoutNew.makeEffect}
 * @see {@link BottomWithoutNew.make}
 *
 * @stability stable
 * @category options
 * @since 3.13.4
 */
export interface MakeOptions {
    /**
     * The parse options to use for the schema.
     */
    readonly parseOptions?: SchemaAST.ParseOptions | undefined;
    /**
     * Whether to skip filters and checks. Types and structure are still parsed,
     * and constructor defaults still apply.
     */
    readonly disableChecks?: boolean | undefined;
}
/**
 * The fully-parameterized schema interface without a construct signature.
 * Exposes all 14 type parameters controlling type inference, mutability,
 * optionality, services, and transformation behavior.
 *
 * **When to use**
 *
 * Use as the base for schema interfaces that provide a specialized construct
 * signature.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface BottomWithoutNew<out T, out E, out RD, out RE, out Ast extends SchemaAST.AST, out Rebuild extends Top, out TypeMakeIn = T, out Iso = T, in out TypeParameters extends ReadonlyArray<Constraint> = readonly [], out TypeMake = TypeMakeIn, out TypeMutability extends Mutability = "readonly", out TypeOptionality extends Optionality = "required", out TypeConstructorDefault extends ConstructorDefault = "no-default", out EncodedMutability extends Mutability = "readonly", out EncodedOptionality extends Optionality = "required"> extends Pipeable.Pipeable {
    readonly [TypeId]: typeof TypeId;
    readonly "ast": Ast;
    readonly "Rebuild": Rebuild;
    readonly "~type.parameters": TypeParameters;
    readonly "Type": T;
    readonly "Encoded": E;
    readonly "DecodingServices": RD;
    readonly "EncodingServices": RE;
    readonly "~type.make.in": TypeMakeIn;
    readonly "~type.make": TypeMake;
    readonly "~type.constructor.default": TypeConstructorDefault;
    readonly "Iso": Iso;
    readonly "~type.mutability": TypeMutability;
    readonly "~type.optionality": TypeOptionality;
    readonly "~encoded.mutability": EncodedMutability;
    readonly "~encoded.optionality": EncodedOptionality;
    annotate(annotations: Annotations.Bottom<this["Type"], this["~type.parameters"]>): this["Rebuild"];
    annotateKey(annotations: Annotations.Key<this["Type"]>): this["Rebuild"];
    check(...checks: readonly [SchemaAST.Check<this["Type"]>, ...Array<SchemaAST.Check<this["Type"]>>]): this["Rebuild"];
    rebuild(ast: this["ast"]): this["Rebuild"];
    /**
     * Constructs a value from the make input representation synchronously.
     *
     * **When to use**
     *
     * Use when constructor input is trusted or when validation failure
     * should abort with a thrown `Error`.
     *
     * **Details**
     *
     * Applies constructor defaults and type-side validation according to
     * `MakeOptions`.
     *
     * **Gotchas**
     *
     * Throws an `Error` with the schema issue in its `cause` when validation
     * fails. Schema validation failures use the generic message
     * `"Schema validation failed"`; format the `cause` explicitly with
     * `SchemaIssue.makeFormatterDefault()` when human-readable details are needed.
     * Causes that contain defects, interruptions, or other non-schema reasons
     * throw with the underlying `Cause` attached instead.
     *
     * @see {@link BottomWithoutNew.makeOption} — construct synchronously and discard validation details
     * @see {@link BottomWithoutNew.makeEffect} — construct through `Effect` when validation failure should stay in the error channel
     */
    make(input: this["~type.make.in"], options?: MakeOptions): this["Type"];
    /**
     * Constructs a value from the make input representation, returning `Option.none`
     * when validation fails.
     *
     * **When to use**
     *
     * Use when you only need to know whether construction succeeds
     * and do not need validation details.
     *
     * **Details**
     *
     * Applies constructor defaults and type-side validation according to
     * `MakeOptions`.
     *
     * **Gotchas**
     *
     * Only causes made entirely of schema issues are converted to `None`. Causes
     * that contain defects, interruptions, or other non-schema reasons throw
     * instead.
     *
     * @see {@link BottomWithoutNew.make} — construct synchronously when validation failure should throw
     * @see {@link BottomWithoutNew.makeEffect} — construct through `Effect` when validation details should stay in the error channel
     */
    makeOption(input: this["~type.make.in"], options?: MakeOptions): Option_.Option<this["Type"]>;
    /**
     * Constructs a value from the make input representation, returning validation
     * failures in the `Effect` error channel.
     *
     * **When to use**
     *
     * Use when construction must compose with other `Effect` operations or when
     * the result supplies a nested constructor default. Otherwise, use
     * {@link BottomWithoutNew.make} when invalid construction should throw.
     *
     * **Details**
     *
     * `SchemaParser` uses `SchemaIssue.Issue` as its canonical structured failure,
     * and this method exposes the same representation directly. Keeping the issue
     * unwrapped lets an enclosing schema attach its own path when the effect is
     * used with {@link withConstructorDefault}. It also avoids allocating a
     * `SchemaError` and keeps its formatting path out of the resulting bundle.
     *
     * **Gotchas**
     *
     * Unlike the decoding helpers in `Schema`, validation failures are not wrapped
     * in `SchemaError`. Map the issue to `SchemaError` or to a domain-specific error
     * when a wrapped error is needed at the application boundary.
     *
     * @see {@link BottomWithoutNew.make} — construct synchronously when validation failure should throw
     * @see {@link BottomWithoutNew.makeOption} — construct synchronously and discard validation details
     */
    makeEffect(input: this["~type.make.in"], options?: MakeOptions): Effect.Effect<this["Type"], SchemaIssue.Issue>;
}
/**
 * Fully-parameterized base interface for schemas that can be extended directly
 * by TypeScript classes.
 *
 * **When to use**
 *
 * Use as the base for concrete schema interfaces whose runtime values support
 * `class ... extends schema`.
 *
 * **Details**
 *
 * Extends {@link BottomWithoutNew} with a construct signature that accepts `never`. The
 * signature enables class extension without making ordinary schemas directly
 * constructible.
 *
 * @see {@link BottomWithoutNew} for the schema protocol without a construct signature
 *
 * @stability stable
 * @category utility types
 * @since 4.0.0
 */
export interface Bottom<out T, out E, out RD, out RE, out Ast extends SchemaAST.AST, out Rebuild extends Top, out TypeMakeIn = T, out Iso = T, in out TypeParameters extends ReadonlyArray<Constraint> = readonly [], out TypeMake = TypeMakeIn, out TypeMutability extends Mutability = "readonly", out TypeOptionality extends Optionality = "required", out TypeConstructorDefault extends ConstructorDefault = "no-default", out EncodedMutability extends Mutability = "readonly", out EncodedOptionality extends Optionality = "required"> extends BottomWithoutNew<T, E, RD, RE, Ast, Rebuild, TypeMakeIn, Iso, TypeParameters, TypeMake, TypeMutability, TypeOptionality, TypeConstructorDefault, EncodedMutability, EncodedOptionality> {
    new (_: never): {};
}
/**
 * Lazy `BottomWithoutNew` variant for schema implementations that
 * compute their public views on demand.
 *
 * **When to use**
 *
 * Use as the base for lazy schema interfaces that provide a specialized
 * construct signature.
 *
 * **Details**
 *
 * The laziness is purely type-level; runtime behavior is unchanged.
 * `BottomLazyWithoutNew` keeps the structural operations inherited from
 * `BottomWithoutNew`, but erases the expensive schema views to
 * `unknown`. Concrete schema interfaces can then redeclare the precise views
 * they expose. This keeps wide schemas such as `Struct` and `Union` cheaper when
 * generic code reads a single view, while preserving their exact public types.
 *
 * @see {@link BottomWithoutNew} for the fully parameterized schema interface when every
 * view must be supplied directly.
 *
 * @stability stable
 * @category utility types
 * @since 4.0.0
 */
export interface BottomLazyWithoutNew<out Ast extends SchemaAST.AST, out Rebuild extends Top, in out TypeParameters extends ReadonlyArray<Constraint> = readonly [], out TypeMutability extends Mutability = "readonly", out TypeOptionality extends Optionality = "required", out TypeConstructorDefault extends ConstructorDefault = "no-default", out EncodedMutability extends Mutability = "readonly", out EncodedOptionality extends Optionality = "required"> extends BottomWithoutNew<unknown, unknown, unknown, unknown, Ast, Rebuild, unknown, unknown, TypeParameters, unknown, TypeMutability, TypeOptionality, TypeConstructorDefault, EncodedMutability, EncodedOptionality> {
}
/**
 * Lazy `Bottom` variant for schemas that can be extended directly by TypeScript
 * classes.
 *
 * **When to use**
 *
 * Use as the base for concrete lazy schema interfaces whose runtime values
 * support `class ... extends schema`.
 *
 * **Details**
 *
 * Extends {@link BottomLazyWithoutNew} with a construct signature that accepts `never`.
 * The signature enables class extension without making ordinary schemas
 * directly constructible.
 *
 * @see {@link BottomLazyWithoutNew} for the lazy schema protocol without a construct signature
 *
 * @stability stable
 * @category utility types
 * @since 4.0.0
 */
export interface BottomLazy<out Ast extends SchemaAST.AST, out Rebuild extends Top, in out TypeParameters extends ReadonlyArray<Constraint> = readonly [], out TypeMutability extends Mutability = "readonly", out TypeOptionality extends Optionality = "required", out TypeConstructorDefault extends ConstructorDefault = "no-default", out EncodedMutability extends Mutability = "readonly", out EncodedOptionality extends Optionality = "required"> extends BottomLazyWithoutNew<Ast, Rebuild, TypeParameters, TypeMutability, TypeOptionality, TypeConstructorDefault, EncodedMutability, EncodedOptionality> {
    new (_: never): {};
}
/**
 * Type-level representation returned by {@link declareConstructor}.
 *
 * @stability stable
 * @category constructors
 * @since 4.0.0
 */
export interface declareConstructor<T, E, TypeParameters extends ReadonlyArray<Constraint>, Iso = T> extends Bottom<T, E, TypeParameters[number]["DecodingServices"], TypeParameters[number]["EncodingServices"], SchemaAST.Declaration, declareConstructor<T, E, TypeParameters, Iso>, T, Iso, TypeParameters> {
}
/**
 * Creates a schema for a **parametric** type (a generic container such as
 * `Array<A>`, `Option<A>`, etc.) by accepting a list of type-parameter schemas
 * and a decoder factory.
 *
 * **When to use**
 *
 * Use when you are defining a schema for a generic container whose validation
 * depends on one or more type-parameter schemas.
 *
 * **Details**
 *
 * The outer call `declareConstructor<T, E, Iso>()` fixes the decoded type `T`,
 * the encoded type `E`, and the optional iso type. The inner call receives:
 * - `typeParameters` — the concrete schemas for each type variable
 * - `run` — a factory that, given resolved codecs for each type parameter,
 *   returns a parsing function `(u, ast, options) => Effect<T, Issue>`
 * - `annotations` — optional metadata
 *
 * @see {@link declare} for creating schemas for non-parametric types.
 *
 * **Example** (Schema for a parametric `Box<A>` type)
 *
 * ```ts import.meta.vitest
 * import { Effect, Schema, SchemaIssue, SchemaParser } from "effect"
 *
 * interface Box<A> {
 *   readonly value: A
 * }
 *
 * const isBox = (u: unknown): u is Box<unknown> =>
 *   typeof u === "object" && u !== null && "value" in u
 *
 * const Box = <A extends Schema.Constraint>(item: A) =>
 *   Schema.declareConstructor<Box<A["Type"]>, Box<A["Encoded"]>>()(
 *     [item],
 *     ([itemCodec]) =>
 *       (u, ast, options) => {
 *         if (!isBox(u)) {
 *           return Effect.fail(new SchemaIssue.InvalidType(ast, u, options))
 *         }
 *         return Effect.map(
 *           SchemaParser.decodeUnknownEffect(itemCodec)(u.value, options),
 *           (value) => ({ value })
 *         )
 *       }
 *   )
 *
 * const schema = Box(Schema.Number)
 * Effect.runSync(Schema.decodeUnknownEffect(schema)({ value: 1 })) // => { value: 1 }
 * ```
 *
 * @stability stable
 * @category constructors
 * @since 4.0.0
 */
export declare function declareConstructor<T, E = T, Iso = T>(): <const TypeParameters extends ReadonlyArray<Constraint>>(typeParameters: TypeParameters, run: (typeParameters: { readonly [K in keyof TypeParameters]: Codec<TypeParameters[K]["Type"], TypeParameters[K]["Encoded"]>; }) => (u: unknown, self: SchemaAST.Declaration, options: SchemaAST.ParseOptions) => Effect.Effect<T, SchemaIssue.Issue>, annotations?: Annotations.Declaration<T, TypeParameters>) => declareConstructor<T, E, TypeParameters, Iso>;
/**
 * Type-level representation returned by {@link declare}.
 *
 * @stability stable
 * @category constructors
 * @since 3.13.3
 */
export interface declare<T, Iso = T> extends declareConstructor<T, T, readonly [], Iso> {
    readonly "Rebuild": declare<T, Iso>;
}
/**
 * Creates a schema for a **non-parametric** opaque type using a type-guard
 * function. The schema accepts any unknown value and succeeds when `is` returns
 * `true`, failing with an `InvalidType` issue otherwise.
 *
 * **When to use**
 *
 * Use when you are defining a schema for an opaque type with no type parameters
 * and validation can be expressed as a type guard.
 *
 * **Example** (Defining a schema for a custom `UserId` branded type)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * type UserId = string & { readonly _tag: "UserId" }
 *
 * const isUserId = (u: unknown): u is UserId =>
 *   typeof u === "string" && u.startsWith("user_")
 *
 * const UserId = Schema.declare<UserId>(isUserId, {
 *   title: "UserId",
 *   description: "A user identifier starting with 'user_'"
 * })
 * Schema.decodeUnknownSync(UserId)("user_123") // => "user_123"
 * ```
 *
 * @see {@link declareConstructor} for creating schemas for parametric types.
 *
 * @stability stable
 * @category constructors
 * @since 3.10.0
 */
export declare function declare<T, Iso = T>(is: (u: unknown) => u is T, annotations?: Annotations.Declaration<T> | undefined): declare<T, Iso>;
/**
 * Returns a schema widened to the fully-parameterized {@link Bottom} interface,
 * making all 14 type parameters visible to TypeScript.
 *
 * **Details**
 *
 * Normally, concrete schema interfaces (e.g. `Schema<string>`) hide most type
 * parameters. `revealBottom` is useful when writing generic utilities that need
 * to inspect or propagate the complete set of type parameters.
 *
 * **Example** (Inspecting all type parameters of a schema)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const schema = Schema.String
 *
 * // Widen to Bottom to access all 14 type parameters
 * const bottom = Schema.revealBottom(schema)
 *
 * // `bottom` now exposes Type, Encoded, DecodingServices, EncodingServices,
 * // ast, Rebuild, ~type.make.in, Iso, ~type.parameters, etc.
 * type T = typeof bottom["Type"]     // string
 * type E = typeof bottom["Encoded"]  // string
 * ```
 *
 * @stability stable
 * @category utility types
 * @since 4.0.0
 */
export declare function revealBottom<S extends Top>(bottom: S): Bottom<S["Type"], S["Encoded"], S["DecodingServices"], S["EncodingServices"], S["ast"], S["Rebuild"], S["~type.make.in"], S["Iso"], S["~type.parameters"], S["~type.make"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]>;
/**
 * Adds metadata annotations to a schema without changing its runtime behavior.
 * This is the pipeable (curried) counterpart of the `.annotate` method.
 *
 * **Details**
 *
 * Annotations provide extra context used by documentation generators, JSON
 * Schema converters, error formatters, and other tooling. Common keys include
 * `title`, `description`, `examples`, `message`, and `identifier`.
 *
 * **Example** (Adding a title and description)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const Age = Schema.Natural.pipe(
 *   Schema.annotate({
 *     title: "Age",
 *     description: "A non-negative integer representing age in years"
 *   })
 * )
 * Schema.resolveAnnotations(Age)?.title // => "Age"
 * ```
 *
 * @see {@link annotateEncoded} to annotate the encoded side instead.
 *
 * @stability stable
 * @category annotations
 * @since 4.0.0
 */
export declare function annotate<S extends Top>(annotations: Annotations.Bottom<S["Type"], S["~type.parameters"]>): (self: S) => S["Rebuild"];
/**
 * Adds metadata annotations to the **encoded** side of a schema without
 * changing its runtime behavior. This is the encoded-side counterpart of
 * `annotate`, which targets the decoded (Type) side.
 *
 * **Details**
 *
 * Internally the schema is flipped so that `Encoded` becomes `Type`,
 * annotated, and then flipped back.
 *
 * **Example** (Adding a title to the encoded representation)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const schema = Schema.NumberFromString.pipe(
 *   Schema.annotateEncoded({
 *     title: "my title"
 *   })
 * )
 *
 * Schema.toEncoded(schema).ast.annotations?.title // => "my title"
 * ```
 *
 * @see {@link annotate} to annotate the type side instead.
 *
 * @stability stable
 * @category annotations
 * @since 4.0.0
 */
export declare function annotateEncoded<S extends Top>(annotations: Annotations.Bottom<S["Encoded"], readonly []>): (self: S) => S["Rebuild"];
/**
 * Adds key-level annotations to a schema field. This is the pipeable
 * (curried) counterpart of the `.annotateKey` method.
 *
 * **Details**
 *
 * Key annotations apply to a field's position inside a `Struct` or `Tuple`
 * rather than to the field's value type. They can carry a
 * `messageMissingKey` to customise the error shown when the field is absent,
 * as well as standard documentation fields such as `title`, `description`,
 * and `examples`.
 *
 * **Example** (Customizing the missing-key message for a required field)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const schema = Schema.Struct({
 *   username: Schema.String.pipe(
 *     Schema.annotateKey({
 *       description: "The username used to log in",
 *       messageMissingKey: "Username is required"
 *     })
 *   )
 * })
 * schema.fields.username.ast.context?.annotations?.messageMissingKey // => "Username is required"
 * ```
 *
 * @stability stable
 * @category annotations
 * @since 4.0.0
 */
export declare function annotateKey<S extends Top>(annotations: Annotations.Key<S["Type"]>): (self: S) => S["Rebuild"];
/**
 * The existential "any schema" type — all type parameters are erased to `unknown`.
 *
 * **Details**
 *
 * Use `Top` as a constraint when writing generic utilities that must accept *any*
 * schema regardless of its `Type`, `Encoded`, or service requirements. It is the
 * widest possible schema type and therefore gives you the least static information.
 *
 * In user code prefer the narrower interfaces:
 * - {@link Schema}`<T>` — when you only care about the decoded type
 * - {@link Codec}`<T, E, RD, RE>` — when you need the encoded type and service requirements
 * - {@link ConstraintDecoder}`<T, RD>` — for decode-only APIs
 * - {@link ConstraintEncoder}`<E, RE>` — for encode-only APIs
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface Top extends Bottom<unknown, unknown, unknown, unknown, SchemaAST.AST, Top, unknown, unknown, any, // this is because TypeParameters is invariant
unknown, Mutability, Optionality, ConstructorDefault, Mutability, Optionality> {
}
/**
 * Lightweight structural constraint for APIs that accept schema values but only
 * read their data and type-level views.
 *
 * **When to use**
 *
 * Use when you need to constrain a generic value to be a schema, but the API
 * only reads properties such as `ast`, `Type`, `Encoded`, service
 * requirements, constructor input views, or modifier flags.
 *
 * **Details**
 *
 * `Constraint` keeps the schema type identifier and the property surface needed
 * by schema constructors, while avoiding the full `Bottom` protocol. Use
 * {@link Top} when an API calls schema methods such as `annotate`, `check`,
 * `rebuild`, `make`, or `makeEffect`.
 *
 * @see {@link Top} for the complete schema protocol.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface Constraint {
    readonly [TypeId]: typeof TypeId;
    readonly "ast": SchemaAST.AST;
    readonly "Type": unknown;
    readonly "Encoded": unknown;
    readonly "DecodingServices": unknown;
    readonly "EncodingServices": unknown;
    readonly "~type.parameters": any;
    readonly "~type.make.in": unknown;
    readonly "~type.make": unknown;
    readonly "Iso": unknown;
    readonly "~type.optionality": Optionality;
    readonly "~type.mutability": Mutability;
    readonly "~type.constructor.default": ConstructorDefault;
    readonly "~encoded.optionality": Optionality;
    readonly "~encoded.mutability": Mutability;
}
/**
 * Lightweight structural constraint for APIs that need codec type views but do
 * not need the full schema protocol.
 *
 * **When to use**
 *
 * Use when you need to preserve decoded type, encoded type, and service
 * requirements for a schema value, but the API does not call schema methods
 * such as `annotate`, `check`, `rebuild`, `make`, or `makeEffect`.
 *
 * @see {@link Constraint} for the generic lightweight schema constraint.
 * @see {@link Codec} for the full schema protocol with codec type views.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface ConstraintCodec<out T, out E = T, out RD = never, out RE = never> extends Constraint {
    readonly "Type": T;
    readonly "Encoded": E;
    readonly "DecodingServices": RD;
    readonly "EncodingServices": RE;
}
/**
 * Lightweight structural constraint for APIs that need decoder type views but
 * do not need the full schema protocol.
 *
 * **When to use**
 *
 * Use when you need to preserve a schema's decoded type and decoding services,
 * but the API does not constrain the encoded type, encoding services, or call
 * schema methods such as `annotate`, `check`, `rebuild`, `make`, or
 * `makeEffect`.
 *
 * @see {@link ConstraintCodec} for APIs that need both decoded and encoded codec views.
 * @see {@link Codec} for the full schema protocol with codec type views.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface ConstraintDecoder<out T, out RD = never> extends ConstraintCodec<T, unknown, RD, unknown> {
}
/**
 * Lightweight structural constraint for APIs that need encoder type views but
 * do not need the full schema protocol.
 *
 * **When to use**
 *
 * Use when you need to preserve a schema's encoded type and encoding services,
 * but the API does not constrain the decoded type, decoding services, or call
 * schema methods such as `annotate`, `check`, `rebuild`, `make`, or
 * `makeEffect`.
 *
 * @see {@link ConstraintCodec} for APIs that need both decoded and encoded codec views.
 * @see {@link Codec} for the full schema protocol with codec type views.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface ConstraintEncoder<out E, out RE = never> extends ConstraintCodec<unknown, E, unknown, RE> {
}
/**
 * Lightweight structural constraint for APIs that need schema views and the
 * rebuilt schema type, but do not call the full schema protocol.
 *
 * **When to use**
 *
 * Use when an API needs to read `Rebuild` in addition to the schema views
 * exposed by {@link Constraint}, but does not call methods such as `annotate`,
 * `check`, `rebuild`, `make`, or `makeEffect`.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface ConstraintRebuildable extends Constraint {
    readonly "Rebuild": Constraint;
}
/**
 * Namespace of type-level helpers for {@link Schema}.
 *
 * @stability stable
 * @since 3.10.0
 */
export declare namespace Schema {
    /**
     * Extracts the decoded `Type` from a schema.
     *
     * **Example** (Extracting the decoded type)
     *
     * ```ts import.meta.vitest
     * import { Schema } from "effect"
     *
     * const Person = Schema.Struct({ name: Schema.String, age: Schema.Number })
     * type Person = Schema.Schema.Type<typeof Person>
     * // { readonly name: string; readonly age: number }
     * ```
     *
     * @category utility types
     * @since 3.10.0
     */
    type Type<S> = S extends {
        readonly "Type": infer T;
    } ? T : never;
}
/**
 * A typed view of a schema that tracks only the decoded (output) type `T`.
 *
 * **Details**
 *
 * Use `Schema<T>` as a constraint when you want to accept "any schema that
 * decodes to `T`" and do not need to know or constrain the encoded
 * representation, required services, or any other type parameters.
 *
 * This is a structural interface — concrete schema values are produced by the
 * constructors in this module (e.g. {@link Struct}, {@link String}, {@link Number}).
 * When you also need the encoded type or service requirements, use {@link Codec}.
 *
 * **Example** (Accepting any schema decoding to `string`)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const accept = (_schema: Schema.Schema<string>): void => {}
 *
 * accept(Schema.String)
 * accept(Schema.NonEmptyString)
 * ```
 *
 * @see {@link Codec} — also tracks Encoded, DecodingServices, EncodingServices
 * @see {@link Schema.Type} — extract the decoded type at the type level
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface Schema<out T> extends Top {
    readonly "Type": T;
    readonly "Rebuild": Schema<T>;
}
/**
 * Namespace of type-level helpers for {@link Codec}.
 *
 * @stability stable
 * @since 4.0.0
 */
export declare namespace Codec {
    /**
     * Extracts the encoded (`Encoded`) type from a schema.
     *
     * **Example** (Extracting the encoded type)
     *
     * ```ts import.meta.vitest
     * import { Schema } from "effect"
     *
     * const schema = Schema.NumberFromString
     * type Enc = Schema.Codec.Encoded<typeof schema>
     * // string
     * ```
     *
     * @category utility types
     * @since 3.10.0
     */
    type Encoded<S> = S extends {
        readonly "Encoded": infer E;
    } ? E : never;
    /**
     * Extracts the Effect services required during *decoding* from a schema.
     *
     * **Example** (Checking decoding service requirements)
     *
     * ```ts import.meta.vitest
     * import { Schema } from "effect"
     *
     * const schema = Schema.String
     * type RD = Schema.Codec.DecodingServices<typeof schema>
     * // never
     * ```
     *
     * @category utility types
     * @since 4.0.0
     */
    type DecodingServices<S> = S extends {
        readonly "DecodingServices": infer R;
    } ? R : never;
    /**
     * Extracts the Effect services required during *encoding* from a schema.
     *
     * **Example** (Checking encoding service requirements)
     *
     * ```ts import.meta.vitest
     * import { Schema } from "effect"
     *
     * const schema = Schema.String
     * type RE = Schema.Codec.EncodingServices<typeof schema>
     * // never
     * ```
     *
     * @category utility types
     * @since 4.0.0
     */
    type EncodingServices<S> = S extends {
        readonly "EncodingServices": infer R;
    } ? R : never;
}
/**
 * A schema that tracks the decoded type `T`, the encoded type `E`, and the
 * Effect services required during decoding (`RD`) and encoding (`RE`).
 *
 * **Details**
 *
 * Use `Codec<T, E, RD, RE>` when you need to preserve full type information
 * about a schema — both what it decodes to and what it serializes from/to.
 * Most concrete schemas produced by this module implement `Codec`.
 *
 * For APIs that only need one direction, prefer the narrower views:
 * - {@link Decoder}`<T, RD>` — decode-only
 * - {@link Encoder}`<E, RE>` — encode-only
 * - {@link Schema}`<T>` — type-only (no encoded representation)
 *
 * **Example** (Accepting a codec that decodes to `number` from `string`)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const serialize = <T>(codec: Schema.Codec<T, string>, value: T): string =>
 *   Schema.encodeSync(codec)(value)
 *
 * serialize(Schema.NumberFromString, 42) // => "42"
 * ```
 *
 * @see {@link Codec.Encoded} — extract the encoded type
 * @see {@link Codec.DecodingServices} — extract required decoding services
 * @see {@link Codec.EncodingServices} — extract required encoding services
 * @see {@link revealCodec} — helper to make TypeScript infer the full Codec type
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface Codec<out T, out E = T, out RD = never, out RE = never> extends Schema<T> {
    readonly "Encoded": E;
    readonly "DecodingServices": RD;
    readonly "EncodingServices": RE;
    readonly "Rebuild": Codec<T, E, RD, RE>;
}
/**
 * A schema that tracks the decoded type `T` and the Effect services required
 * during decoding (`RD`).
 *
 * **When to use**
 *
 * Use when you need to preserve a schema's decoded type and decoding service
 * requirements, but do not need to constrain its encoded representation or
 * encoding services.
 *
 * @see {@link Codec} for preserving both decoded and encoded type information.
 * @see {@link Encoder} for the encode-only view.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface Decoder<out T, out RD = never> extends Schema<T> {
    readonly "Encoded": unknown;
    readonly "DecodingServices": RD;
    readonly "EncodingServices": unknown;
    readonly "Rebuild": Decoder<T, RD>;
}
/**
 * A schema that tracks the encoded type `E` and the Effect services required
 * during encoding (`RE`).
 *
 * **When to use**
 *
 * Use when you need to preserve a schema's encoded type and encoding service
 * requirements, but do not need to constrain its decoded representation or
 * decoding services.
 *
 * @see {@link Codec} for preserving both decoded and encoded type information.
 * @see {@link Decoder} for the decode-only view.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface Encoder<out E, out RE = never> extends Schema<unknown> {
    readonly "Encoded": E;
    readonly "DecodingServices": unknown;
    readonly "EncodingServices": RE;
    readonly "Rebuild": Encoder<E, RE>;
}
/**
 * Returns a codec widened to the full {@link Codec} interface, prompting
 * TypeScript to infer all four type parameters (`T`, `E`, `RD`, `RE`).
 *
 * **Details**
 *
 * When a schema is stored in a variable typed as `Schema<T>` or `Top`, the
 * encoded type and service requirements are erased. Passing the value through
 * `revealCodec` recovers those parameters without any runtime cost.
 *
 * **Example** (Recovering encoded type from a schema variable)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const schema: Schema.Schema<number> = Schema.NumberFromString
 *
 * // Without revealCodec, Encoded is unknown
 * const codec = Schema.revealCodec(schema)
 * type Enc = typeof codec["Encoded"] // string
 * ```
 *
 * @stability stable
 * @category utility types
 * @since 4.0.0
 */
export declare function revealCodec<T, E, RD, RE>(codec: Codec<T, E, RD, RE>): Codec<T, E, RD, RE>;
/**
 * A schema that additionally supports optic (lens/prism) operations.
 *
 * **Details**
 *
 * `Optic<T, Iso>` extends {@link Schema}`<T>` with an `Iso` type that
 * describes the isomorphic counterpart used by the optic layer. Crucially,
 * decoding and encoding require *no* Effect services (`DecodingServices` and
 * `EncodingServices` are both `never`), which means the optic can operate
 * purely without an Effect runtime.
 *
 * Most primitive schemas (e.g. `Schema.String`, `Schema.Number`) implement
 * `Optic` automatically. You normally interact with this interface through
 * {@link Optic_} utilities rather than constructing it directly.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface Optic<out T, out Iso> extends Schema<T> {
    readonly "Iso": Iso;
    readonly "DecodingServices": never;
    readonly "EncodingServices": never;
    readonly "Rebuild": Optic<T, Iso>;
}
declare const SchemaError_base: new <A extends Record<string, any> = {}>(args: import("./Types.ts").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause_.YieldableError & {
    readonly _tag: "SchemaError";
} & Readonly<A>;
/**
 * Error thrown or returned when schema decoding or encoding fails.
 *
 * **Details**
 *
 * The `issue` field contains a structured {@link SchemaIssue.Issue} tree describing
 * every validation failure, including the path to the problematic value and
 * the expected type or constraint. The `message` field renders the issue tree
 * with the default formatter.
 *
 * **Gotchas**
 *
 * Parsing with `reportInput: true` adds an enumerable `input` field to
 * value-bearing issues. Built-in messages may include reported input, and
 * custom annotations or messages are not sanitized.
 *
 * **Example** (Inspecting a SchemaError)
 *
 * ```ts import.meta.vitest
 * import { Result, Schema } from "effect"
 *
 * const result = Schema.decodeUnknownResult(Schema.Number)("not a number")
 * const message = Result.isFailure(result) ? result.failure.message : ""
 * message // => "Expected number"
 * ```
 *
 * @see {@link isSchemaError} for narrowing unknown values
 * @stability stable
 * @category errors
 * @since 4.0.0
 */
export declare class SchemaError extends SchemaError_base<{
    readonly issue: SchemaIssue.Issue;
}> {
    readonly [SchemaErrorTypeId]: typeof SchemaErrorTypeId;
    constructor(issue: SchemaIssue.Issue);
    get message(): string;
    toJSON(): {
        _tag: "SchemaError";
        message: string;
    };
    [NodeInspectSymbol](): {
        _tag: "SchemaError";
        message: string;
    };
    toString(): string;
}
/**
 * Returns `true` if `u` is a {@link SchemaError}.
 *
 * **When to use**
 *
 * Use when you need to narrow an unknown value to `SchemaError`.
 *
 * **Example** (Narrowing Schema errors)
 *
 * ```ts import.meta.vitest
 * import { Result, Schema } from "effect"
 *
 * const result = Result.try(() => Schema.decodeUnknownSync(Schema.Number)("oops"))
 * const error: unknown = Result.isFailure(result) ? result.failure : undefined
 * Schema.isSchemaError(error) // => true
 * ```
 *
 * @stability stable
 * @category guards
 * @since 4.0.0
 */
export declare function isSchemaError(u: unknown): u is SchemaError;
/**
 * Returns a "Standard Schema" object conforming to the [Standard Schema
 * v1](https://standardschema.dev/) specification.
 *
 * **Details**
 *
 * This function creates a schema whose `validate` method attempts to decode and
 * validate the provided input synchronously. If the underlying `Schema`
 * includes any asynchronous components (e.g., asynchronous message resolutions
 * or checks), then validation will necessarily return a `Promise` instead.
 *
 * **Example** (Creating a standard schema from a regular schema)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * // Define custom hook functions for error formatting
 * const leafHook = (issue: any) => {
 *   switch (issue._tag) {
 *     case "InvalidType":
 *       return "Expected different type"
 *     case "InvalidValue":
 *       return "Invalid value provided"
 *     case "MissingKey":
 *       return "Required property missing"
 *     case "UnexpectedKey":
 *       return "Unexpected property found"
 *     case "Forbidden":
 *       return "Operation not allowed"
 *     case "OneOf":
 *       return "Multiple valid options available"
 *     default:
 *       return "Validation error"
 *   }
 * }
 *
 * // Create a standard schema from a regular schema
 * const PersonSchema = Schema.Struct({
 *   name: Schema.NonEmptyString,
 *   age: Schema.Finite.check(Schema.isBetween({ minimum: 0, maximum: 150 }))
 * })
 *
 * const standardSchema = Schema.toStandardSchemaV1(PersonSchema, {
 *   leafHook
 * })
 *
 * // The standard schema can be used with any Standard Schema v1 compatible library
 * const validResult = standardSchema["~standard"].validate({
 *   name: "Alice",
 *   age: 30
 * })
 * const invalidResult = standardSchema["~standard"].validate({
 *   name: "",
 *   age: 200
 * })
 *
 * if (validResult instanceof Promise || invalidResult instanceof Promise) {
 *   throw new Error("Expected synchronous validation")
 * }
 * if ("value" in validResult) {
 *   validResult.value // => { name: "Alice", age: 30 }
 * }
 * invalidResult.issues?.map((issue) => issue.path) // => [["name"], ["age"]]
 * ```
 *
 * @stability stable
 * @category converting
 * @since 4.0.0
 */
export declare function toStandardSchemaV1<S extends ConstraintDecoder<unknown>>(self: S, options?: {
    readonly leafHook?: SchemaIssue.LeafHook | undefined;
    readonly checkHook?: SchemaIssue.CheckHook | undefined;
    readonly parseOptions?: SchemaAST.ParseOptions | undefined;
}): StandardSchemaV1<S["Encoded"], S["Type"]> & S;
/**
 * Converts a schema to an experimental Standard JSON Schema V1 representation.
 *
 * **Details**
 *
 * https://github.com/standard-schema/standard-schema/pull/134
 *
 * @stability stable
 * @category converting
 * @since 4.0.0
 */
export declare function toStandardJSONSchemaV1<S extends Constraint>(self: S): StandardJSONSchemaV1<S["Encoded"], S["Type"]> & S;
/**
 * Creates a type guard function that checks if a value conforms to a given
 * schema.
 *
 * **Details**
 *
 * This function returns a predicate that performs a type-safe check, narrowing
 * the type of the input value if the check passes. The predicate returns `false`
 * for schema mismatches.
 *
 * **Gotchas**
 *
 * Only causes made entirely of schema issues are converted to `false`. Causes
 * that contain defects, interruptions, or other non-schema reasons throw
 * instead.
 *
 * **Example** (Defining a basic type guard)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const isString = Schema.is(Schema.String)
 *
 * isString("hello") // => true
 * isString(42) // => false
 *
 * // Type narrowing in action
 * const value: unknown = "hello"
 * if (isString(value)) {
 *   // value is now typed as string
 *   value.toUpperCase() // => "HELLO"
 * }
 * ```
 *
 * @stability stable
 * @category guards
 * @since 3.10.0
 */
export declare const is: typeof SchemaParser.is;
/**
 * Creates an assertion function that throws an error if the input does not match
 * the schema.
 *
 * **When to use**
 *
 * Use to validate unknown input at runtime while narrowing the value with a
 * TypeScript assertion signature.
 *
 * **Details**
 *
 * The input is narrowed if the assertion succeeds. If schema validation fails,
 * the assertion throws an `Error` whose cause is `SchemaIssue.Issue`.
 * Schema validation failures use the generic message `"Schema validation failed"`.
 * Format the `cause` explicitly with `SchemaIssue.makeFormatterDefault()` when
 * human-readable details are needed.
 *
 * **Gotchas**
 *
 * Causes that contain defects, interruptions, or other non-schema reasons throw
 * with the underlying `Cause` attached instead of being converted to schema
 * validation errors.
 *
 * **Example** (Asserting and narrowing an input)
 *
 * ```ts import.meta.vitest
 * import { Schema, SchemaIssue } from "effect"
 *
 * const input: unknown = "hello"
 *
 * // This will pass silently (no return value) and narrow input to string
 * Schema.asserts(Schema.String, input)
 * input.toUpperCase() // => "HELLO"
 *
 * // This will throw an error
 * try {
 *   const invalid: unknown = 123
 *   Schema.asserts(Schema.String, invalid)
 * } catch (error) {
 *   if (error instanceof Error) {
 *     SchemaIssue.isIssue(error.cause) // => true
 *   }
 * }
 * ```
 *
 * @stability stable
 * @category guards
 * @since 4.0.0
 */
export declare const asserts: <S extends Constraint, I>(schema: S, input: I) => asserts input is I & S["Type"];
/**
 * Decodes an `unknown` input against a schema, returning an `Effect` that
 * succeeds with the decoded value or fails with a {@link SchemaError}.
 *
 * **When to use**
 *
 * Use when you need to decode unknown input in an `Effect` whose failure
 * channel is `SchemaError`.
 *
 * **Details**
 *
 * Prefer {@link decodeEffect} when the input is already typed as the schema's
 * `Encoded` type.
 * Options may be provided either when creating the decoder or when applying it;
 * application options override creation options.
 *
 * @see {@link SchemaParser.decodeUnknownEffect} for the adapter that fails with `SchemaIssue.Issue` directly
 *
 * @stability stable
 * @category decoding
 * @since 4.0.0
 */
export declare function decodeUnknownEffect<S extends Constraint>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => Effect.Effect<S["Type"], SchemaError, S["DecodingServices"]>;
/**
 * Decodes a typed input (the schema's `Encoded` type) against a schema,
 * returning an `Effect` that succeeds with the decoded value or fails with a
 * {@link SchemaError}.
 *
 * **When to use**
 *
 * Use when you need to decode input already typed as the schema's `Encoded`
 * type in an `Effect` whose failure channel is `SchemaError`.
 *
 * **Details**
 *
 * For `unknown` input use {@link decodeUnknownEffect}.
 * Options may be provided either when creating the decoder or when applying it;
 * application options override creation options.
 *
 * @see {@link SchemaParser.decodeEffect} for the adapter that fails with `SchemaIssue.Issue` directly
 *
 * @stability stable
 * @category decoding
 * @since 4.0.0
 */
export declare const decodeEffect: <S extends Constraint>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Encoded"], options?: SchemaAST.ParseOptions) => Effect.Effect<S["Type"], SchemaError, S["DecodingServices"]>;
/**
 * Decodes an `unknown` input against a schema synchronously, returning an
 * `Exit` that is either a `Success` with the decoded value or a `Failure`.
 *
 * **When to use**
 *
 * Use when you need to decode unknown input into an `Exit` and capture schema
 * mismatches as `SchemaError`.
 *
 * **Details**
 *
 * Only usable with schemas that have no `DecodingServices` requirement. Prefer
 * {@link decodeExit} when the input is already typed as the schema's `Encoded`
 * type.
 * Options may be provided either when creating the decoder or when applying it;
 * application options override creation options.
 * Schema mismatches are represented by a `Failure` cause containing
 * `SchemaError`.
 *
 * **Gotchas**
 *
 * Schema issue fail reasons are wrapped as `SchemaError`. Defects,
 * interruptions, and other non-schema reasons remain in the returned `Cause`,
 * including when they are mixed with schema issues.
 *
 * @see {@link SchemaParser.decodeUnknownExit} for the adapter whose failure contains `SchemaIssue.Issue` directly
 *
 * @stability stable
 * @category decoding
 * @since 4.0.0
 */
export declare function decodeUnknownExit<S extends ConstraintDecoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => Exit_.Exit<S["Type"], SchemaError>;
/**
 * Decodes a typed input (the schema's `Encoded` type) against a schema
 * synchronously, returning an `Exit` that is either a `Success` with the decoded
 * value or a `Failure`.
 *
 * **When to use**
 *
 * Use when you need to decode already typed `Encoded` input into an `Exit` and
 * capture schema mismatches as `SchemaError`.
 *
 * **Details**
 *
 * Only usable with schemas that have no `DecodingServices` requirement. For
 * `unknown` input use {@link decodeUnknownExit}.
 * Options may be provided either when creating the decoder or when applying it;
 * application options override creation options.
 * Schema mismatches are represented by a `Failure` cause containing
 * `SchemaError`.
 *
 * **Gotchas**
 *
 * Schema issue fail reasons are wrapped as `SchemaError`. Defects,
 * interruptions, and other non-schema reasons remain in the returned `Cause`,
 * including when they are mixed with schema issues.
 *
 * @see {@link SchemaParser.decodeExit} for the adapter whose failure contains `SchemaIssue.Issue` directly
 *
 * @stability stable
 * @category decoding
 * @since 4.0.0
 */
export declare const decodeExit: <S extends ConstraintDecoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Encoded"], options?: SchemaAST.ParseOptions) => Exit_.Exit<S["Type"], SchemaError>;
/**
 * Decodes an `unknown` input against a schema, returning an `Option` that is
 * `Some` with the decoded value on success or `None` for schema mismatches.
 *
 * **When to use**
 *
 * Use when you do not know the input type statically and only need to know
 * whether decoding succeeded.
 *
 * **Details**
 *
 * Prefer this over {@link decodeUnknownExit} or {@link decodeUnknownEffect}
 * when you don't need error details. For input already typed as the schema's
 * `Encoded` type use {@link decodeOption}.
 * Options may be provided either when creating the decoder or when applying it;
 * application options override creation options.
 *
 * **Gotchas**
 *
 * Only causes made entirely of schema issues are converted to `None`. Causes
 * that contain defects, interruptions, or other non-schema reasons throw
 * instead.
 *
 * @stability stable
 * @category decoding
 * @since 3.10.0
 */
export declare const decodeUnknownOption: <S extends ConstraintDecoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: unknown, options?: SchemaAST.ParseOptions) => Option_.Option<S["Type"]>;
/**
 * Decodes a typed input (the schema's `Encoded` type) against a schema,
 * returning an `Option` that is `Some` with the decoded value on success or
 * `None` for schema mismatches.
 *
 * **When to use**
 *
 * Use when you already have input typed as the schema's `Encoded` type and
 * only need to know whether decoding succeeded.
 *
 * **Details**
 *
 * For `unknown` input use {@link decodeUnknownOption}.
 * Options may be provided either when creating the decoder or when applying it;
 * application options override creation options.
 *
 * **Gotchas**
 *
 * Only causes made entirely of schema issues are converted to `None`. Causes
 * that contain defects, interruptions, or other non-schema reasons throw
 * instead.
 *
 * @stability stable
 * @category decoding
 * @since 3.10.0
 */
export declare const decodeOption: <S extends ConstraintDecoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Encoded"], options?: SchemaAST.ParseOptions) => Option_.Option<S["Type"]>;
/**
 * Decodes an `unknown` input against a schema, returning a `Result` that
 * succeeds with the decoded value or fails with a {@link SchemaError} for schema
 * mismatches.
 *
 * **When to use**
 *
 * Use when you do not know the input type statically and want schema mismatches
 * returned as `Result.fail` with `SchemaError`.
 *
 * **Details**
 *
 * For input already typed as the schema's `Encoded` type use
 * {@link decodeResult}.
 * Options may be provided either when creating the decoder or when applying it;
 * application options override creation options.
 * Schema mismatches are returned as `Result.fail` with `SchemaError`.
 *
 * **Gotchas**
 *
 * Only causes made entirely of schema issues are returned as `Result.fail`.
 * Causes that contain defects, interruptions, or other non-schema reasons throw
 * instead.
 *
 * @see {@link SchemaParser.decodeUnknownResult} for the adapter that fails with `SchemaIssue.Issue` directly
 *
 * @stability stable
 * @category decoding
 * @since 4.0.0
 */
export declare function decodeUnknownResult<S extends ConstraintDecoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => Result_.Result<S["Type"], SchemaError>;
/**
 * Decodes a typed input (the schema's `Encoded` type) against a schema,
 * returning a `Result` that succeeds with the decoded value or fails with a
 * {@link SchemaError} for schema mismatches.
 *
 * **When to use**
 *
 * Use when you already have input typed as the schema's `Encoded` type and want
 * schema mismatches returned as `Result.fail` with `SchemaError`.
 *
 * **Details**
 *
 * For `unknown` input use {@link decodeUnknownResult}.
 * Options may be provided either when creating the decoder or when applying it;
 * application options override creation options.
 * Schema mismatches are returned as `Result.fail` with `SchemaError`.
 *
 * **Gotchas**
 *
 * Only causes made entirely of schema issues are returned as `Result.fail`.
 * Causes that contain defects, interruptions, or other non-schema reasons throw
 * instead.
 *
 * @see {@link SchemaParser.decodeResult} for the adapter that fails with `SchemaIssue.Issue` directly
 *
 * @stability stable
 * @category decoding
 * @since 4.0.0
 */
export declare const decodeResult: <S extends ConstraintDecoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Encoded"], options?: SchemaAST.ParseOptions) => Result_.Result<S["Type"], SchemaError>;
/**
 * Decodes an `unknown` input against a schema, returning a `Promise` that
 * resolves with the decoded value or rejects with a {@link SchemaError} for
 * schema mismatches.
 *
 * **When to use**
 *
 * Use when you need decoding of unknown input to return a JavaScript `Promise`
 * that rejects with `SchemaError` for schema mismatches.
 *
 * **Details**
 *
 * For input already typed as the schema's `Encoded` type use
 * {@link decodePromise}.
 * Options may be provided either when creating the decoder or when applying it;
 * application options override creation options.
 *
 * **Gotchas**
 *
 * Non-schema failures may reject with a runtime failure instead of
 * `SchemaError`.
 *
 * @see {@link SchemaParser.decodeUnknownPromise} for the adapter that rejects with an `Error` whose cause is `SchemaIssue.Issue`
 *
 * @stability stable
 * @category decoding
 * @since 3.10.0
 */
export declare function decodeUnknownPromise<S extends ConstraintDecoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => Promise<S["Type"]>;
/**
 * Decodes a typed input (the schema's `Encoded` type) against a schema,
 * returning a `Promise` that resolves with the decoded value or rejects with a
 * {@link SchemaError} for schema mismatches.
 *
 * **When to use**
 *
 * Use when you already have input typed as the schema's `Encoded` type and
 * need decoding to return a JavaScript `Promise` that rejects with
 * `SchemaError` for schema mismatches.
 *
 * **Details**
 *
 * For `unknown` input use `decodeUnknownPromise`.
 * Options may be provided either when creating the decoder or when applying it;
 * application options override creation options.
 *
 * **Gotchas**
 *
 * Non-schema failures may reject with a runtime failure instead of
 * `SchemaError`.
 *
 * @see {@link SchemaParser.decodePromise} for the adapter that rejects with an `Error` whose cause is `SchemaIssue.Issue`
 *
 * @stability stable
 * @category decoding
 * @since 3.10.0
 */
export declare const decodePromise: <S extends ConstraintDecoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Encoded"], options?: SchemaAST.ParseOptions) => Promise<S["Type"]>;
/**
 * Decodes an `unknown` input against a schema synchronously, returning the
 * decoded value or throwing a {@link SchemaError} for schema mismatches.
 *
 * **When to use**
 *
 * Use when you need to validate unknown data at a synchronous boundary and want
 * schema mismatches to throw `SchemaError`.
 *
 * **Details**
 *
 * For input already typed as the schema's `Encoded` type use `decodeSync`.
 * Only service-free schemas can be decoded synchronously. For alternatives that
 * do not throw on schema mismatches, see `decodeUnknownOption`,
 * `decodeUnknownExit`, or `decodeUnknownEffect`. Options may be provided either
 * when creating the decoder or when applying it; application options override
 * creation options.
 *
 * **Gotchas**
 *
 * Non-schema failures may throw a runtime failure instead of `SchemaError`.
 *
 * **Example** (Decoding with a transformation schema)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const NumberFromString = Schema.NumberFromString
 *
 * Schema.decodeUnknownSync(NumberFromString)("42") // => 42
 * ```
 *
 * @see {@link SchemaParser.decodeUnknownSync} for the adapter that throws an `Error` whose cause is `SchemaIssue.Issue`
 *
 * @stability stable
 * @category decoding
 * @since 4.0.0
 */
export declare function decodeUnknownSync<S extends ConstraintDecoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => S["Type"];
/**
 * Decodes a typed input (the schema's `Encoded` type) against a schema
 * synchronously, returning the decoded value or throwing a {@link SchemaError}
 * for schema mismatches.
 *
 * **When to use**
 *
 * Use when you already have input typed as the schema's `Encoded` type and
 * want schema mismatches to throw `SchemaError` synchronously.
 *
 * **Details**
 *
 * For `unknown` input use `decodeUnknownSync`.
 * Only service-free schemas can be decoded synchronously. Options may be
 * provided either when creating the decoder or when applying it; application
 * options override creation options.
 *
 * **Gotchas**
 *
 * Non-schema failures may throw a runtime failure instead of `SchemaError`.
 *
 * @see {@link SchemaParser.decodeSync} for the adapter that throws an `Error` whose cause is `SchemaIssue.Issue`
 *
 * @stability stable
 * @category decoding
 * @since 4.0.0
 */
export declare const decodeSync: <S extends ConstraintDecoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Encoded"], options?: SchemaAST.ParseOptions) => S["Type"];
/**
 * Encodes an `unknown` input against a schema, returning an `Effect` that
 * succeeds with the encoded value or fails with a {@link SchemaError}.
 *
 * **When to use**
 *
 * Use when you need to encode unknown input in an `Effect` whose failure
 * channel is `SchemaError`.
 *
 * **Details**
 *
 * Prefer {@link encodeEffect} when the value is already typed as the schema's
 * `Type`.
 * Options may be provided either when creating the encoder or when applying it;
 * application options override creation options.
 *
 * **Example** (Encoding a value to a string)
 *
 * ```ts import.meta.vitest
 * import { Effect, Schema } from "effect"
 *
 * const NumberFromString = Schema.NumberFromString
 *
 * await Effect.runPromise(Schema.encodeUnknownEffect(NumberFromString)(42)) // => "42"
 * ```
 *
 * @see {@link SchemaParser.encodeUnknownEffect} for the adapter that fails with `SchemaIssue.Issue` directly
 *
 * @stability stable
 * @category encoding
 * @since 4.0.0
 */
export declare function encodeUnknownEffect<S extends Constraint>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => Effect.Effect<S["Encoded"], SchemaError, S["EncodingServices"]>;
/**
 * Encodes a typed input (the schema's `Type`) against a schema, returning an
 * `Effect` that succeeds with the encoded value or fails with a
 * {@link SchemaError}.
 *
 * **When to use**
 *
 * Use when you need to encode input already typed as the schema's `Type` in
 * an `Effect` whose failure channel is `SchemaError`.
 *
 * **Details**
 *
 * For `unknown` input use {@link encodeUnknownEffect}.
 * Options may be provided either when creating the encoder or when applying it;
 * application options override creation options.
 *
 * @see {@link SchemaParser.encodeEffect} for the adapter that fails with `SchemaIssue.Issue` directly
 *
 * @stability stable
 * @category encoding
 * @since 4.0.0
 */
export declare const encodeEffect: <S extends Constraint>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Type"], options?: SchemaAST.ParseOptions) => Effect.Effect<S["Encoded"], SchemaError, S["EncodingServices"]>;
/**
 * Encodes an `unknown` input against a schema synchronously, returning an
 * `Exit` that is either a `Success` with the encoded value or a `Failure`.
 *
 * **When to use**
 *
 * Use when you need to encode unknown input into an `Exit` and capture schema
 * mismatches as `SchemaError`.
 *
 * **Details**
 *
 * Only usable with schemas that have no `EncodingServices` requirement. Prefer
 * {@link encodeExit} when the value is already typed as the schema's `Type`.
 * Options may be provided either when creating the encoder or when applying it;
 * application options override creation options.
 * Schema mismatches are represented by a `Failure` cause containing
 * `SchemaError`.
 *
 * **Gotchas**
 *
 * Schema issue fail reasons are wrapped as `SchemaError`. Defects,
 * interruptions, and other non-schema reasons remain in the returned `Cause`,
 * including when they are mixed with schema issues.
 *
 * @see {@link SchemaParser.encodeUnknownExit} for the adapter whose failure contains `SchemaIssue.Issue` directly
 *
 * @stability stable
 * @category encoding
 * @since 4.0.0
 */
export declare function encodeUnknownExit<S extends ConstraintEncoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => Exit_.Exit<S["Encoded"], SchemaError>;
/**
 * Encodes a typed input (the schema's `Type`) against a schema synchronously,
 * returning an `Exit` that is either a `Success` with the encoded value or a
 * `Failure`.
 *
 * **When to use**
 *
 * Use when you need to encode already typed schema values into an `Exit` and
 * capture schema mismatches as `SchemaError`.
 *
 * **Details**
 *
 * Only usable with schemas that have no `EncodingServices` requirement. For
 * `unknown` input use {@link encodeUnknownExit}.
 * Options may be provided either when creating the encoder or when applying it;
 * application options override creation options.
 * Schema mismatches are represented by a `Failure` cause containing
 * `SchemaError`.
 *
 * **Gotchas**
 *
 * Schema issue fail reasons are wrapped as `SchemaError`. Defects,
 * interruptions, and other non-schema reasons remain in the returned `Cause`,
 * including when they are mixed with schema issues.
 *
 * @see {@link SchemaParser.encodeExit} for the adapter whose failure contains `SchemaIssue.Issue` directly
 *
 * @stability stable
 * @category encoding
 * @since 4.0.0
 */
export declare const encodeExit: <S extends ConstraintEncoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Type"], options?: SchemaAST.ParseOptions) => Exit_.Exit<S["Encoded"], SchemaError>;
/**
 * Encodes an `unknown` input against a schema, returning an `Option` that is
 * `Some` with the encoded value on success or `None` for schema mismatches.
 *
 * **When to use**
 *
 * Use when you do not know the input type statically and only need to know
 * whether encoding succeeded.
 *
 * **Details**
 *
 * Prefer this over {@link encodeUnknownExit} or {@link encodeUnknownEffect}
 * when you don't need error details. For values already typed as the schema's
 * `Type` use {@link encodeOption}.
 * Options may be provided either when creating the encoder or when applying it;
 * application options override creation options.
 *
 * **Gotchas**
 *
 * Only causes made entirely of schema issues are converted to `None`. Causes
 * that contain defects, interruptions, or other non-schema reasons throw
 * instead.
 *
 * @stability stable
 * @category encoding
 * @since 3.10.0
 */
export declare const encodeUnknownOption: <S extends ConstraintEncoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: unknown, options?: SchemaAST.ParseOptions) => Option_.Option<S["Encoded"]>;
/**
 * Encodes a typed input (the schema's `Type`) against a schema, returning an
 * `Option` that is `Some` with the encoded value on success or `None` for schema
 * mismatches.
 *
 * **When to use**
 *
 * Use when you already have a value typed as the schema's `Type` and only need
 * to know whether encoding succeeded.
 *
 * **Details**
 *
 * For `unknown` input use {@link encodeUnknownOption}.
 * Options may be provided either when creating the encoder or when applying it;
 * application options override creation options.
 *
 * **Gotchas**
 *
 * Only causes made entirely of schema issues are converted to `None`. Causes
 * that contain defects, interruptions, or other non-schema reasons throw
 * instead.
 *
 * @stability stable
 * @category encoding
 * @since 3.10.0
 */
export declare const encodeOption: <S extends ConstraintEncoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Type"], options?: SchemaAST.ParseOptions) => Option_.Option<S["Encoded"]>;
/**
 * Encodes an `unknown` input against a schema, returning a `Result` that
 * succeeds with the encoded value or fails with a {@link SchemaError} for schema
 * mismatches.
 *
 * **When to use**
 *
 * Use when you do not know the input type statically and want schema mismatches
 * returned as `Result.fail` with `SchemaError`.
 *
 * **Details**
 *
 * For values already typed as the schema's `Type` use {@link encodeResult}.
 * Options may be provided either when creating the encoder or when applying it;
 * application options override creation options.
 * Schema mismatches are returned as `Result.fail` with `SchemaError`.
 *
 * **Gotchas**
 *
 * Only causes made entirely of schema issues are returned as `Result.fail`.
 * Causes that contain defects, interruptions, or other non-schema reasons throw
 * instead.
 *
 * @see {@link SchemaParser.encodeUnknownResult} for the adapter that fails with `SchemaIssue.Issue` directly
 *
 * @stability stable
 * @category encoding
 * @since 4.0.0
 */
export declare function encodeUnknownResult<S extends ConstraintEncoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => Result_.Result<S["Encoded"], SchemaError>;
/**
 * Encodes a typed input (the schema's `Type`) against a schema, returning a
 * `Result` that succeeds with the encoded value or fails with a
 * {@link SchemaError} for schema mismatches.
 *
 * **When to use**
 *
 * Use when you already have a value typed as the schema's `Type` and want schema
 * mismatches returned as `Result.fail` with `SchemaError`.
 *
 * **Details**
 *
 * For `unknown` input use {@link encodeUnknownResult}.
 * Options may be provided either when creating the encoder or when applying it;
 * application options override creation options.
 * Schema mismatches are returned as `Result.fail` with `SchemaError`.
 *
 * **Gotchas**
 *
 * Only causes made entirely of schema issues are returned as `Result.fail`.
 * Causes that contain defects, interruptions, or other non-schema reasons throw
 * instead.
 *
 * @see {@link SchemaParser.encodeResult} for the adapter that fails with `SchemaIssue.Issue` directly
 *
 * @stability stable
 * @category encoding
 * @since 4.0.0
 */
export declare const encodeResult: <S extends ConstraintEncoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Type"], options?: SchemaAST.ParseOptions) => Result_.Result<S["Encoded"], SchemaError>;
/**
 * Encodes an `unknown` input against a schema, returning a `Promise` that
 * resolves with the encoded value or rejects with a {@link SchemaError} for
 * schema mismatches.
 *
 * **When to use**
 *
 * Use when you need encoding of unknown input to return a JavaScript `Promise`
 * that rejects with `SchemaError` for schema mismatches.
 *
 * **Details**
 *
 * For values already typed as the schema's `Type` use {@link encodePromise}.
 * Options may be provided either when creating the encoder or when applying it;
 * application options override creation options.
 *
 * **Gotchas**
 *
 * Non-schema failures may reject with a runtime failure instead of
 * `SchemaError`.
 *
 * @see {@link SchemaParser.encodeUnknownPromise} for the adapter that rejects with an `Error` whose cause is `SchemaIssue.Issue`
 *
 * @stability stable
 * @category encoding
 * @since 3.10.0
 */
export declare function encodeUnknownPromise<S extends ConstraintEncoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => Promise<S["Encoded"]>;
/**
 * Encodes a typed input (the schema's `Type`) against a schema, returning a
 * `Promise` that resolves with the encoded value or rejects with a
 * {@link SchemaError} for schema mismatches.
 *
 * **When to use**
 *
 * Use when you already have a value typed as the schema's `Type` and need
 * encoding to return a JavaScript `Promise` that rejects with `SchemaError` for
 * schema mismatches.
 *
 * **Details**
 *
 * For `unknown` input use {@link encodeUnknownPromise}.
 * Options may be provided either when creating the encoder or when applying it;
 * application options override creation options.
 *
 * **Gotchas**
 *
 * Non-schema failures may reject with a runtime failure instead of
 * `SchemaError`.
 *
 * @see {@link SchemaParser.encodePromise} for the adapter that rejects with an `Error` whose cause is `SchemaIssue.Issue`
 *
 * @stability stable
 * @category encoding
 * @since 3.10.0
 */
export declare const encodePromise: <S extends ConstraintEncoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Type"], options?: SchemaAST.ParseOptions) => Promise<S["Encoded"]>;
/**
 * Encodes an `unknown` input against a schema synchronously, throwing a
 * {@link SchemaError} for schema mismatches.
 *
 * **When to use**
 *
 * Use when you need to serialize unknown data at a synchronous boundary and
 * want schema mismatches to throw `SchemaError`.
 *
 * **Details**
 *
 * For alternatives that do not throw on schema mismatches, see
 * {@link encodeUnknownOption}, {@link encodeUnknownExit}, or
 * {@link encodeUnknownEffect}. For values already typed as the schema's `Type`
 * use {@link encodeSync}. Options may be provided either when creating the
 * encoder or when applying it; application options override creation options.
 *
 * **Gotchas**
 *
 * Non-schema failures may throw a runtime failure instead of `SchemaError`.
 *
 * @see {@link SchemaParser.encodeUnknownSync} for the adapter that throws an `Error` whose cause is `SchemaIssue.Issue`
 *
 * @stability stable
 * @category encoding
 * @since 4.0.0
 */
export declare function encodeUnknownSync<S extends ConstraintEncoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => S["Encoded"];
/**
 * Encodes a typed input (the schema's `Type`) against a schema synchronously,
 * throwing a {@link SchemaError} for schema mismatches.
 *
 * **When to use**
 *
 * Use when you already have a value typed as the schema's `Type` and want
 * schema mismatches to throw `SchemaError` synchronously.
 *
 * **Details**
 *
 * For `unknown` input use {@link encodeUnknownSync}.
 * Options may be provided either when creating the encoder or when applying it;
 * application options override creation options.
 *
 * **Gotchas**
 *
 * Non-schema failures may throw a runtime failure instead of `SchemaError`.
 *
 * @see {@link SchemaParser.encodeSync} for the adapter that throws an `Error` whose cause is `SchemaIssue.Issue`
 *
 * @stability stable
 * @category encoding
 * @since 4.0.0
 */
export declare const encodeSync: <S extends ConstraintEncoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Type"], options?: SchemaAST.ParseOptions) => S["Encoded"];
/**
 * Creates a schema from an AST (Abstract Syntax Tree) node.
 *
 * **Details**
 *
 * This is the fundamental constructor for all schemas in the Effect Schema
 * library. It takes an AST node and wraps it in a fully-typed schema that
 * preserves all type information and provides the complete schema API.
 *
 * The `make` function is used internally to create all primitive schemas like
 * `String`, `Number`, `Boolean`, etc., as well as more complex schemas. It's
 * the bridge between the untyped AST representation and the strongly-typed
 * schema.
 *
 * @stability stable
 * @category constructors
 * @since 3.10.0
 */
export declare const make: <S extends Constraint>(ast: S["ast"], options?: object) => S;
/**
 * Checks whether a value is a `Schema`.
 *
 * @stability stable
 * @category guards
 * @since 3.10.0
 */
export declare function isSchema(u: unknown): u is Top;
/**
 * Type-level representation returned by {@link optionalKey}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface optionalKey<S extends Constraint> extends BottomLazy<S["ast"], optionalKey<S>, S["~type.parameters"], S["~type.mutability"], "optional", S["~type.constructor.default"], S["~encoded.mutability"], "optional"> {
    readonly "Type": S["Type"];
    readonly "Encoded": S["Encoded"];
    readonly "DecodingServices": S["DecodingServices"];
    readonly "EncodingServices": S["EncodingServices"];
    readonly "~type.make.in": S["~type.make.in"];
    readonly "~type.make": S["~type.make"];
    readonly "Iso": S["Iso"];
    readonly schema: S;
}
interface optionalKeyLambda extends Lambda {
    <S extends Constraint>(self: S): optionalKey<S>;
    readonly "~lambda.out": this["~lambda.in"] extends Constraint ? optionalKey<this["~lambda.in"]> : never;
}
/**
 * Creates an exact optional key schema for struct fields. Unlike `optional`,
 * this creates exact optional properties (not `| undefined`) that can be
 * completely omitted from the object.
 *
 * **Example** (Creating a struct with optional key)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const schema = Schema.Struct({
 *   name: Schema.String,
 *   age: Schema.optionalKey(Schema.Number)
 * })
 *
 * // Type: { readonly name: string; readonly age?: number }
 * type Person = typeof schema["Type"]
 * ```
 *
 * @stability stable
 * @category combinators
 * @since 4.0.0
 */
export declare const optionalKey: optionalKeyLambda;
interface requiredKeyLambda extends Lambda {
    <S extends Constraint>(self: optionalKey<S>): S;
    readonly "~lambda.out": this["~lambda.in"] extends optionalKey<Constraint> ? this["~lambda.in"]["schema"] : "Error: schema not eligible for requiredKey";
}
/**
 * Reverses `optionalKey` and returns the inner required schema.
 *
 * **When to use**
 *
 * Use to remove optional-key wrapping from a schema field that was previously
 * wrapped with {@link optionalKey}.
 *
 * @stability stable
 * @category combinators
 * @since 4.0.0
 */
export declare const requiredKey: requiredKeyLambda;
/**
 * Type-level representation returned by {@link optional}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface optional<S extends Constraint> extends optionalKey<UndefinedOr<S>> {
    readonly "Rebuild": optional<S>;
}
interface optionalLambda extends Lambda {
    <S extends Constraint>(self: S): optional<S>;
    readonly "~lambda.out": this["~lambda.in"] extends Constraint ? optional<this["~lambda.in"]> : never;
}
/**
 * Marks a struct field as optional, allowing the key to be absent or
 * `undefined`.
 *
 * **Details**
 *
 * The resulting property may be absent or explicitly set to `undefined`.
 * Equivalent to `optionalKey(UndefinedOr(S))`.
 *
 * Use {@link optionalKey} instead if you want exact optional semantics (absent
 * only, not `undefined`).
 *
 * **Example** (Defining an optional field accepting undefined)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const schema = Schema.Struct({
 *   name: Schema.String,
 *   age: Schema.optional(Schema.Number)
 * })
 *
 * // { readonly name: string; readonly age?: number | undefined }
 * type Person = typeof schema.Type
 * ```
 *
 * @stability stable
 * @category combinators
 * @since 3.10.0
 */
export declare const optional: optionalLambda;
interface requiredLambda extends Lambda {
    <S extends Constraint>(self: optional<S>): S;
    readonly "~lambda.out": this["~lambda.in"] extends optional<Constraint> ? this["~lambda.in"]["schema"]["members"][0] : "Error: schema not eligible for required";
}
/**
 * Reverses `optional` and returns the inner schema.
 *
 * **When to use**
 *
 * Use to remove optional wrapping from a schema field that was previously
 * wrapped with {@link optional}.
 *
 * **Details**
 *
 * This also unwraps the `UndefinedOr` member added by `optional`.
 *
 * @stability stable
 * @category combinators
 * @since 3.10.0
 */
export declare const required: requiredLambda;
/**
 * Type-level representation returned by {@link mutableKey}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface mutableKey<S extends Constraint> extends BottomLazy<S["ast"], mutableKey<S>, S["~type.parameters"], "mutable", S["~type.optionality"], S["~type.constructor.default"], "mutable", S["~encoded.optionality"]> {
    readonly "Type": S["Type"];
    readonly "Encoded": S["Encoded"];
    readonly "DecodingServices": S["DecodingServices"];
    readonly "EncodingServices": S["EncodingServices"];
    readonly "~type.make.in": S["~type.make.in"];
    readonly "~type.make": S["~type.make"];
    readonly "Iso": S["Iso"];
    readonly schema: S;
}
interface mutableKeyLambda extends Lambda {
    <S extends Constraint>(self: S): mutableKey<S>;
    readonly "~lambda.out": this["~lambda.in"] extends Constraint ? mutableKey<this["~lambda.in"]> : never;
}
/**
 * Makes a struct field mutable (removes the `readonly` modifier on the property).
 * Use {@link readonlyKey} to reverse.
 *
 * @stability stable
 * @category combinators
 * @since 4.0.0
 */
export declare const mutableKey: mutableKeyLambda;
interface readonlyKeyLambda extends Lambda {
    <S extends Constraint>(self: mutableKey<S>): S;
    readonly "~lambda.out": this["~lambda.in"] extends mutableKey<Constraint> ? this["~lambda.in"]["schema"] : "Error: schema not eligible for readonlyKey";
}
/**
 * Reverses `mutableKey` and returns the inner readonly schema.
 *
 * **When to use**
 *
 * Use to remove mutable-key wrapping from a schema field that was previously
 * wrapped with {@link mutableKey}.
 *
 * @stability stable
 * @category combinators
 * @since 4.0.0
 */
export declare const readonlyKey: readonlyKeyLambda;
/**
 * Type-level representation returned by {@link toType}.
 *
 * @stability stable
 * @category transforming
 * @since 4.0.0
 */
export interface toType<S extends Constraint> extends BottomLazy<S["ast"], toType<S>, S["~type.parameters"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
    readonly "Type": S["Type"];
    readonly "Encoded": S["Type"];
    readonly "DecodingServices": never;
    readonly "EncodingServices": never;
    readonly "~type.make.in": S["~type.make.in"];
    readonly "~type.make": S["~type.make"];
    readonly "Iso": S["Iso"];
    readonly schema: S;
}
interface toTypeLambda extends Lambda {
    <S extends Constraint>(self: S): toType<S>;
    readonly "~lambda.out": this["~lambda.in"] extends Constraint ? toType<this["~lambda.in"]> : never;
}
/**
 * Extracts the type-side schema: sets `Encoded` to equal the decoded `Type`,
 * discarding the encoding transformation path.
 *
 * @stability stable
 * @category transforming
 * @since 4.0.0
 */
export declare const toType: toTypeLambda;
/**
 * Type-level representation returned by {@link toEncoded}.
 *
 * @stability stable
 * @category transforming
 * @since 4.0.0
 */
export interface toEncoded<S extends Constraint> extends BottomLazy<SchemaAST.AST, toEncoded<S>, ReadonlyArray<Constraint>, S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
    readonly "Type": S["Encoded"];
    readonly "Encoded": S["Encoded"];
    readonly "DecodingServices": never;
    readonly "EncodingServices": never;
    readonly "~type.make.in": S["Encoded"];
    readonly "~type.make": S["Encoded"];
    readonly "Iso": S["Encoded"];
    readonly schema: S;
}
interface toEncodedLambda extends Lambda {
    <S extends Constraint>(self: S): toEncoded<S>;
    readonly "~lambda.out": this["~lambda.in"] extends Constraint ? toEncoded<this["~lambda.in"]> : never;
}
/**
 * Extracts the encoded-side schema: sets `Type` to equal the `Encoded`,
 * discarding the decoding transformation path.
 *
 * @stability stable
 * @category transforming
 * @since 4.0.0
 */
export declare const toEncoded: toEncodedLambda;
declare const FlipTypeId = "~effect/Schema/flip";
/**
 * Type-level representation returned by {@link flip}.
 *
 * @stability stable
 * @category transforming
 * @since 4.0.0
 */
export interface flip<S extends Top> extends BottomLazy<SchemaAST.AST, flip<S>, ReadonlyArray<Constraint>, S["~encoded.mutability"], S["~encoded.optionality"], ConstructorDefault, S["~type.mutability"], S["~type.optionality"]> {
    readonly "Type": S["Encoded"];
    readonly "Encoded": S["Type"];
    readonly "DecodingServices": S["EncodingServices"];
    readonly "EncodingServices": S["DecodingServices"];
    readonly "~type.make.in": S["Encoded"];
    readonly "~type.make": S["Encoded"];
    readonly "Iso": S["Encoded"];
    readonly [FlipTypeId]: typeof FlipTypeId;
    readonly schema: S;
}
/**
 * Swaps the decoded and encoded sides of a schema.
 *
 * **When to use**
 *
 * Use to invert a schema transformation direction.
 *
 * **Details**
 *
 * Calling `flip` twice returns the original schema.
 *
 * **Example** (Flipping a number-from-string schema)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * // NumberFromString: decodes string → number
 * const flipped = Schema.flip(Schema.NumberFromString)
 * Schema.decodeSync(flipped)(42) // => "42"
 * ```
 *
 * @stability stable
 * @category transforming
 * @since 4.0.0
 */
export declare function flip<S extends Top>(schema: S): S extends flip<infer F> ? F["Rebuild"] : flip<S>;
/**
 * Type-level representation returned by {@link Literal}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface Literal<L extends SchemaAST.LiteralValue> extends Bottom<L, L, never, never, SchemaAST.Literal, Literal<L>> {
    readonly literal: L;
    transform<L2 extends SchemaAST.LiteralValue>(to: L2): decodeTo<Literal<L2>, Literal<L>>;
}
/**
 * Creates a schema for a single literal value (string, number, bigint, boolean, or null).
 *
 * **Example** (Defining a string literal)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const schema = Schema.Literal("hello")
 * // Type: Schema.Literal<"hello">
 * Schema.decodeSync(schema)("hello") // => "hello"
 * ```
 *
 * @see {@link Literals} for a schema that represents a union of literals.
 * @see {@link tag} for a schema that represents a literal value that can be
 * used as a discriminator field in tagged unions and has a constructor default.
 * @stability stable
 * @category constructors
 * @since 3.10.0
 */
export declare function Literal<L extends SchemaAST.LiteralValue>(literal: L): Literal<L>;
/**
 * Namespace for {@link TemplateLiteral} helper types.
 *
 * @stability stable
 * @since 3.10.0
 */
export declare namespace TemplateLiteral {
    /**
     * Constraint for schema parts that can appear inside a `TemplateLiteral`.
     *
     * **Details**
     *
     * The schema's encoded value must be a `string`, `number`, or `bigint` so it can
     * be converted into a template literal string segment.
     * `TemplateLiteral` additionally rejects encodings at runtime;
     * `TemplateLiteralParser` supports transformed parts.
     *
     * @category utility types
     * @since 4.0.0
     */
    interface SchemaPart extends Constraint {
        readonly Encoded: string | number | bigint;
    }
    /**
     * Literal value that can be used directly as a part of a `TemplateLiteral`.
     *
     * @category utility types
     * @since 4.0.0
     */
    type LiteralPart = string | number | bigint;
    /**
     * A single part of a `TemplateLiteral`, either an interpolated schema part or a
     * literal `string`, `number`, or `bigint`.
     *
     * @category utility types
     * @since 4.0.0
     */
    type Part = SchemaPart | LiteralPart;
    /**
     * Ordered list of parts used to construct a `TemplateLiteral` schema.
     *
     * @category utility types
     * @since 4.0.0
     */
    type Parts = ReadonlyArray<Part>;
    type AppendType<Template extends string, Next> = Next extends LiteralPart ? `${Template}${Next}` : Next extends {
        readonly Encoded: infer E extends LiteralPart;
    } ? `${Template}${E}` : never;
    /**
     * Computes the encoded string literal type produced by concatenating the encoded
     * forms of all template literal parts.
     *
     * @category utility types
     * @since 3.10.0
     */
    type Encoded<Parts> = Parts extends readonly [...infer Init, infer Last] ? AppendType<Encoded<Init>, Last> : ``;
}
/**
 * Type-level representation returned by {@link TemplateLiteral}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface TemplateLiteral<Parts extends TemplateLiteral.Parts> extends Bottom<TemplateLiteral.Encoded<Parts>, TemplateLiteral.Encoded<Parts>, never, never, SchemaAST.TemplateLiteral, TemplateLiteral<Parts>> {
    readonly parts: Parts;
}
/**
 * Creates a schema that validates strings by matching ordered template literal
 * parts.
 *
 * **When to use**
 *
 * Use when the decoded value should remain the matched string and you do not
 * need the individual template parts parsed into a tuple.
 *
 * **Details**
 *
 * Each part can be a literal `string`, `number`, or `bigint`, or a schema whose
 * encoded type is `string`, `number`, or `bigint`. Checks on string, number,
 * and bigint schema parts are applied while matching each segment.
 *
 * **Gotchas**
 *
 * Parts must not contain encodings, including inside unions or nested templates.
 * Construction throws for transformed parts even when their decoded and encoded
 * types are the same. Use {@link TemplateLiteralParser} to decode transformed parts.
 * Brands and supported checks without encodings remain valid.
 *
 * **Example** (Defining a URL path pattern)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const schema = Schema.TemplateLiteral(["/user/", Schema.Number])
 * Schema.is(schema)("/user/123") // => true
 * ```
 *
 * @see {@link TemplateLiteralParser} for a schema that also parses matched parts into a tuple.
 * @stability stable
 * @category constructors
 * @since 3.10.0
 */
export declare function TemplateLiteral<const Parts extends TemplateLiteral.Parts>(parts: Parts): TemplateLiteral<Parts>;
/**
 * Namespace for {@link TemplateLiteralParser} helper types.
 *
 * @stability stable
 * @since 3.10.0
 */
export declare namespace TemplateLiteralParser {
    /**
     * Computes the decoded tuple type produced by `TemplateLiteralParser`.
     *
     * **Details**
     *
     * Literal parts contribute their literal value to the tuple. Schema parts
     * contribute their decoded `Type`.
     *
     * @category utility types
     * @since 3.10.0
     */
    type Type<Parts> = Parts extends readonly [infer Head, ...infer Tail] ? readonly [
        Head extends TemplateLiteral.LiteralPart ? Head : Head extends ConstraintDecoder<infer T, unknown> ? T : never,
        ...Type<Tail>
    ] : [
    ];
}
/**
 * Type-level representation returned by {@link TemplateLiteralParser}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface TemplateLiteralParser<Parts extends TemplateLiteral.Parts> extends BottomLazy<SchemaAST.Arrays, TemplateLiteralParser<Parts>> {
    readonly "Type": TemplateLiteralParser.Type<Parts>;
    readonly "Encoded": TemplateLiteral.Encoded<Parts>;
    readonly "DecodingServices": Extract<Parts[number], Constraint>["DecodingServices"];
    readonly "EncodingServices": Extract<Parts[number], Constraint>["EncodingServices"];
    readonly "~type.make.in": TemplateLiteralParser.Type<Parts>;
    readonly "~type.make": TemplateLiteralParser.Type<Parts>;
    readonly "Iso": TemplateLiteralParser.Type<Parts>;
    readonly parts: Parts;
}
/**
 * Schema for parsing matched template literal strings into typed tuple parts.
 *
 * **When to use**
 *
 * Use to validate a template literal string and decode the matched parts into
 * typed values.
 *
 * **Details**
 *
 * Unlike {@link TemplateLiteral}, this schema decodes the matched string into a
 * readonly tuple with one element per schema part. Checks on string, number,
 * and bigint schema parts are applied while matching each segment.
 * The source template uses the encoded sides of the parts; the tuple retains
 * their transformations, checks, and decoding and encoding service requirements.
 *
 * **Gotchas**
 *
 * Ambiguous templates use greedy segmentation with backtracking. Encoding a
 * tuple and decoding the resulting string can therefore produce a different
 * tuple when a segment contains a separator used by the template.
 *
 * **Example** (Parsing path parameters)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const schema = Schema.TemplateLiteralParser(["/user/", Schema.NumberFromString])
 * Schema.decodeSync(schema)("/user/42") // => ["/user/", 42]
 * ```
 *
 * @see {@link TemplateLiteral} for a validation-only version that keeps the string encoded.
 * @stability stable
 * @category constructors
 * @since 3.10.0
 */
export declare function TemplateLiteralParser<const Parts extends TemplateLiteral.Parts>(parts: Parts): TemplateLiteralParser<Parts>;
/**
 * Type-level representation returned by {@link Enum}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface Enum<A extends {
    [x: string]: string | number;
}> extends Bottom<A[keyof A], A[keyof A], never, never, SchemaAST.Enum, Enum<A>> {
    readonly enums: A;
}
/**
 * Creates a schema from a TypeScript enum or an object mapping names to string or number values.
 * Validates that the input is one of those values. Numeric values must be finite.
 *
 * **Gotchas**
 *
 * Throws when a numeric member is `NaN`, `Infinity`, or `-Infinity`.
 *
 * **Example** (Defining a direction enum)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * enum Direction {
 *   Up = "Up",
 *   Down = "Down"
 * }
 *
 * const schema = Schema.Enum(Direction)
 * Schema.decodeSync(schema)(Direction.Up) // => "Up"
 * ```
 *
 * @stability stable
 * @category constructors
 * @since 4.0.0
 */
export declare function Enum<const A extends {
    [x: string]: string | number;
}>(enums: A): Enum<A>;
/**
 * Type-level representation of {@link Never}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface Never extends Bottom<never, never, never, never, SchemaAST.Never, Never> {
}
/**
 * Schema for the `never` type. Always fails validation — no value satisfies it.
 *
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare const Never: Never;
/**
 * Type-level representation of {@link Any}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface Any extends Bottom<any, any, never, never, SchemaAST.Any, Any> {
}
/**
 * Schema for the `any` type. Accepts any value without validation.
 *
 * @see {@link Unknown} for a safer alternative that uses `unknown`.
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare const Any: Any;
/**
 * Type-level representation of {@link Unknown}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface Unknown extends Bottom<unknown, unknown, never, never, SchemaAST.Unknown, Unknown> {
}
/**
 * Schema for the `unknown` type. Accepts any value without validation.
 *
 * **When to use**
 *
 * Use as a top schema when you need to accept any input while preserving
 * TypeScript's `unknown` safety at use sites.
 *
 * @see {@link Any} for the `any` variant.
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare const Unknown: Unknown;
/**
 * Type-level representation of {@link Null}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface Null extends Bottom<null, null, never, never, SchemaAST.Null, Null> {
}
/**
 * Schema for the `null` literal. Validates that the input is strictly `null`.
 *
 * @see {@link NullOr} for a union with another schema.
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare const Null: Null;
/**
 * Type-level representation of {@link Undefined}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface Undefined extends Bottom<undefined, undefined, never, never, SchemaAST.Undefined, Undefined> {
}
/**
 * Schema for the `undefined` literal. Validates that the input is strictly `undefined`.
 *
 * @see {@link UndefinedOr} for a union with another schema.
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare const Undefined: Undefined;
/**
 * Type-level representation of {@link String}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface String extends Bottom<string, string, never, never, SchemaAST.String, String> {
}
/**
 * Schema for `string` values. Validates that the input is `typeof` `"string"`.
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare const String: String;
/**
 * Type-level representation of {@link StringForLiteralAutocomplete}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface StringForLiteralAutocomplete extends Bottom<string & {}, string & {}, never, never, SchemaAST.String, StringForLiteralAutocomplete> {
}
/**
 * Schema for `string & {}`. Validates that the input is `typeof` `"string"`.
 *
 * **When to use**
 *
 * Use with {@link Union} and {@link Literals} when a value may be any string
 * and known literals should stay available for editor autocomplete.
 *
 * **Details**
 *
 * `string & {}` stays alongside string literals in a union, so editors keep
 * suggesting those literals. Any string still passes validation. Read the
 * literals from the {@link Literals} member.
 *
 * **Example** (Suggesting known HTTP methods)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const Method = Schema.Union([
 *   Schema.StringForLiteralAutocomplete,
 *   Schema.Literals(["GET", "POST"])
 * ])
 *
 * // Type: "GET" | "POST" | (string & {})
 * Method.make("PATCH") // => "PATCH"
 * Method.members[1].literals // => ["GET", "POST"]
 * ```
 *
 * @see {@link String} for a schema whose type is plain `string`.
 * @see {@link Literals} for the known literals to include in the union.
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare const StringForLiteralAutocomplete: StringForLiteralAutocomplete;
/**
 * Type-level representation of {@link Number}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface Number extends Bottom<number, number, never, never, SchemaAST.Number, Number> {
}
/**
 * Schema for `number` values, including `NaN`, `Infinity`, and `-Infinity`.
 *
 * **Details**
 *
 * Default JSON serializer:
 *
 * - Finite numbers are serialized as numbers.
 * - Non-finite values are serialized as strings (`"NaN"`, `"Infinity"`, `"-Infinity"`).
 *
 * @see {@link Finite} for a schema that excludes non-finite values.
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare const Number: Number;
/**
 * Type-level representation of {@link Boolean}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface Boolean extends Bottom<boolean, boolean, never, never, SchemaAST.Boolean, Boolean> {
}
/**
 * Schema for `boolean` values. Validates that the input is `typeof` `"boolean"`.
 *
 * **When to use**
 *
 * Use to validate values that are already JavaScript booleans.
 *
 * @see {@link BooleanFromBit} for a schema that decodes bit literals `0` or `1` into a boolean
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare const Boolean: Boolean;
/**
 * Type-level representation of {@link Symbol}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface Symbol extends Bottom<symbol, symbol, never, never, SchemaAST.Symbol, Symbol> {
}
/**
 * Schema for `symbol` values. Validates that the input is `typeof` `"symbol"`.
 *
 * @see {@link UniqueSymbol} for a schema that matches a specific symbol.
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare const Symbol: Symbol;
/**
 * Type-level representation of {@link BigInt}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface BigInt extends Bottom<bigint, bigint, never, never, SchemaAST.BigInt, BigInt> {
}
/**
 * Schema for `bigint` values. Validates that the input is `typeof` `"bigint"`.
 *
 * **When to use**
 *
 * Use when the input is already a bigint and the schema should validate and
 * preserve bigint values without parsing from another representation.
 *
 * @see {@link BigIntFromString} for parsing string input into a bigint
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare const BigInt: BigInt;
/**
 * Type-level representation of {@link Void}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface Void extends Bottom<void, void, never, never, SchemaAST.Void, Void> {
}
/**
 * Schema for a TypeScript `void` return value.
 *
 * **When to use**
 *
 * Use when you need to model the return value of a function, RPC, or endpoint
 * whose result is intentionally ignored.
 *
 * **Details**
 *
 * Runtime parsing accepts any present value and discards it, producing
 * `undefined`. The public decoded and encoded TypeScript representation remains
 * `void`, so typed construction, decoding, and encoding APIs are still modeled
 * as `void`.
 *
 * @see {@link Undefined} for a schema that matches only the exact `undefined` value.
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare const Void: Void;
/**
 * Type-level representation of {@link ObjectKeyword}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface ObjectKeyword extends Bottom<object, object, never, never, SchemaAST.ObjectKeyword, ObjectKeyword> {
}
/**
 * Schema for the `object` type. Validates that the input is a non-null object or function
 * (i.e. `typeof value === "object" && value !== null || typeof value === "function"`).
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare const ObjectKeyword: ObjectKeyword;
/**
 * Type-level representation returned by {@link UniqueSymbol}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface UniqueSymbol<sym extends symbol> extends Bottom<sym, sym, never, never, SchemaAST.UniqueSymbol, UniqueSymbol<sym>> {
}
/**
 * Creates a schema for a specific symbol. Only that exact symbol satisfies the schema.
 *
 * **Gotchas**
 *
 * Only globally registered symbols have a JSON encoding. Their canonical JSON
 * form is the exact string returned by `String(symbol)`. A local symbol cannot
 * be encoded as JSON.
 *
 * **Example** (Defining a specific symbol)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const mySymbol = Symbol.for("mySymbol")
 * const schema = Schema.UniqueSymbol(mySymbol)
 * Schema.decodeSync(schema)(mySymbol) === mySymbol // => true
 * ```
 *
 * @see {@link Symbol} for a schema that accepts any symbol.
 * @stability stable
 * @category constructors
 * @since 4.0.0
 */
export declare function UniqueSymbol<const sym extends symbol>(symbol: sym): UniqueSymbol<sym>;
/**
 * Namespace for struct field type utilities.
 *
 * **Details**
 *
 * These types compute the decoded `Type`, encoded `Encoded`, and constructor
 * input `MakeIn` of a {@link Struct} from its field map, handling optional,
 * mutable, and other field modifiers automatically.
 *
 * - `Struct.Fields` — constraint for the field map object
 * - `Struct.Type<F>` — decoded type of the struct
 * - `Struct.Encoded<F>` — encoded type of the struct
 * - `Struct.MakeIn<F>` — constructor input (optional/defaulted fields may be omitted)
 * - `Struct.DecodingServices<F>` / `Struct.EncodingServices<F>` — required services
 *
 * @stability stable
 * @since 3.10.0
 */
export declare namespace Struct {
    /**
     * Constraint for a struct field map: an object whose values are schemas.
     *
     * @category utility types
     * @since 3.10.0
     */
    type Fields = {
        readonly [x: PropertyKey]: Constraint;
    };
    type TypeOptionalKeys<Fields extends Struct.Fields> = {
        [K in keyof Fields]: Fields[K] extends {
            readonly "~type.optionality": "optional";
        } ? K : never;
    }[keyof Fields];
    type TypeMutableKeys<Fields extends Struct.Fields> = {
        [K in keyof Fields]: Fields[K] extends {
            readonly "~type.mutability": "mutable";
        } ? K : never;
    }[keyof Fields];
    type SetOptional<A, K extends keyof A> = Omit<A, K> & Partial<Pick<A, K>>;
    type Mutable<A> = {
        -readonly [K in keyof A]: A[K];
    };
    type SetMutable<A, K extends keyof A> = Omit<A, K> & Mutable<Pick<A, K>>;
    type Side = "Type" | "Iso" | "Encoded";
    type EncodedOptionalKeys<Fields extends Struct.Fields> = {
        [K in keyof Fields]: Fields[K] extends {
            readonly "~encoded.optionality": "optional";
        } ? K : never;
    }[keyof Fields];
    type EncodedMutableKeys<Fields extends Struct.Fields> = {
        [K in keyof Fields]: Fields[K] extends {
            readonly "~encoded.mutability": "mutable";
        } ? K : never;
    }[keyof Fields];
    type SideOptionalKeys<F extends Fields, S extends Side> = S extends "Encoded" ? EncodedOptionalKeys<F> : TypeOptionalKeys<F>;
    type SideMutableKeys<F extends Fields, S extends Side> = S extends "Encoded" ? EncodedMutableKeys<F> : TypeMutableKeys<F>;
    type ReadonlySide<F extends Fields, S extends Side> = {
        readonly [K in keyof F]: F[K][S];
    };
    type View<F extends Fields, S extends Side, O extends keyof F = SideOptionalKeys<F, S>, M extends keyof F = SideMutableKeys<F, S>> = [O | M] extends [never] ? Simplify<ReadonlySide<F, S>> : [M] extends [never] ? Simplify<SetOptional<ReadonlySide<F, S>, O>> : [O] extends [never] ? Simplify<SetMutable<ReadonlySide<F, S>, M>> : Simplify<SetMutable<SetOptional<ReadonlySide<F, S>, O>, Extract<keyof SetOptional<ReadonlySide<F, S>, O>, M>>>;
    /**
     * Computes the decoded object type for a struct field map.
     *
     * **Details**
     *
     * Field schemas contribute their decoded `Type`. `optionalKey` and `optional`
     * produce optional properties, while `mutableKey` produces writable properties.
     *
     * @category utility types
     * @since 3.10.0
     */
    type Type<F extends Fields> = View<F, "Type">;
    /**
     * Computes the iso object type for a struct field map from each field schema's
     * `Iso` type.
     *
     * **Details**
     *
     * The resulting property optionality and mutability follow the same field
     * modifiers used by `Struct.Type`.
     *
     * @category utility types
     * @since 4.0.0
     */
    type Iso<F extends Fields> = View<F, "Iso">;
    /**
     * Computes the encoded object type for a struct field map.
     *
     * **Details**
     *
     * Field schemas contribute their `Encoded` type. Encoded-side optionality and
     * mutability modifiers determine whether properties are optional or writable in
     * the encoded shape.
     *
     * @category utility types
     * @since 3.10.0
     */
    type Encoded<F extends Fields> = View<F, "Encoded">;
    /**
     * Union of all decoding service requirements needed by the schemas in a struct
     * field map.
     *
     * @category utility types
     * @since 4.0.0
     */
    type DecodingServices<F extends Fields> = {
        readonly [K in keyof F]: F[K]["DecodingServices"];
    }[keyof F];
    /**
     * Union of all encoding service requirements needed by the schemas in a struct
     * field map.
     *
     * @category utility types
     * @since 4.0.0
     */
    type EncodingServices<F extends Fields> = {
        readonly [K in keyof F]: F[K]["EncodingServices"];
    }[keyof F];
    type TypeConstructorDefaultedKeys<Fields extends Struct.Fields> = {
        [K in keyof Fields]: Fields[K] extends {
            readonly "~type.constructor.default": "with-default";
        } ? K : never;
    }[keyof Fields];
    type ReadonlyMakeIn<F extends Fields> = {
        readonly [K in keyof F]: F[K]["~type.make"];
    };
    type MakeInView<F extends Fields, O extends keyof F = TypeOptionalKeys<F> | TypeConstructorDefaultedKeys<F>> = [O] extends [never] ? Simplify<ReadonlyMakeIn<F>> : Simplify<SetOptional<ReadonlyMakeIn<F>, O>>;
    /**
     * Computes the input object type accepted when constructing a struct value.
     *
     * **Details**
     *
     * Required fields use each field schema's `~type.make` input. Fields marked
     * optional or with a constructor default may be omitted.
     *
     * @category utility types
     * @since 4.0.0
     */
    type MakeIn<F extends Fields> = MakeInView<F>;
}
/**
 * Type-level representation returned by {@link Struct}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface Struct<Fields extends Struct.Fields> extends BottomLazy<SchemaAST.Objects, Struct<Fields>> {
    readonly "Type": Struct.Type<Fields>;
    readonly "Encoded": Struct.Encoded<Fields>;
    readonly "DecodingServices": Struct.DecodingServices<Fields>;
    readonly "EncodingServices": Struct.EncodingServices<Fields>;
    readonly "~type.make.in": Struct.MakeIn<Fields>;
    readonly "~type.make": Struct.MakeIn<Fields>;
    readonly "Iso": Struct.Iso<Fields>;
    /**
     * The field definitions of this struct. Spread them into a new struct to
     * reuse fields across schemas.
     *
     * **Example** (Reusing fields across structs)
     *
     * ```ts import.meta.vitest
     * import { Schema } from "effect"
     *
     * const Timestamped = Schema.Struct({
     *   createdAt: Schema.Date,
     *   updatedAt: Schema.Date
     * })
     *
     * const User = Schema.Struct({
     *   ...Timestamped.fields,
     *   name: Schema.String,
     *   email: Schema.String
     * })
     * Object.keys(User.fields) // => ["createdAt", "updatedAt", "name", "email"]
     * ```
     */
    readonly fields: Fields;
    /**
     * Returns a new struct with the fields modified by the provided function.
     *
     * **Details**
     *
     * Options:
     *
     * - `unsafePreserveChecks` - if `true`, keep any `.check(...)` constraints
     *   that were attached to the original union. Defaults to `false`.
     *
     *   **Warning**: This is an unsafe operation. Since `mapFields`
     *   transformations change the schema type, the original refinement functions
     *   may no longer be valid or safe to apply to the transformed schema. Only
     *   use this option if you have verified that your refinements remain correct
     *   after the transformation.
     */
    mapFields<To extends Struct.Fields>(f: (fields: Fields) => To, options?: {
        readonly unsafePreserveChecks?: boolean | undefined;
    } | undefined): Struct<Simplify<Readonly<To>>>;
}
/**
 * Defines a struct schema from a map of field schemas.
 *
 * **Details**
 *
 * Each field value is a schema. Use {@link optionalKey} or {@link optional} to
 * mark fields as optional, and {@link mutableKey} to mark them as mutable.
 *
 * The resulting schema's `Type` is a readonly object type with the fields'
 * decoded types. The `Encoded` form mirrors the field schemas' encoded types.
 * Declared fields may be inherited and are copied to own properties in the
 * output. The `__proto__` field is accepted only when it is an own property.
 * Parsing does not guarantee that output keys retain their input order.
 *
 * **Example** (Defining a basic struct)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const Person = Schema.Struct({
 *   name: Schema.String,
 *   age: Schema.Number,
 *   email: Schema.optionalKey(Schema.String)
 * })
 *
 * // { readonly name: string; readonly age: number; readonly email?: string }
 * type Person = typeof Person.Type
 *
 * Schema.decodeUnknownSync(Person)({ name: "Alice", age: 30 }) // => { name: "Alice", age: 30 }
 * ```
 *
 * @stability stable
 * @category constructors
 * @since 3.10.0
 */
export declare function Struct<const Fields extends Struct.Fields>(fields: Fields): Struct<Fields>;
interface fieldsAssign<NewFields extends Struct.Fields> extends Lambda {
    <Fields extends Struct.Fields>(struct: Struct<Fields>): Struct<Struct_.Simplify<Struct_.Assign<Fields, NewFields>>>;
    readonly "~lambda.out": this["~lambda.in"] extends Struct<Struct.Fields> ? Struct<Struct_.Simplify<Struct_.Assign<this["~lambda.in"]["fields"], NewFields>>> : "Error: schema not eligible for fieldsAssign";
}
/**
 * Adds fields to a struct schema through a struct-mapping lambda.
 *
 * **When to use**
 *
 * Use to add the same fields to an existing struct or every struct member of a
 * union.
 *
 * **Details**
 *
 * This is a shortcut for `MyStruct.mapFields(Struct.assign(fields))`.
 *
 * **Example** (Adding fields to a union of structs)
 *
 * ```ts import.meta.vitest
 * import { Schema, Tuple } from "effect"
 *
 * // Add a new field to all members of a union of structs
 * const schema = Schema.Union([
 *   Schema.Struct({ a: Schema.String }),
 *   Schema.Struct({ b: Schema.Number })
 * ]).mapMembers(Tuple.map(Schema.fieldsAssign({ c: Schema.Number })))
 * Schema.decodeSync(schema)({ a: "a", c: 1 }) // => { a: "a", c: 1 }
 * ```
 *
 * @stability stable
 * @category combinators
 * @since 4.0.0
 */
export declare function fieldsAssign<const NewFields extends Struct.Fields>(fields: NewFields): fieldsAssign<NewFields>;
/**
 * Type-level representation returned by {@link encodeKeys}.
 *
 * @stability stable
 * @category transforming
 * @since 4.0.0
 */
export interface encodeKeys<S extends Constraint & {
    readonly fields: Struct.Fields;
}, M extends {
    readonly [K in keyof S["fields"]]?: PropertyKey;
}> extends decodeTo<S, Struct<{
    [K in keyof S["fields"] as K extends keyof M ? M[K] extends PropertyKey ? M[K] : K : K]: toEncoded<S["fields"][K]>;
}>> {
}
/**
 * Renames struct keys in the encoded form without changing the decoded type.
 *
 * **Details**
 *
 * Takes a partial mapping `{ decodedKey: encodedKey }` and produces a
 * transformation schema that decodes from the renamed keys and encodes back to
 * the renamed keys. Keys not present in the mapping are left unchanged.
 * If two existing fields would produce the same encoded key, construction
 * fails.
 *
 * **Example** (Renaming `name` to `full_name` in the encoded form)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const Person = Schema.Struct({ name: Schema.String, age: Schema.Number })
 * const Encoded = Person.pipe(Schema.encodeKeys({ name: "full_name" }))
 *
 * // Decodes { full_name: "Alice", age: 30 } → { name: "Alice", age: 30 }
 * Schema.decodeUnknownSync(Encoded)({ full_name: "Alice", age: 30 }) // => { name: "Alice", age: 30 }
 * ```
 *
 * @stability stable
 * @category transforming
 * @since 4.0.0
 */
export declare function encodeKeys<S extends Constraint & {
    readonly fields: Struct.Fields;
}, const M extends {
    readonly [K in keyof S["fields"]]?: PropertyKey;
}>(mapping: M): (self: S) => encodeKeys<S, M>;
/**
 * Adds derived fields to a struct schema during decoding.
 *
 * **Details**
 *
 * Each new field is derived from the decoded struct value via a function that
 * returns `Option`. On encoding the derived fields are stripped. This allows
 * computed or enriched fields to live in the decoded type without appearing in
 * the encoded form.
 *
 * **Example** (Adding a computed `fullName` field)
 *
 * ```ts import.meta.vitest
 * import { Option, Schema } from "effect"
 *
 * const Person = Schema.Struct({ first: Schema.String, last: Schema.String })
 * const Extended = Person.pipe(
 *   Schema.extendTo(
 *     { fullName: Schema.String },
 *     { fullName: (p) => Option.some(`${p.first} ${p.last}`) }
 *   )
 * )
 *
 * const alice = Schema.decodeUnknownSync(Extended)({ first: "Alice", last: "Smith" })
 * alice.fullName // => "Alice Smith"
 * ```
 *
 * @stability stable
 * @category transforming
 * @since 4.0.0
 */
export declare function extendTo<S extends Struct<Struct.Fields>, const Fields extends Struct.Fields>(fields: Fields, derive: {
    readonly [K in keyof Fields]: (s: S["Type"]) => Option_.Option<Fields[K]["Type"]>;
}): (self: S) => decodeTo<Struct<Simplify<{ [K in keyof S["fields"]]: toType<S["fields"][K]>; } & Fields>>, S>;
/**
 * Namespace for `Record` type utilities.
 *
 * **Details**
 *
 * - `Record.Key` — constraint for the key schema (must encode to `PropertyKey`)
 * - `Record.Type<K, V>` — decoded type of the record
 * - `Record.Encoded<K, V>` — encoded type of the record
 *
 * @stability stable
 * @since 3.10.0
 */
export declare namespace Record {
    /**
     * Constraint for schemas that can be used as record keys.
     *
     * **Details**
     *
     * The key schema must decode and encode property keys (`string`, `number`, or
     * `symbol`) so it can describe object property names.
     *
     * @category utility types
     * @since 4.0.0
     */
    interface Key extends Codec<PropertyKey, PropertyKey, unknown, unknown> {
        readonly "~type.make": PropertyKey;
        readonly "Iso": PropertyKey;
    }
    /**
     * Computes the decoded object type for a record schema from its key and value
     * schemas.
     *
     * **Details**
     *
     * The key schema supplies the property keys and the value schema supplies each
     * property's decoded `Type`. Optional and mutable value schemas affect the
     * resulting property optionality and writability.
     *
     * @category utility types
     * @since 3.10.0
     */
    type Type<Key extends Record.Key, Value extends Constraint> = Value extends {
        readonly "~type.optionality": "optional";
    } ? Value extends {
        readonly "~type.mutability": "mutable";
    } ? {
        [P in Key["Type"]]?: Value["Type"];
    } : {
        readonly [P in Key["Type"]]?: Value["Type"];
    } : Value extends {
        readonly "~type.mutability": "mutable";
    } ? {
        [P in Key["Type"]]: Value["Type"];
    } : {
        readonly [P in Key["Type"]]: Value["Type"];
    };
    /**
     * Computes the iso object type for a record schema from the key schema's `Iso`
     * keys and the value schema's `Iso` values.
     *
     * @category utility types
     * @since 4.0.0
     */
    type Iso<Key extends Record.Key, Value extends Constraint> = Value extends {
        readonly "~type.optionality": "optional";
    } ? Value extends {
        readonly "~type.mutability": "mutable";
    } ? {
        [P in Key["Iso"]]?: Value["Iso"];
    } : {
        readonly [P in Key["Iso"]]?: Value["Iso"];
    } : Value extends {
        readonly "~type.mutability": "mutable";
    } ? {
        [P in Key["Iso"]]: Value["Iso"];
    } : {
        readonly [P in Key["Iso"]]: Value["Iso"];
    };
    /**
     * Computes the encoded object type for a record schema from the key and value
     * schemas' encoded types.
     *
     * **Details**
     *
     * Encoded-side optionality and mutability on the value schema determine whether
     * the encoded record properties are optional or writable.
     *
     * @category utility types
     * @since 3.10.0
     */
    type Encoded<Key extends Record.Key, Value extends Constraint> = Value extends {
        readonly "~encoded.optionality": "optional";
    } ? Value extends {
        readonly "~encoded.mutability": "mutable";
    } ? {
        [P in Key["Encoded"]]?: Value["Encoded"];
    } : {
        readonly [P in Key["Encoded"]]?: Value["Encoded"];
    } : Value extends {
        readonly "~encoded.mutability": "mutable";
    } ? {
        [P in Key["Encoded"]]: Value["Encoded"];
    } : {
        readonly [P in Key["Encoded"]]: Value["Encoded"];
    };
    /**
     * Union of the decoding service requirements of a record's key schema and value
     * schema.
     *
     * @category utility types
     * @since 4.0.0
     */
    type DecodingServices<Key extends Record.Key, Value extends Constraint> = Key["DecodingServices"] | Value["DecodingServices"];
    /**
     * Union of the encoding service requirements of a record's key schema and value
     * schema.
     *
     * @category utility types
     * @since 4.0.0
     */
    type EncodingServices<Key extends Record.Key, Value extends Constraint> = Key["EncodingServices"] | Value["EncodingServices"];
    /**
     * Computes the input object type accepted when constructing a record value.
     *
     * **Details**
     *
     * Keys use the key schema's `~type.make` type and values use the value schema's
     * `~type.make` type. Value optionality and mutability determine whether
     * properties are optional or writable.
     *
     * @category utility types
     * @since 4.0.0
     */
    type MakeIn<Key extends Record.Key, Value extends Constraint> = Value extends {
        readonly "~encoded.optionality": "optional";
    } ? Value extends {
        readonly "~encoded.mutability": "mutable";
    } ? {
        [P in Key["~type.make"]]?: Value["~type.make"];
    } : {
        readonly [P in Key["~type.make"]]?: Value["~type.make"];
    } : Value extends {
        readonly "~encoded.mutability": "mutable";
    } ? {
        [P in Key["~type.make"]]: Value["~type.make"];
    } : {
        readonly [P in Key["~type.make"]]: Value["~type.make"];
    };
}
/**
 * Type-level representation returned by {@link Record}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface $Record<Key extends Record.Key, Value extends Constraint> extends BottomLazy<SchemaAST.Objects, $Record<Key, Value>> {
    readonly "Type": Record.Type<Key, Value>;
    readonly "Encoded": Record.Encoded<Key, Value>;
    readonly "DecodingServices": Record.DecodingServices<Key, Value>;
    readonly "EncodingServices": Record.EncodingServices<Key, Value>;
    readonly "~type.make.in": Simplify<Record.MakeIn<Key, Value>>;
    readonly "~type.make": Simplify<Record.MakeIn<Key, Value>>;
    readonly "Iso": Record.Iso<Key, Value>;
    readonly key: Key;
    readonly value: Value;
}
/**
 * Defines a record schema whose dynamic properties are selected by a key schema
 * and decoded with a value schema.
 *
 * **Details**
 *
 * For dynamic keys, the key schema selects matching own properties and the
 * value schema decodes or encodes only those selected properties. Checks on
 * string, number, symbol, and template literal key schemas narrow which
 * properties are selected.
 *
 * For transformed key schemas, property selection is based on encoded property
 * names before the selected key is decoded.
 *
 * **Gotchas**
 *
 * When decoded or encoded key transformations produce the same property key,
 * sequential parsing applies selected own properties in selection order, so
 * the later selected property overwrites the earlier value. Dynamic key
 * selection always examines own properties. Finite literal keys are declared
 * fields and may therefore be inherited. Output key order is not guaranteed.
 *
 * **Example** (Defining a string-keyed record of numbers)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const schema = Schema.Record(Schema.String, Schema.Number)
 *
 * // { readonly [x: string]: number }
 * type R = typeof schema.Type
 *
 * Schema.decodeUnknownSync(schema)({ a: 1, b: 2 }) // => { a: 1, b: 2 }
 * ```
 *
 * @stability stable
 * @category constructors
 * @since 3.10.0
 */
export declare function Record<Key extends Record.Key, Value extends Constraint>(key: Key, value: Value): $Record<Key, Value>;
/**
 * Namespace for `StructWithRest` type utilities.
 *
 * **Details**
 *
 * - `StructWithRest.Type<S, R>` — decoded type (struct type intersected with record types)
 * - `StructWithRest.Encoded<S, R>` — encoded type
 *
 * @stability stable
 * @since 4.0.0
 */
export declare namespace StructWithRest {
    /**
     * Constraint for object-like schemas that can be used as the fixed portion of a
     * `StructWithRest` schema.
     *
     * @category utility types
     * @since 4.0.0
     */
    type Objects = Constraint & {
        readonly ast: SchemaAST.Objects;
        readonly Encoded: object;
    };
    /**
     * Readonly list of record schemas that provide the additional index signatures
     * for a `StructWithRest` schema.
     *
     * @category utility types
     * @since 3.10.0
     */
    type Records = ReadonlyArray<$Record<Record.Key, Constraint>>;
    type MergeTuple<T extends ReadonlyArray<unknown>> = T extends readonly [infer Head, ...infer Tail] ? Head & MergeTuple<Tail> : {};
    type Intersect<S extends Objects, Records extends StructWithRest.Records, Side extends "Type" | "Iso" | "Encoded" | "~type.make"> = S[Side] & MergeTuple<{
        readonly [K in keyof Records]: Records[K][Side];
    }>;
    /**
     * Computes the decoded type for `StructWithRest` by intersecting the base object
     * schema's decoded `Type` with the decoded types of all rest record schemas.
     *
     * @category utility types
     * @since 3.10.0
     */
    type Type<S extends Objects, Records extends StructWithRest.Records> = Intersect<S, Records, "Type">;
    /**
     * Computes the iso type for `StructWithRest` by intersecting the base object
     * schema's `Iso` type with the `Iso` types of all rest record schemas.
     *
     * @category utility types
     * @since 4.0.0
     */
    type Iso<S extends Objects, Records extends StructWithRest.Records> = Intersect<S, Records, "Iso">;
    /**
     * Computes the encoded type for `StructWithRest` by intersecting the base object
     * schema's encoded type with the encoded types of all rest record schemas.
     *
     * @category utility types
     * @since 3.10.0
     */
    type Encoded<S extends Objects, Records extends StructWithRest.Records> = Intersect<S, Records, "Encoded">;
    /**
     * Computes the input type accepted when constructing a `StructWithRest` value by
     * intersecting the base object's make input with the make inputs of all rest
     * record schemas.
     *
     * @category utility types
     * @since 4.0.0
     */
    type MakeIn<S extends Objects, Records extends StructWithRest.Records> = Intersect<S, Records, "~type.make">;
    type Services<S extends Objects, Records extends StructWithRest.Records, Side extends "DecodingServices" | "EncodingServices"> = S[Side] | {
        [K in keyof Records]: Records[K][Side];
    }[number];
    /**
     * Union of the decoding service requirements of the base object schema and all
     * rest record schemas.
     *
     * @category utility types
     * @since 4.0.0
     */
    type DecodingServices<S extends Objects, Records extends StructWithRest.Records> = Services<S, Records, "DecodingServices">;
    /**
     * Union of the encoding service requirements of the base object schema and all
     * rest record schemas.
     *
     * @category utility types
     * @since 4.0.0
     */
    type EncodingServices<S extends Objects, Records extends StructWithRest.Records> = Services<S, Records, "EncodingServices">;
    type IncompatibleKeys<A, B, OK extends (keyof A & keyof B) = Extract<keyof A, keyof B>> = {
        [K in OK]: Required<Pick<A, K>>[K] extends B[K] ? never : K;
    }[OK];
    type IncompatibleSideKeys<S extends Objects, Records extends StructWithRest.Records, Side extends "Type" | "Encoded" | "Iso" | "~type.make"> = {
        [I in keyof Records]: Records[I][Side] extends object ? IncompatibleKeys<S[Side], Records[I][Side]> : never;
    }[number];
    type IncompatibleRecords<S extends Objects, Records extends StructWithRest.Records> = IncompatibleSideKeys<S, Records, "Type"> | IncompatibleSideKeys<S, Records, "Encoded"> | IncompatibleSideKeys<S, Records, "Iso"> | IncompatibleSideKeys<S, Records, "~type.make">;
    /**
     * Checks whether fixed fields are compatible with the rest record schemas.
     *
     * **Details**
     *
     * Returns `true` when all fixed fields can also satisfy the matching rest
     * index signatures. Returns a diagnostic object when TypeScript would make
     * the resulting intersection too narrow for one or more fixed keys.
     *
     * **Example** (Checking record compatibility)
     *
     * ```ts import.meta.vitest
     * import { Schema } from "effect"
     *
     * const user = Schema.Struct({ id: Schema.String })
     * const stringExtras = [Schema.Record(Schema.String, Schema.String)] as const
     *
     * type UserCheck = Schema.StructWithRest.ValidateRecords<typeof user, typeof stringExtras>
     *
     * const userCheck: UserCheck = true
     * void userCheck
     *
     * const counter = Schema.Struct({ count: Schema.NumberFromString })
     *
     * type CounterCheck = Schema.StructWithRest.ValidateRecords<typeof counter, typeof stringExtras>
     * //    ^? { "incompatible index signatures": "count" }
     *
     * const counterCheck = null as unknown as CounterCheck
     * void counterCheck
     * ```
     *
     * @category utility types
     * @since 4.0.0
     */
    type ValidateRecords<S extends Objects, Records extends StructWithRest.Records> = [
        IncompatibleRecords<S, Records>
    ] extends [never] ? true : {
        "incompatible index signatures": IncompatibleRecords<S, Records>;
    };
}
/**
 * Type-level representation returned by {@link StructWithRest}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface StructWithRest<S extends StructWithRest.Objects, Records extends StructWithRest.Records> extends BottomLazy<SchemaAST.Objects, StructWithRest<S, Records>> {
    readonly "Type": Simplify<StructWithRest.Type<S, Records>>;
    readonly "Encoded": Simplify<StructWithRest.Encoded<S, Records>>;
    readonly "DecodingServices": StructWithRest.DecodingServices<S, Records>;
    readonly "EncodingServices": StructWithRest.EncodingServices<S, Records>;
    readonly "~type.make.in": Simplify<StructWithRest.MakeIn<S, Records>>;
    readonly "~type.make": Simplify<StructWithRest.MakeIn<S, Records>>;
    readonly "Iso": Simplify<StructWithRest.Iso<S, Records>>;
    readonly schema: S;
    readonly records: Records;
}
/**
 * Extends a struct schema with one or more record (index-signature) schemas,
 * producing a schema whose decoded type intersects the struct and all records.
 *
 * **Gotchas**
 *
 * The base schema must have an object-shaped encoded type. Whole-object
 * transformations are not supported, even with an empty rest array. Apply
 * transformations such as `Schema.fromJsonString` to the completed
 * `StructWithRest` schema instead. Object-shaped encoded types alone do not
 * guarantee compatibility: unsupported encodings are still rejected at runtime.
 * Transformations on individual fields remain supported.
 *
 * TypeScript index signatures also apply to fixed keys. `StructWithRest` does
 * not reject incompatible fixed fields at the call site; use
 * `StructWithRest.ValidateRecords` when you want an explicit type-level
 * compatibility check.
 *
 * **Example** (Defining structs with string-indexed extra keys)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const schema = Schema.StructWithRest(
 *   Schema.Struct({ id: Schema.Number }),
 *   [Schema.Record(Schema.String, Schema.Number)]
 * )
 *
 * // { readonly id: number, readonly [x: string]: number }
 * type T = typeof schema.Type
 * ```
 *
 * @stability stable
 * @category constructors
 * @since 4.0.0
 */
export declare function StructWithRest<const S extends StructWithRest.Objects, const Records extends StructWithRest.Records>(schema: S, records: Records): StructWithRest<S, Records>;
/**
 * Namespace for `Tuple` type utilities.
 *
 * **Details**
 *
 * - `Tuple.Elements` — constraint for the element schema array
 * - `Tuple.Type<E>` — decoded tuple type
 * - `Tuple.Encoded<E>` — encoded tuple type
 * - `Tuple.MakeIn<E>` — constructor input tuple
 *
 * @stability stable
 * @since 3.10.0
 */
export declare namespace Tuple {
    /**
     * Constraint for the readonly array of element schemas used to define a
     * fixed-length `Tuple` schema.
     *
     * @category utility types
     * @since 3.10.0
     */
    type Elements = ReadonlyArray<Constraint>;
    type Type_<Elements, Out extends ReadonlyArray<any> = readonly []> = Elements extends readonly [infer Head, ...infer Tail] ? Head extends {
        readonly "Type": infer T;
    } ? Head extends {
        readonly "~type.optionality": "optional";
    } ? Type_<Tail, readonly [...Out, T?]> : Type_<Tail, readonly [...Out, T]> : Out : Out;
    /**
     * Computes the decoded tuple type for a tuple element schema array.
     *
     * **Details**
     *
     * Each element contributes its decoded `Type`; optional element schemas produce
     * optional tuple positions.
     *
     * @category utility types
     * @since 3.10.0
     */
    type Type<E extends Elements> = Type_<E>;
    type Iso_<Elements, Out extends ReadonlyArray<any> = readonly []> = Elements extends readonly [infer Head, ...infer Tail] ? Head extends {
        readonly "Iso": infer T;
    } ? Head extends {
        readonly "~type.optionality": "optional";
    } ? Iso_<Tail, readonly [...Out, T?]> : Iso_<Tail, readonly [...Out, T]> : Out : Out;
    /**
     * Computes the iso tuple type for a tuple element schema array from each
     * element schema's `Iso` type.
     *
     * @category utility types
     * @since 4.0.0
     */
    type Iso<E extends Elements> = Iso_<E>;
    type Encoded_<Elements, Out extends ReadonlyArray<any> = readonly []> = Elements extends readonly [infer Head, ...infer Tail] ? Head extends {
        readonly "Encoded": infer T;
    } ? Head extends {
        readonly "~encoded.optionality": "optional";
    } ? Encoded_<Tail, readonly [...Out, T?]> : Encoded_<Tail, readonly [...Out, T]> : Out : Out;
    /**
     * Computes the encoded tuple type for a tuple element schema array.
     *
     * **Details**
     *
     * Each element contributes its `Encoded` type; encoded-side optional element
     * schemas produce optional tuple positions.
     *
     * @category utility types
     * @since 3.10.0
     */
    type Encoded<E extends Elements> = Encoded_<E>;
    /**
     * Union of all decoding service requirements needed by the tuple element
     * schemas.
     *
     * @category utility types
     * @since 4.0.0
     */
    type DecodingServices<E extends Elements> = E[number]["DecodingServices"];
    /**
     * Union of all encoding service requirements needed by the tuple element
     * schemas.
     *
     * @category utility types
     * @since 4.0.0
     */
    type EncodingServices<E extends Elements> = E[number]["EncodingServices"];
    type MakeIn_<E, Out extends ReadonlyArray<any> = readonly []> = E extends readonly [infer Head, ...infer Tail] ? Head extends {
        "~type.make": infer T;
    } ? Head extends {
        readonly "~type.optionality": "optional";
    } | {
        readonly "~type.constructor.default": "with-default";
    } ? MakeIn_<Tail, readonly [...Out, T?]> : MakeIn_<Tail, readonly [...Out, T]> : Out : Out;
    /**
     * Computes the input tuple type accepted when constructing a tuple value.
     *
     * **Details**
     *
     * Each element uses its `~type.make` input type. Optional elements and elements
     * with constructor defaults produce optional tuple positions.
     *
     * @category utility types
     * @since 4.0.0
     */
    type MakeIn<E extends Elements> = MakeIn_<E>;
}
/**
 * Type-level representation returned by {@link Tuple}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface Tuple<Elements extends Tuple.Elements> extends BottomLazy<SchemaAST.Arrays, Tuple<Elements>> {
    readonly "Type": Tuple.Type<Elements>;
    readonly "Encoded": Tuple.Encoded<Elements>;
    readonly "DecodingServices": Tuple.DecodingServices<Elements>;
    readonly "EncodingServices": Tuple.EncodingServices<Elements>;
    readonly "~type.make.in": Tuple.MakeIn<Elements>;
    readonly "~type.make": Tuple.MakeIn<Elements>;
    readonly "Iso": Tuple.Iso<Elements>;
    readonly elements: Elements;
    /**
     * Returns a new tuple with the elements modified by the provided function.
     *
     * **Details**
     *
     * Options:
     *
     * - `unsafePreserveChecks` - if `true`, keep any `.check(...)` constraints
     *   that were attached to the original union. Defaults to `false`.
     *
     *   **Warning**: This is an unsafe operation. Since `mapFields`
     *   transformations change the schema type, the original refinement functions
     *   may no longer be valid or safe to apply to the transformed schema. Only
     *   use this option if you have verified that your refinements remain correct
     *   after the transformation.
     */
    mapElements<To extends Tuple.Elements>(f: (elements: Elements) => To, options?: {
        readonly unsafePreserveChecks?: boolean | undefined;
    } | undefined): Tuple<Simplify<Readonly<To>>>;
}
/**
 * Defines a fixed-length tuple schema from an array of element schemas.
 *
 * **Example** (Defining a pair of string and number)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const schema = Schema.Tuple([Schema.String, Schema.Number])
 *
 * Schema.decodeUnknownSync(schema)(["hello", 42]) // => ["hello", 42]
 * ```
 *
 * @stability stable
 * @category constructors
 * @since 3.10.0
 */
export declare function Tuple<const Elements extends ReadonlyArray<Constraint>>(elements: Elements): Tuple<Elements>;
/**
 * Namespace for `TupleWithRest` type utilities.
 *
 * **Details**
 *
 * - `TupleWithRest.TupleType` — constraint for the leading tuple schema
 * - `TupleWithRest.Rest` — the rest element schema(s)
 * - `TupleWithRest.Type<T, R>` — decoded type (fixed elements + rest)
 * - `TupleWithRest.Encoded<T, R>` — encoded type
 *
 * @stability stable
 * @since 4.0.0
 */
export declare namespace TupleWithRest {
    /**
     * Constraint for tuple-like schemas that can be used as the fixed leading
     * portion of a `TupleWithRest` schema.
     *
     * @category utility types
     * @since 3.10.0
     */
    type TupleType = Constraint & {
        readonly Type: ReadonlyArray<unknown>;
        readonly Encoded: ReadonlyArray<unknown>;
        readonly ast: SchemaAST.Arrays;
        readonly "~type.make": ReadonlyArray<unknown>;
        readonly "Iso": ReadonlyArray<unknown>;
    };
    /**
     * Non-empty list of schemas used for the rest portion of a `TupleWithRest`.
     *
     * **Details**
     *
     * The first schema describes the repeated rest element. Additional schemas, when
     * present, describe trailing tuple elements after the repeated rest segment.
     *
     * @category utility types
     * @since 3.10.0
     */
    type Rest = readonly [Constraint, ...Array<Constraint>];
    /**
     * Computes the decoded tuple type for a `TupleWithRest`.
     *
     * **Details**
     *
     * The output starts with the fixed tuple elements, continues with zero or more
     * values decoded by the first rest schema, and includes any trailing rest schemas
     * as fixed tuple positions.
     *
     * @category utility types
     * @since 3.10.0
     */
    type Type<T extends ReadonlyArray<unknown>, Rest extends TupleWithRest.Rest> = Rest extends readonly [infer Head extends Constraint, ...infer Tail extends ReadonlyArray<Constraint>] ? Readonly<[
        ...T,
        ...Array<Head["Type"]>,
        ...{
            readonly [K in keyof Tail]: Tail[K]["Type"];
        }
    ]> : T;
    /**
     * Computes the iso tuple type for a `TupleWithRest`.
     *
     * **Details**
     *
     * The output starts with the fixed tuple's `Iso` elements, continues with zero
     * or more values using the first rest schema's `Iso`, and includes any trailing
     * rest schemas as fixed tuple positions.
     *
     * @category utility types
     * @since 4.0.0
     */
    type Iso<T extends ReadonlyArray<unknown>, Rest extends TupleWithRest.Rest> = Rest extends readonly [infer Head extends Constraint, ...infer Tail extends ReadonlyArray<Constraint>] ? Readonly<[
        ...T,
        ...Array<Head["Iso"]>,
        ...{
            readonly [K in keyof Tail]: Tail[K]["Iso"];
        }
    ]> : T;
    /**
     * Computes the encoded tuple type for `TupleWithRest`.
     *
     * **Details**
     *
     * The leading tuple's encoded elements are kept first. The encoded type of the
     * first rest schema may repeat zero or more times, and the encoded types of any
     * additional rest schemas become required trailing tuple elements.
     *
     * @category utility types
     * @since 3.10.0
     */
    type Encoded<E extends ReadonlyArray<unknown>, Rest extends TupleWithRest.Rest> = Rest extends readonly [infer Head extends Constraint, ...infer Tail extends ReadonlyArray<Constraint>] ? readonly [
        ...E,
        ...Array<Head["Encoded"]>,
        ...{
            readonly [K in keyof Tail]: Tail[K]["Encoded"];
        }
    ] : E;
    /**
     * Computes the constructor input tuple type for `TupleWithRest`.
     *
     * **Details**
     *
     * The leading tuple's make input elements are kept first. The make input type of
     * the first rest schema may repeat zero or more times, and the make input types
     * of any additional rest schemas become required trailing tuple elements.
     *
     * @category utility types
     * @since 4.0.0
     */
    type MakeIn<M extends ReadonlyArray<unknown>, Rest extends TupleWithRest.Rest> = Rest extends readonly [infer Head extends Constraint, ...infer Tail extends ReadonlyArray<Constraint>] ? readonly [
        ...M,
        ...Array<Head["~type.make"]>,
        ...{
            readonly [K in keyof Tail]: Tail[K]["~type.make"];
        }
    ] : M;
}
/**
 * Type-level representation returned by {@link TupleWithRest}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface TupleWithRest<S extends TupleWithRest.TupleType, Rest extends TupleWithRest.Rest> extends BottomLazy<SchemaAST.Arrays, TupleWithRest<S, Rest>> {
    readonly "Type": TupleWithRest.Type<S["Type"], Rest>;
    readonly "Encoded": TupleWithRest.Encoded<S["Encoded"], Rest>;
    readonly "DecodingServices": S["DecodingServices"] | Rest[number]["DecodingServices"];
    readonly "EncodingServices": S["EncodingServices"] | Rest[number]["EncodingServices"];
    readonly "~type.make.in": TupleWithRest.MakeIn<S["~type.make"], Rest>;
    readonly "~type.make": TupleWithRest.MakeIn<S["~type.make"], Rest>;
    readonly "Iso": TupleWithRest.Iso<S["Iso"], Rest>;
    readonly schema: S;
    readonly rest: Rest;
}
/**
 * Extends a fixed-length tuple schema with a variadic rest segment.
 *
 * **Details**
 *
 * The resulting tuple starts with the fixed elements from `schema`. The first
 * schema in `rest` is the repeatable element schema, and any additional schemas
 * in `rest` are required trailing tuple elements after the variadic segment. For
 * example, `[Schema.Boolean, Schema.String]` represents zero or more booleans
 * followed by a final string.
 *
 * **Example** (Defining tuples with rest elements)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * // [string, number, ...boolean[]]
 * const schema = Schema.TupleWithRest(
 *   Schema.Tuple([Schema.String, Schema.Number]),
 *   [Schema.Boolean]
 * )
 *
 * Schema.decodeUnknownSync(schema)(["hello", 1, true, false]) // => ["hello", 1, true, false]
 * ```
 *
 * @stability stable
 * @category constructors
 * @since 4.0.0
 */
export declare function TupleWithRest<S extends Tuple<Tuple.Elements>, const Rest extends TupleWithRest.Rest>(schema: S, rest: Rest): TupleWithRest<S, Rest>;
/**
 * Type-level representation returned by {@link Array}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface $Array<S extends Constraint> extends BottomLazy<SchemaAST.Arrays, $Array<S>> {
    readonly "Type": ReadonlyArray<S["Type"]>;
    readonly "Encoded": ReadonlyArray<S["Encoded"]>;
    readonly "DecodingServices": S["DecodingServices"];
    readonly "EncodingServices": S["EncodingServices"];
    readonly "~type.make.in": ReadonlyArray<S["~type.make"]>;
    readonly "~type.make": ReadonlyArray<S["~type.make"]>;
    readonly "Iso": ReadonlyArray<S["Iso"]>;
    readonly value: S;
}
interface ArrayLambda extends Lambda {
    <S extends Constraint>(self: S): $Array<S>;
    readonly "~lambda.out": this["~lambda.in"] extends Constraint ? $Array<this["~lambda.in"]> : never;
}
/**
 * @category constructors
 * @since 4.0.0
 */
declare const ArraySchema: ArrayLambda;
export { 
/**
 * Defines a `ReadonlyArray` schema for a given element schema.
 *
 * **Example** (Defining an array of strings)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const schema = Schema.Array(Schema.String)
 *
 * Schema.decodeUnknownSync(schema)(["a", "b", "c"]) // => ["a", "b", "c"]
 * ```
 *
 * @stability stable
 * @category constructors
 * @since 4.0.0
 */
ArraySchema as Array };
/**
 * Type-level representation returned by {@link NonEmptyArray}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface NonEmptyArray<S extends Constraint> extends BottomLazy<SchemaAST.Arrays, NonEmptyArray<S>> {
    readonly "Type": readonly [S["Type"], ...Array<S["Type"]>];
    readonly "Encoded": readonly [S["Encoded"], ...Array<S["Encoded"]>];
    readonly "DecodingServices": S["DecodingServices"];
    readonly "EncodingServices": S["EncodingServices"];
    readonly "~type.make.in": readonly [S["~type.make"], ...Array<S["~type.make"]>];
    readonly "~type.make": readonly [S["~type.make"], ...Array<S["~type.make"]>];
    readonly "Iso": readonly [S["Iso"], ...Array<S["Iso"]>];
    readonly value: S;
}
interface NonEmptyArrayLambda extends Lambda {
    <S extends Constraint>(self: S): NonEmptyArray<S>;
    readonly "~lambda.out": this["~lambda.in"] extends Constraint ? NonEmptyArray<this["~lambda.in"]> : never;
}
/**
 * Defines a non-empty `ReadonlyArray` schema — at least one element required.
 * Type is `readonly [T, ...T[]]`.
 *
 * **Example** (Defining a non-empty array of numbers)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const schema = Schema.NonEmptyArray(Schema.Number)
 *
 * Schema.decodeUnknownSync(schema)([1, 2, 3]) // => [1, 2, 3]
 * ```
 *
 * @stability stable
 * @category constructors
 * @since 3.10.0
 */
export declare const NonEmptyArray: NonEmptyArrayLambda;
/**
 * Type-level representation returned by {@link ArrayEnsure}.
 *
 * @stability stable
 * @category constructors
 * @since 3.10.0
 */
export interface ArrayEnsure<S extends Constraint> extends decodeTo<$Array<toType<S>>, Union<readonly [S, $Array<S>]>> {
    readonly "Rebuild": ArrayEnsure<S>;
}
/**
 * Creates a schema that accepts either a value decoded by `schema` or an array
 * decoded by `Schema.Array(schema)`, then returns an array.
 *
 * **When to use**
 *
 * Use to accept input that may be provided either as one item or as an array,
 * while normalizing decoded values to a readonly array.
 *
 * **Details**
 *
 * During encoding, one-element arrays are encoded as the single element. Empty
 * arrays and arrays with two or more elements are encoded as arrays.
 *
 * **Gotchas**
 *
 * The single-value branch is tried before the array branch. If `schema` itself
 * accepts arrays, an array input can be treated as one value and wrapped in a
 * one-element array.
 *
 * @see {@link Array} for accepting only array input
 * @see {@link NonEmptyArray} for requiring at least one decoded element
 *
 * @stability stable
 * @category constructors
 * @since 3.10.0
 */
export declare function ArrayEnsure<S extends Constraint>(schema: S): ArrayEnsure<S>;
/**
 * Type-level representation returned by {@link UniqueArray}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface UniqueArray<S extends Constraint> extends $Array<S> {
    readonly "Rebuild": UniqueArray<S>;
}
/**
 * Returns a new array schema that ensures all elements are unique.
 *
 * **Details**
 *
 * The equivalence used to determine uniqueness is the one provided by
 * `Schema.toEquivalence(item)`.
 *
 * @stability stable
 * @category constructors
 * @since 4.0.0
 */
export declare function UniqueArray<S extends Constraint>(item: S): UniqueArray<S>;
/**
 * Type-level representation returned by {@link mutable}.
 *
 * @stability stable
 * @category transforming
 * @since 3.10.0
 */
export interface mutable<S extends Constraint & {
    readonly "ast": SchemaAST.Arrays;
}> extends BottomLazy<S["ast"], mutable<S>, S["~type.parameters"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
    readonly "Type": Mutable<S["Type"]>;
    readonly "Encoded": Mutable<S["Encoded"]>;
    readonly "DecodingServices": S["DecodingServices"];
    readonly "EncodingServices": S["EncodingServices"];
    readonly "~type.make.in": S["~type.make.in"];
    readonly "~type.make": S["~type.make"];
    readonly "Iso": S["Iso"];
    readonly schema: S;
}
interface mutableLambda extends Lambda {
    <S extends Constraint & {
        readonly "ast": SchemaAST.Arrays;
    }>(self: S): mutable<S>;
    readonly "~lambda.out": this["~lambda.in"] extends Constraint & {
        readonly "ast": SchemaAST.Arrays;
    } ? mutable<this["~lambda.in"]> : "Error: schema not eligible for mutable";
}
/**
 * Makes an array or tuple schema mutable, removing the `readonly` modifier.
 *
 * **Gotchas**
 *
 * This combinator does not support an encoding attached to the array or tuple
 * node and throws if one is present. Encodings on element schemas are
 * supported.
 *
 * **Example** (Defining mutable arrays)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const schema = Schema.mutable(Schema.Array(Schema.Number))
 *
 * // number[]   (mutable)
 * type T = typeof schema.Type
 * const value: T = [1, 2]
 * value.push(3)
 * value // => [1, 2, 3]
 * ```
 *
 * @stability stable
 * @category transforming
 * @since 3.10.0
 */
export declare const mutable: mutableLambda;
/**
 * Type-level representation returned by {@link Union}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface Union<Members extends ReadonlyArray<Constraint>> extends BottomLazy<SchemaAST.Union<{
    [K in keyof Members]: Members[K]["ast"];
}[number]>, Union<Members>> {
    readonly "Type": {
        [K in keyof Members]: Members[K]["Type"];
    }[number];
    readonly "Encoded": {
        [K in keyof Members]: Members[K]["Encoded"];
    }[number];
    readonly "DecodingServices": {
        [K in keyof Members]: Members[K]["DecodingServices"];
    }[number];
    readonly "EncodingServices": {
        [K in keyof Members]: Members[K]["EncodingServices"];
    }[number];
    readonly "~type.make.in": {
        [K in keyof Members]: Members[K]["~type.make"];
    }[number];
    readonly "~type.make": {
        [K in keyof Members]: Members[K]["~type.make"];
    }[number];
    readonly "Iso": {
        [K in keyof Members]: Members[K]["Iso"];
    }[number];
    readonly members: Members;
    /**
     * Returns a new union with the members modified by the provided function.
     *
     * **Details**
     *
     * Options:
     *
     * - `unsafePreserveChecks` - if `true`, keep any `.check(...)` constraints
     *   that were attached to the original union. Defaults to `false`.
     *
     *   **Warning**: This is an unsafe operation. Since `mapFields`
     *   transformations change the schema type, the original refinement functions
     *   may no longer be valid or safe to apply to the transformed schema. Only
     *   use this option if you have verified that your refinements remain correct
     *   after the transformation.
     */
    mapMembers<To extends ReadonlyArray<Constraint>>(f: (members: Members) => To, options?: {
        readonly unsafePreserveChecks?: boolean | undefined;
    } | undefined): Union<Simplify<Readonly<To>>>;
}
/**
 * Creates a union schema from an array of member schemas. Members are tested in
 * order; the first match is returned.
 *
 * **Details**
 *
 * Optionally, specify `mode`:
 * - `"anyOf"` (default) — matches if any member matches.
 * - `"oneOf"` — matches if exactly one member matches.
 *
 * **Example** (Defining a string or number union)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const schema = Schema.Union([Schema.String, Schema.Number])
 *
 * Schema.decodeUnknownSync(schema)("hello") // => "hello"
 * Schema.decodeUnknownSync(schema)(42) // => 42
 * ```
 *
 * @stability stable
 * @category constructors
 * @since 3.10.0
 */
export declare function Union<const Members extends ReadonlyArray<Constraint>>(members: Members, options?: SchemaAST.UnionOptions): Union<Members>;
/**
 * Type-level representation returned by {@link Literals}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface Literals<L extends ReadonlyArray<SchemaAST.LiteralValue>> extends Bottom<L[number], L[number], never, never, SchemaAST.Union<SchemaAST.Literal>, Literals<L>> {
    readonly literals: L;
    readonly members: {
        readonly [K in keyof L]: Literal<L[K]>;
    };
    /**
     * Map over the members of the union.
     */
    mapMembers<To extends ReadonlyArray<Constraint>>(f: (members: this["members"]) => To): Union<Simplify<Readonly<To>>>;
    pick<const L2 extends ReadonlyArray<L[number]>>(literals: L2): Literals<L2>;
    transform<const L2 extends {
        readonly [I in keyof L]: SchemaAST.LiteralValue;
    }>(to: L2): Union<{
        [I in keyof L]: decodeTo<Literal<L2[I]>, Literal<L[I]>>;
    }>;
}
/**
 * Creates a union schema from an array of literal values.
 *
 * **Example** (Defining status codes)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const schema = Schema.Literals(["active", "inactive", "pending"])
 * Schema.decodeSync(schema)("active") // => "active"
 * ```
 *
 * @see {@link Literal} for a schema that represents a single literal.
 * @stability stable
 * @category constructors
 * @since 4.0.0
 */
export declare function Literals<const L extends ReadonlyArray<SchemaAST.LiteralValue>>(literals: L): Literals<L>;
/**
 * Type-level representation returned by {@link NullOr}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface NullOr<S extends Constraint> extends Union<readonly [S, Null]> {
    readonly "Rebuild": NullOr<S>;
}
interface NullOrLambda extends Lambda {
    <S extends Constraint>(self: S): NullOr<S>;
    readonly "~lambda.out": this["~lambda.in"] extends Constraint ? NullOr<this["~lambda.in"]> : never;
}
/**
 * Creates a union schema of `S | null`.
 *
 * @stability stable
 * @category constructors
 * @since 3.10.0
 */
export declare const NullOr: NullOrLambda;
/**
 * Type-level representation returned by {@link UndefinedOr}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface UndefinedOr<S extends Constraint> extends Union<readonly [S, Undefined]> {
    readonly "Rebuild": UndefinedOr<S>;
}
interface UndefinedOrLambda extends Lambda {
    <S extends Constraint>(self: S): UndefinedOr<S>;
    readonly "~lambda.out": this["~lambda.in"] extends Constraint ? UndefinedOr<this["~lambda.in"]> : never;
}
/**
 * Creates a union schema of `S | undefined`.
 *
 * @stability stable
 * @category constructors
 * @since 3.10.0
 */
export declare const UndefinedOr: UndefinedOrLambda;
/**
 * Type-level representation returned by {@link NullishOr}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface NullishOr<S extends Constraint> extends Union<readonly [S, Null, Undefined]> {
    readonly "Rebuild": NullishOr<S>;
}
interface NullishOrLambda extends Lambda {
    <S extends Constraint>(self: S): NullishOr<S>;
    readonly "~lambda.out": this["~lambda.in"] extends Constraint ? NullishOr<this["~lambda.in"]> : never;
}
/**
 * Creates a union schema of `S | null | undefined`.
 *
 * @stability stable
 * @category constructors
 * @since 3.10.0
 */
export declare const NullishOr: NullishOrLambda;
/**
 * Type-level representation returned by {@link suspend}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface suspend<S extends Constraint> extends BottomLazy<SchemaAST.Suspend, suspend<S>, S["~type.parameters"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
    readonly "Type": S["Type"];
    readonly "Encoded": S["Encoded"];
    readonly "DecodingServices": S["DecodingServices"];
    readonly "EncodingServices": S["EncodingServices"];
    readonly "~type.make.in": S["~type.make.in"];
    readonly "~type.make": S["~type.make"];
    readonly "Iso": S["Iso"];
}
/**
 * Creates a suspended schema that defers evaluation until needed. This is
 * essential for creating recursive schemas where a schema references itself,
 * preventing infinite recursion during schema definition.
 *
 * **Example** (Defining recursive tree schemas)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * interface Tree {
 *   readonly value: number
 *   readonly children: ReadonlyArray<Tree>
 * }
 *
 * const Tree = Schema.Struct({
 *   value: Schema.Number,
 *   children: Schema.Array(Schema.suspend((): Schema.Codec<Tree> => Tree))
 * })
 * Schema.decodeSync(Tree)({ value: 1, children: [] }) // => { value: 1, children: [] }
 * ```
 *
 * @stability stable
 * @category constructors
 * @since 3.10.0
 */
export declare function suspend<S extends Constraint>(f: () => S): suspend<S>;
/**
 * Attaches one or more filter checks to a schema without changing the
 * TypeScript type.
 *
 * **Example** (Adding checks to a schema)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const AgeSchema = Schema.Finite.pipe(
 *   Schema.check(Schema.isGreaterThanOrEqualTo(0), Schema.isLessThanOrEqualTo(120))
 * )
 * Schema.is(AgeSchema)(42) // => true
 * Schema.is(AgeSchema)(121) // => false
 * ```
 *
 * @stability stable
 * @category filtering
 * @since 4.0.0
 */
export declare function check<S extends Top>(...checks: readonly [SchemaAST.Check<S["Type"]>, ...Array<SchemaAST.Check<S["Type"]>>]): (self: S) => S["Rebuild"];
/**
 * Type-level representation returned by {@link refine}.
 *
 * @stability stable
 * @category filtering
 * @since 3.10.0
 */
export interface refine<T extends S["Type"], S extends Constraint> extends BottomLazy<S["ast"], refine<T, S>, S["~type.parameters"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
    readonly "Type": T;
    readonly "Encoded": S["Encoded"];
    readonly "DecodingServices": S["DecodingServices"];
    readonly "EncodingServices": S["EncodingServices"];
    readonly "~type.make.in": S["~type.make.in"];
    readonly "~type.make": T;
    readonly "Iso": T;
    readonly schema: S;
}
/**
 * Narrows the TypeScript type of a schema's output via a type guard predicate,
 * attaching the guard as a runtime filter check.
 *
 * **Details**
 *
 * The `annotations` parameter annotates the filter created by the refinement.
 * With the default formatter, failed refinements use `message` first,
 * `expected` second, and `<filter>` when neither is provided. `identifier`
 * names type-level failures before the refinement runs; it does not name the
 * failed refinement itself.
 *
 * @stability stable
 * @category filtering
 * @since 3.10.0
 */
export declare function refine<S extends Constraint, T extends S["Type"]>(refinement: (value: S["Type"]) => value is T, annotations?: Annotations.Filter): (schema: S) => refine<T, S>;
type EnsureSingleBrandKey<K extends PropertyKey> = IsUnion<K> extends false ? {} extends Record<K, unknown> ? never : unknown : never;
type FromBrandKeys<A extends Brand.Brand<any>> = A extends unknown ? Brand.Brand.Keys<A> : never;
/**
 * Type-level representation returned by {@link brand}.
 *
 * @stability stable
 * @category branding
 * @since 3.10.0
 */
export interface brand<S extends Constraint, B extends string> extends BottomLazy<S["ast"], brand<S, B>, S["~type.parameters"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
    readonly "Type": S["Type"] & Brand.Brand<B>;
    readonly "Encoded": S["Encoded"];
    readonly "DecodingServices": S["DecodingServices"];
    readonly "EncodingServices": S["EncodingServices"];
    readonly "~type.make.in": S["~type.make.in"];
    readonly "~type.make": S["Type"] & Brand.Brand<B>;
    readonly "Iso": S["Type"] & Brand.Brand<B>;
    readonly schema: S;
    readonly identifier: string;
}
/**
 * Intersects a schema's output type with `Brand.Brand<B>` to prevent accidental
 * mixing of structurally identical types.
 *
 * **When to use**
 *
 * Use to make values decoded by an existing schema nominally distinct when the
 * schema already carries the runtime validation you need.
 *
 * **Gotchas**
 *
 * - `identifier` must be a single concrete string literal. Widened strings,
 *   unions, and open template literal types are rejected.
 * - `brand` only narrows the TypeScript output type. It does not change the
 *   schema's runtime AST or add runtime checks.
 * - Schema representations and generated schema code omit the brand. Reapply
 *   `brand` after rebuilding or generating a schema when the nominal type is
 *   still required.
 *
 * @see {@link fromBrand} for applying a Brand constructor's checks along with its branded type
 *
 * @stability stable
 * @category branding
 * @since 3.10.0
 */
export declare function brand<B extends string>(identifier: B & EnsureSingleBrandKey<B>): <S extends ConstraintRebuildable>(schema: S) => brand<S["Rebuild"], B>;
/**
 * Creates a branded schema from a {@link Brand.Constructor}, applying the
 * constructor's checks and branded type to the underlying schema.
 *
 * **When to use**
 *
 * Use to reuse the checks from a constructor with one concrete brand key.
 *
 * **Gotchas**
 *
 * `identifier` must match the constructor's only brand key. Apply `fromBrand`
 * repeatedly to compose distinct brands, and use {@link Union} to represent
 * alternatives.
 *
 * @see {@link brand} for adding a brand without constructor checks
 *
 * @stability stable
 * @category branding
 * @since 3.10.0
 */
export declare function fromBrand<A extends Brand.Brand<any>>(identifier: Brand.Brand.Keys<A> & string, ctor: Brand.Constructor<A> & EnsureSingleBrandKey<FromBrandKeys<A>>): <S extends Top & {
    readonly "Type": Brand.Brand.Unbranded<A>;
}>(self: S) => brand<S["Rebuild"], keyof A["~effect/Brand"] & string>;
/**
 * Type-level representation returned by {@link middlewareDecoding}.
 *
 * @stability stable
 * @category decoding
 * @since 4.0.0
 */
export interface middlewareDecoding<S extends Constraint, RD> extends BottomLazy<S["ast"], middlewareDecoding<S, RD>, S["~type.parameters"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
    readonly "Type": S["Type"];
    readonly "Encoded": S["Encoded"];
    readonly "DecodingServices": RD;
    readonly "EncodingServices": S["EncodingServices"];
    readonly "~type.make.in": S["~type.make.in"];
    readonly "~type.make": S["~type.make"];
    readonly "Iso": S["Iso"];
    readonly schema: S;
}
/**
 * Intercepts the decoding pipeline of a schema.
 *
 * **Details**
 *
 * The provided function receives the current decoding `Effect` and `ParseOptions`,
 * and returns a new `Effect` — potentially adding service requirements (`RD`),
 * recovering from errors, or augmenting the result.
 *
 * **Example** (Logging decode failures)
 *
 * ```ts import.meta.vitest
 * import { Effect, Schema } from "effect"
 *
 * const events: Array<string> = []
 * const Logged = Schema.String.pipe(
 *   Schema.middlewareDecoding((effect) =>
 *     Effect.tapError(effect, () => Effect.sync(() => events.push("decode failed")))
 *   )
 * )
 * Effect.runSync(Effect.result(Schema.decodeUnknownEffect(Logged)(42)))
 * events // => ["decode failed"]
 * ```
 *
 * @see {@link catchDecoding} for a simpler error-recovery variant
 * @stability stable
 * @category decoding
 * @since 4.0.0
 */
export declare function middlewareDecoding<S extends Constraint, RD>(decode: (effect: Effect.Effect<Option_.Option<S["Type"]>, SchemaIssue.Issue, S["DecodingServices"]>, options: SchemaAST.ParseOptions) => Effect.Effect<Option_.Option<S["Type"]>, SchemaIssue.Issue, RD>): (schema: S) => middlewareDecoding<S, RD>;
/**
 * Type-level representation returned by {@link middlewareEncoding}.
 *
 * @stability stable
 * @category encoding
 * @since 4.0.0
 */
export interface middlewareEncoding<S extends Constraint, RE> extends BottomLazy<S["ast"], middlewareEncoding<S, RE>, S["~type.parameters"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
    readonly "Type": S["Type"];
    readonly "Encoded": S["Encoded"];
    readonly "DecodingServices": S["DecodingServices"];
    readonly "EncodingServices": RE;
    readonly "~type.make.in": S["~type.make.in"];
    readonly "~type.make": S["~type.make"];
    readonly "Iso": S["Iso"];
    readonly schema: S;
}
/**
 * Intercepts the encoding pipeline of a schema.
 *
 * **Details**
 *
 * The provided function receives the current encoding `Effect` and `ParseOptions`,
 * and returns a new `Effect` — potentially adding service requirements (`RE`),
 * recovering from errors, or augmenting the result.
 *
 * **Example** (Logging encode failures)
 *
 * ```ts import.meta.vitest
 * import { Effect, Schema } from "effect"
 *
 * const events: Array<string> = []
 * const Logged = Schema.String.pipe(
 *   Schema.middlewareEncoding((effect) =>
 *     Effect.tapError(effect, () => Effect.sync(() => events.push("encode failed")))
 *   )
 * )
 * Effect.runSync(Effect.result(Schema.encodeUnknownEffect(Logged)(42)))
 * events // => ["encode failed"]
 * ```
 *
 * @see {@link catchEncoding} for a simpler error-recovery variant
 * @stability stable
 * @category encoding
 * @since 4.0.0
 */
export declare function middlewareEncoding<S extends Constraint, RE>(encode: (effect: Effect.Effect<Option_.Option<S["Encoded"]>, SchemaIssue.Issue, S["EncodingServices"]>, options: SchemaAST.ParseOptions) => Effect.Effect<Option_.Option<S["Encoded"]>, SchemaIssue.Issue, RE>): (schema: S) => middlewareEncoding<S, RE>;
/**
 * Recovers from a decoding error by providing a fallback value.
 *
 * **Details**
 *
 * The handler receives the `Issue` and returns an `Effect` that either
 * succeeds with a fallback value or re-fails with a (possibly different) issue.
 *
 * **Example** (Returning a default on decode failure)
 *
 * ```ts import.meta.vitest
 * import { Effect, Option, Schema } from "effect"
 *
 * const schema = Schema.Number.pipe(
 *   Schema.catchDecoding((_issue) => Effect.succeed(Option.some(0)))
 * )
 * Effect.runSync(Schema.decodeUnknownEffect(schema)("invalid")) // => 0
 * ```
 *
 * @see {@link catchDecodingWithContext} to add service requirements to the handler
 * @stability stable
 * @category error handling
 * @since 4.0.0
 */
export declare function catchDecoding<S extends Constraint>(f: (issue: SchemaIssue.Issue) => Effect.Effect<Option_.Option<S["Type"]>, SchemaIssue.Issue>): (self: S) => middlewareDecoding<S, S["DecodingServices"]>;
/**
 * Recovers from a decoding error with a handler that may require Effect services.
 *
 * **When to use**
 *
 * Use when you need decoding fallback logic to require services from the Effect
 * context.
 *
 * **Details**
 *
 * The handler receives the `Issue` and returns an `Effect` that either succeeds
 * with a fallback value or re-fails with a (possibly different) issue. The
 * handler's services are added to the schema's decoding services.
 *
 * @see {@link catchDecoding} for recovery handlers that do not require services
 * @see {@link middlewareDecoding} for intercepting or replacing the full decoding pipeline
 *
 * @stability stable
 * @category error handling
 * @since 4.0.0
 */
export declare function catchDecodingWithContext<S extends Constraint, R = never>(f: (issue: SchemaIssue.Issue) => Effect.Effect<Option_.Option<S["Type"]>, SchemaIssue.Issue, R>): (self: S) => middlewareDecoding<S, S["DecodingServices"] | R>;
/**
 * Recovers from an encoding error by providing a fallback value.
 *
 * **Details**
 *
 * The handler receives the `Issue` and returns an `Effect` that either
 * succeeds with a fallback value or re-fails with a (possibly different) issue.
 *
 * @see {@link catchEncodingWithContext} to add service requirements to the handler
 * @stability stable
 * @category error handling
 * @since 4.0.0
 */
export declare function catchEncoding<S extends Constraint>(f: (issue: SchemaIssue.Issue) => Effect.Effect<Option_.Option<S["Encoded"]>, SchemaIssue.Issue>): (self: S) => middlewareEncoding<S, S["EncodingServices"]>;
/**
 * Recovers from an encoding error with a handler that may require Effect services.
 *
 * **When to use**
 *
 * Use when you need encoding fallback logic to require services from the Effect
 * context.
 *
 * **Details**
 *
 * The handler receives the `Issue` and returns an `Effect` that either succeeds
 * with a fallback encoded value or re-fails with a (possibly different) issue.
 * The handler's services are added to the schema's encoding services.
 *
 * @see {@link catchEncoding} for recovery handlers that do not require services
 * @see {@link middlewareEncoding} for intercepting or replacing the full encoding pipeline
 *
 * @stability stable
 * @category error handling
 * @since 4.0.0
 */
export declare function catchEncodingWithContext<S extends Constraint, R = never>(f: (issue: SchemaIssue.Issue) => Effect.Effect<Option_.Option<S["Encoded"]>, SchemaIssue.Issue, R>): (self: S) => middlewareEncoding<S, S["EncodingServices"] | R>;
/**
 * Type-level representation returned by {@link decodeTo}.
 *
 * @stability stable
 * @category transforming
 * @since 4.0.0
 */
export interface decodeTo<To extends Constraint, From extends Constraint, RD = never, RE = never> extends BottomLazy<To["ast"], decodeTo<To, From, RD, RE>, To["~type.parameters"], To["~type.mutability"], To["~type.optionality"], To["~type.constructor.default"], From["~encoded.mutability"], From["~encoded.optionality"]> {
    readonly "Type": To["Type"];
    readonly "Encoded": From["Encoded"];
    readonly "DecodingServices": To["DecodingServices"] | From["DecodingServices"] | RD;
    readonly "EncodingServices": To["EncodingServices"] | From["EncodingServices"] | RE;
    readonly "~type.make.in": To["~type.make.in"];
    readonly "~type.make": To["~type.make"];
    readonly "Iso": To["Iso"];
    readonly from: From;
    readonly to: To;
}
/**
 * Type-level representation returned by {@link decodeTo} without a custom transformation.
 *
 * @stability stable
 * @category transforming
 * @since 3.10.0
 */
export interface compose<To extends Constraint, From extends Constraint> extends decodeTo<To, From> {
}
/**
 * Creates a schema that transforms from a source schema to a target schema.
 *
 * **When to use**
 *
 * Use when decoding should change the schema's decoded type or encoded shape,
 * with an optional custom bidirectional transformation.
 *
 * **Details**
 *
 * Call it with the target schema `to` and then pipe the source schema `from`
 * into the returned function. The resulting schema decodes from
 * `From["Encoded"]` to `To["Type"]` and encodes from `To["Type"]` back to
 * `From["Encoded"]`.
 *
 * When no transformation is provided, `SchemaTransformation.passthrough()` is
 * used, so `From["Type"]` must already be compatible with `To["Encoded"]`.
 * The resulting schema combines decoding and encoding services from both
 * schemas and any custom transformation.
 *
 * **Gotchas**
 *
 * In a custom transformation, `decode` maps `From["Type"]` to `To["Encoded"]`
 * and is used on the decoding path, while `encode` maps `To["Encoded"]` to
 * `From["Type"]` and is used on the encoding path.
 *
 * **Example** (Transforming strings to numbers with a schema transformation)
 *
 * ```ts import.meta.vitest
 * import { Schema, SchemaGetter } from "effect"
 *
 * const NumberFromString = Schema.String.pipe(
 *   Schema.decodeTo(
 *     Schema.Number,
 *     {
 *       decode: SchemaGetter.transform((s) => Number(s)),
 *       encode: SchemaGetter.transform((n) => String(n))
 *     }
 *   )
 * )
 *
 * Schema.decodeUnknownSync(NumberFromString)("123") // => 123
 * ```
 *
 * @stability stable
 * @category transforming
 * @since 4.0.0
 */
export declare function decodeTo<To extends Constraint>(to: To): <From extends Constraint>(from: From) => compose<To, From>;
export declare function decodeTo<To extends Constraint, From extends Constraint, RD = never, RE = never>(to: To, transformation: {
    readonly decode: SchemaGetter.Getter<NoInfer<To["Encoded"]>, NoInfer<From["Type"]>, RD>;
    readonly encode: SchemaGetter.Getter<NoInfer<From["Type"]>, NoInfer<To["Encoded"]>, RE>;
}): (from: From) => decodeTo<To, From, RD, RE>;
/**
 * Applies a transformation to a schema, creating a new schema with the same type but transformed encoding/decoding.
 *
 * **When to use**
 *
 * Use when the decoded type stays the same and the transformation only
 * normalizes values during encoding and decoding.
 *
 * **Details**
 *
 * Call it with a transformation object and then pipe a schema into the returned
 * function. The resulting schema keeps the same `Type` and `Encoded` types as
 * the source schema, while applying the transformation during both decoding and
 * encoding.
 *
 * Internally this uses `toType(self)` as the target schema and combines service
 * requirements from the source schema and the transformation.
 *
 * **Gotchas**
 *
 * Use {@link decodeTo} instead when the transformation should change the
 * decoded type. For this helper, both transformation getters operate on
 * `S["Type"]` values.
 *
 * **Example** (Trimming string values during encoding/decoding)
 *
 * ```ts import.meta.vitest
 * import { Schema, SchemaGetter } from "effect"
 *
 * const Trimmed = Schema.String.pipe(
 *   Schema.decode({
 *     decode: SchemaGetter.transform((s) => s.trim()),
 *     encode: SchemaGetter.transform((s) => s.trim())
 *   })
 * )
 *
 * Schema.decodeUnknownSync(Trimmed)("  hello  ") // => "hello"
 * ```
 *
 * @stability stable
 * @category transforming
 * @since 4.0.0
 */
export declare function decode<S extends Constraint, RD = never, RE = never>(transformation: {
    readonly decode: SchemaGetter.Getter<S["Type"], S["Type"], RD>;
    readonly encode: SchemaGetter.Getter<S["Type"], S["Type"], RE>;
}): (self: S) => decodeTo<toType<S>, S, RD, RE>;
/**
 * Reverses a schema transformation so the encoded schema is supplied first.
 *
 * **When to use**
 *
 * Use to define a transformation by naming the encoded schema before the
 * decoded schema.
 *
 * **Details**
 *
 * `encodeTo(to)(from)` is equivalent to `to.pipe(decodeTo(from))`. The `from`
 * schema acts as the target decoded schema and `to` acts as the encoded source.
 *
 * **Example** (Encoding a number back to a string)
 *
 * ```ts import.meta.vitest
 * import { Schema, SchemaGetter } from "effect"
 *
 * const NumberFromString = Schema.Number.pipe(
 *   Schema.encodeTo(Schema.String, {
 *     decode: SchemaGetter.transform((s: string) => Number(s)),
 *     encode: SchemaGetter.transform((n: number) => String(n))
 *   })
 * )
 * Schema.decodeSync(NumberFromString)("42") // => 42
 * ```
 *
 * @stability stable
 * @category transforming
 * @since 4.0.0
 */
export declare function encodeTo<To extends Constraint>(to: To): <From extends Constraint>(from: From) => compose<From, To>;
export declare function encodeTo<To extends Constraint, From extends Constraint, RD = never, RE = never>(to: To, transformation: {
    readonly decode: SchemaGetter.Getter<NoInfer<From["Encoded"]>, NoInfer<To["Type"]>, RD>;
    readonly encode: SchemaGetter.Getter<NoInfer<To["Type"]>, NoInfer<From["Encoded"]>, RE>;
}): (from: From) => decodeTo<From, To, RD, RE>;
/**
 * Applies a transformation to a schema's encoded type, creating a new schema where encoding/decoding
 * operate on `S["Encoded"]` rather than `S["Type"]`.
 *
 * **Details**
 *
 * The `decode` getter maps `S["Encoded"]` → `S["Encoded"]` (applied during decoding),
 * and the `encode` getter maps `S["Encoded"]` → `S["Encoded"]` (applied during encoding).
 *
 * **Example** (Upper-casing encoded strings)
 *
 * ```ts import.meta.vitest
 * import { Schema, SchemaGetter } from "effect"
 *
 * const UpperFromLower = Schema.String.pipe(
 *   Schema.encode({
 *     decode: SchemaGetter.transform((s: string) => s.toLowerCase()),
 *     encode: SchemaGetter.transform((s: string) => s.toUpperCase())
 *   })
 * )
 * Schema.encodeSync(UpperFromLower)("hello") // => "HELLO"
 * ```
 *
 * @stability stable
 * @category transforming
 * @since 4.0.0
 */
export declare function encode<S extends Constraint, RD = never, RE = never>(transformation: {
    readonly decode: SchemaGetter.Getter<S["Encoded"], S["Encoded"], RD>;
    readonly encode: SchemaGetter.Getter<S["Encoded"], S["Encoded"], RE>;
}): (self: S) => decodeTo<S, toEncoded<S>, RD, RE>;
/**
 * Constraint used to ensure a schema field does not already have a constructor default.
 *
 * **Details**
 *
 * Only schemas that satisfy this constraint can be passed to {@link withConstructorDefault}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface WithoutConstructorDefault {
    readonly "~type.constructor.default": "no-default";
}
/**
 * Type-level representation returned by {@link withConstructorDefault}.
 *
 * @stability stable
 * @category constructors
 * @since 3.10.0
 */
export interface withConstructorDefault<S extends Constraint & WithoutConstructorDefault> extends BottomLazy<S["ast"], withConstructorDefault<S>, S["~type.parameters"], S["~type.mutability"], S["~type.optionality"], "with-default", S["~encoded.mutability"], S["~encoded.optionality"]> {
    readonly "Type": S["Type"];
    readonly "Encoded": S["Encoded"];
    readonly "DecodingServices": S["DecodingServices"];
    readonly "EncodingServices": S["EncodingServices"];
    readonly "~type.make.in": S["~type.make.in"];
    readonly "~type.make": S["~type.make"];
    readonly "Iso": S["Iso"];
    readonly schema: S;
}
/**
 * Attaches a constructor default value to a schema field.
 *
 * **Details**
 *
 * Constructor defaults are applied only during `make*`, not during decoding or
 * encoding. Failures are represented directly as `SchemaIssue.Issue` values.
 *
 * **Example** (Defining an optional field with a static default)
 *
 * ```ts import.meta.vitest
 * import { Effect, Schema } from "effect"
 *
 * const MySchema = Schema.Struct({
 *   name: Schema.String.pipe(
 *     Schema.optionalKey,
 *     Schema.withConstructorDefault(Effect.succeed("anonymous"))
 *   )
 * })
 *
 * MySchema.make({}).name // => "anonymous"
 * ```
 *
 * @stability stable
 * @category constructors
 * @since 3.10.0
 */
export declare function withConstructorDefault<S extends Constraint & WithoutConstructorDefault>(defaultValue: Effect.Effect<S["~type.make.in"], SchemaIssue.Issue>): (schema: S) => withConstructorDefault<S>;
/**
 * Type-level representation returned by {@link withDecodingDefaultKey}.
 *
 * @stability stable
 * @category decoding
 * @since 4.0.0
 */
export interface withDecodingDefaultKey<S extends Constraint, R = never> extends decodeTo<S, optionalKey<toEncoded<S>>, R> {
    readonly "Rebuild": withDecodingDefaultKey<S, R>;
}
/**
 * Options for {@link withDecodingDefaultKey} and {@link withDecodingDefault}.
 *
 * **Details**
 *
 * - `encodingStrategy`:
 *   - `"passthrough"` (default): pass the value through during encoding
 *   - `"omit"`: omit the key from the encoded output
 *
 * @stability stable
 * @category options
 * @since 4.0.0
 */
export type DecodingDefaultOptions = {
    readonly encodingStrategy?: "omit" | "passthrough" | undefined;
};
/**
 * Makes a struct key optional on the `Encoded` side and provides a default
 * `Encoded` value when the key is missing during decoding.
 *
 * **Details**
 *
 * The key uses `optionalKey` on the encoded side, so it may be absent from the
 * input object but **not** `undefined`. The default value is specified in terms
 * of the `Encoded` type (before any decoding transformations).
 *
 * Options:
 *
 * - `encodingStrategy`:
 *   - `"passthrough"` (default): include the value in the encoded output.
 *   - `"omit"`: omit the key from the encoded output.
 *
 * **Example** (Providing a default for a missing struct key)
 *
 * ```ts import.meta.vitest
 * import { Effect, Schema } from "effect"
 *
 * const MySchema = Schema.Struct({
 *   name: Schema.String.pipe(Schema.withDecodingDefaultKey(Effect.succeed("anonymous")))
 * })
 *
 * Schema.decodeUnknownSync(MySchema)({}).name // => "anonymous"
 * ```
 *
 * @see {@link withDecodingDefault} for the value-level variant (key absent **or** `undefined`)
 * @see {@link withDecodingDefaultTypeKey} for the variant where the default is a `Type` value
 * @stability stable
 * @category decoding
 * @since 4.0.0
 */
export declare function withDecodingDefaultKey<S extends Constraint, R = never>(defaultValue: Effect.Effect<S["Encoded"], SchemaError, R>, options?: DecodingDefaultOptions): (self: S) => withDecodingDefaultKey<S, R>;
/**
 * Type-level representation returned by {@link withDecodingDefaultTypeKey}.
 *
 * @stability stable
 * @category decoding
 * @since 4.0.0
 */
export interface withDecodingDefaultTypeKey<S extends Constraint, R = never> extends decodeTo<withDecodingDefaultKey<toType<S>, R>, optionalKey<S>> {
    readonly "Rebuild": withDecodingDefaultTypeKey<S, R>;
}
/**
 * Makes a struct key optional on the `Encoded` side (`optionalKey`, so the
 * key may be absent but **not** `undefined`) and provides a default `Type`
 * value when the key is missing during decoding.
 *
 * **Details**
 *
 * Unlike {@link withDecodingDefaultKey}, the default value is specified in
 * terms of the `Type` (decoded) representation, so it does not need to go
 * through the decoding transformation.
 *
 * Options:
 *
 * - `encodingStrategy`:
 *   - `"passthrough"` (default): include the value in the encoded output.
 *   - `"omit"`: omit the key from the encoded output.
 *
 * @see {@link withDecodingDefaultKey} for the variant where the default is an `Encoded` value
 * @see {@link withDecodingDefaultType} for the value-level variant
 * @stability stable
 * @category decoding
 * @since 4.0.0
 */
export declare function withDecodingDefaultTypeKey<S extends Constraint, R = never>(defaultValue: Effect.Effect<S["Type"], SchemaError, R>, options?: DecodingDefaultOptions): (self: S) => withDecodingDefaultTypeKey<S, R>;
/**
 * Type-level representation returned by {@link withDecodingDefault}.
 *
 * @stability stable
 * @category decoding
 * @since 3.10.0
 */
export interface withDecodingDefault<S extends Constraint, R = never> extends decodeTo<S, optional<toEncoded<S>>, R> {
    readonly "Rebuild": withDecodingDefault<S, R>;
}
/**
 * Wraps the `Encoded` side with `optional` (key absent **or** `undefined`)
 * and provides a default `Encoded` value when the field is missing or
 * `undefined` during decoding.
 *
 * **When to use**
 *
 * Use when the default is expressed in the encoded representation, before the
 * field's decoding transformation runs.
 *
 * **Details**
 *
 * The default value is specified in terms of the `Encoded` type (before any
 * decoding transformations).
 *
 * Options:
 *
 * - `encodingStrategy`:
 *   - `"passthrough"` (default): include the value in the encoded output.
 *   - `"omit"`: omit the key from the encoded output.
 *
 * **Example** (Providing a default for an optional field value)
 *
 * ```ts import.meta.vitest
 * import { Effect, Schema } from "effect"
 *
 * const MySchema = Schema.Struct({
 *   name: Schema.String.pipe(Schema.optional, Schema.withDecodingDefault(Effect.succeed("anonymous")))
 * })
 *
 * Schema.decodeUnknownSync(MySchema)({ name: undefined }).name // => "anonymous"
 * ```
 *
 * @see {@link withDecodingDefaultKey} for the key-level variant (key absent only, not `undefined`)
 * @see {@link withDecodingDefaultType} for the variant where the default is a `Type` value
 * @stability stable
 * @category decoding
 * @since 3.10.0
 */
export declare function withDecodingDefault<S extends Constraint, R = never>(defaultValue: Effect.Effect<S["Encoded"], SchemaError, R>, options?: DecodingDefaultOptions): (self: S) => withDecodingDefault<S, R>;
/**
 * Type-level representation returned by {@link withDecodingDefaultType}.
 *
 * @stability stable
 * @category decoding
 * @since 4.0.0
 */
export interface withDecodingDefaultType<S extends Constraint, R = never> extends decodeTo<withDecodingDefault<toType<S>, R>, optional<S>> {
    readonly "Rebuild": withDecodingDefaultType<S, R>;
}
/**
 * Wraps the `Encoded` side with `optional` (key absent **or** `undefined`)
 * and provides a default `Type` value when the field is missing or
 * `undefined` during decoding.
 *
 * **When to use**
 *
 * Use when the default is already in the decoded representation and should not
 * pass through the field's decoding transformation.
 *
 * **Details**
 *
 * Unlike {@link withDecodingDefault}, the default value is specified in terms
 * of the `Type` (decoded) representation, so it does not need to go through
 * the decoding transformation.
 *
 * Options:
 *
 * - `encodingStrategy`:
 *   - `"passthrough"` (default): include the value in the encoded output.
 *   - `"omit"`: omit the key from the encoded output.
 *
 * @see {@link withDecodingDefault} for the variant where the default is an `Encoded` value
 * @see {@link withDecodingDefaultTypeKey} for the key-level variant
 * @stability stable
 * @category decoding
 * @since 4.0.0
 */
export declare function withDecodingDefaultType<S extends Constraint, R = never>(defaultValue: Effect.Effect<S["Type"], SchemaError, R>, options?: DecodingDefaultOptions): (self: S) => withDecodingDefaultType<S, R>;
/**
 * Type-level representation returned by {@link tag}.
 *
 * @stability stable
 * @category constructors
 * @since 3.10.0
 */
export interface tag<Tag extends SchemaAST.LiteralValue> extends withConstructorDefault<Literal<Tag>> {
}
/**
 * Combines a {@link Literal} schema with {@link withConstructorDefault}, making it ideal
 * for discriminator fields in tagged unions. When constructing via `make`, the
 * `_tag` field can be omitted and will be filled automatically.
 *
 * **Example** (Defining a discriminated union tag)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const A = Schema.Struct({ _tag: Schema.tag("A"), value: Schema.Number })
 *
 * // _tag is optional in make, auto-filled to "A"
 * const a = A.make({ value: 42 })
 * a // => { _tag: "A", value: 42 }
 * ```
 *
 * @see {@link tagDefaultOmit} to also omit the tag during encoding
 * @see {@link TaggedStruct} for a shorthand that adds `_tag` automatically
 * @stability stable
 * @category constructors
 * @since 3.10.0
 */
export declare function tag<Tag extends SchemaAST.LiteralValue>(literal: Tag): tag<Tag>;
/**
 * Creates a literal `_tag` schema that is omitted from encoded output.
 *
 * **When to use**
 *
 * Use to decode data that omits the discriminator field while still constructing
 * values with a `_tag` for tagged union matching.
 *
 * **Details**
 *
 * The tag is filled during decoding and construction, like {@link tag}, but is
 * omitted when encoding.
 *
 * **Example** (Omitting tags during encoding)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const A = Schema.Struct({
 *   _tag: Schema.tagDefaultOmit("A"),
 *   value: Schema.Number
 * })
 *
 * // Encode strips the _tag field
 * Schema.encodeUnknownSync(A)({ _tag: "A", value: 1 }) // => { value: 1 }
 * ```
 *
 * @see {@link tag} for the variant that keeps the tag during encoding
 * @stability stable
 * @category constructors
 * @since 4.0.0
 */
export declare function tagDefaultOmit<Tag extends SchemaAST.LiteralValue>(literal: Tag): withDecodingDefaultKey<tag<Tag>, never>;
/**
 * Type-level representation returned by {@link TaggedStruct}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export type TaggedStruct<Tag extends SchemaAST.LiteralValue, Fields extends Struct.Fields> = Struct<Simplify<{
    readonly _tag: tag<Tag>;
} & Fields>>;
/**
 * Creates a struct schema with an automatically populated `_tag` field.
 *
 * **When to use**
 *
 * Use to define a tagged union case from a literal tag and a set of fields.
 *
 * **Details**
 *
 * When using the `make` method, the `_tag` field is optional and will be
 * added automatically. However, when decoding or encoding, the `_tag` field
 * must be present in the input.
 *
 * **Example** (Defining a tagged struct shorthand)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * // Defines a struct with a fixed `_tag` field
 * const tagged = Schema.TaggedStruct("A", {
 *   a: Schema.String
 * })
 *
 * // This is the same as writing:
 * const equivalent = Schema.Struct({
 *   _tag: Schema.tag("A"),
 *   a: Schema.String
 * })
 * void tagged
 * void equivalent
 * ```
 *
 * **Example** (Accessing the literal value of the tag)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const tagged = Schema.TaggedStruct("A", {
 *   a: Schema.String
 * })
 *
 * tagged.fields._tag.schema.literal // => "A"
 * ```
 *
 * @stability stable
 * @category constructors
 * @since 3.10.0
 */
export declare function TaggedStruct<const Tag extends SchemaAST.LiteralValue, const Fields extends Struct.Fields>(value: Tag, fields: Fields): TaggedStruct<Tag, Fields>;
/**
 * Recursively flatten any nested Schema.Union members into a single tuple of leaf schemas.
 */
type Flatten<Schemas> = Schemas extends readonly [infer Head, ...infer Tail] ? Head extends Union<infer Inner> ? [...Flatten<Inner>, ...Flatten<Tail>] : [Head, ...Flatten<Tail>] : [];
type MatchCasesResult<Cases> = {
    [K in keyof Cases]-?: NonNullable<Cases[K]> extends (...args: Array<any>) => infer R ? R : never;
}[keyof Cases];
type MatchOrElseResult<Cases, OrElse extends (...args: Array<any>) => any> = Unify<MatchCasesResult<Cases> | ReturnType<OrElse>>;
type TaggedUnionUtils<Tag extends PropertyKey, Members extends ReadonlyArray<Constraint & {
    readonly Type: {
        readonly [K in Tag]: PropertyKey;
    };
}>, Flattened extends ReadonlyArray<Constraint & {
    readonly Type: {
        readonly [K in Tag]: PropertyKey;
    };
}> = Flatten<Members>> = {
    /**
     * Property key used to discriminate union members.
     */
    readonly tag: Tag;
    /**
     * Discriminant values in flattened member order.
     */
    readonly discriminants: {
        readonly [I in keyof Flattened]: Flattened[I]["Type"][Tag];
    };
    readonly cases: Simplify<{
        [M in Flattened[number] as M["Type"][Tag]]: M;
    }>;
    readonly isAnyOf: <const Keys>(keys: ReadonlyArray<Keys>) => (value: Members[number]["Type"]) => value is Extract<Members[number]["Type"], {
        readonly [K in Tag]: Keys;
    }>;
    readonly guards: {
        [M in Flattened[number] as M["Type"][Tag]]: (u: unknown) => u is M["Type"];
    };
    readonly match: {
        <Cases extends {
            [M in Flattened[number] as M["Type"][Tag]]: (value: M["Type"]) => any;
        }>(value: Members[number]["Type"], cases: Cases): Cases[keyof Cases] extends (value: any) => infer R ? Unify<R> : never;
        <Cases extends {
            [M in Flattened[number] as M["Type"][Tag]]: (value: M["Type"]) => any;
        }>(cases: Cases): (value: Members[number]["Type"]) => Cases[keyof Cases] extends (value: any) => infer R ? Unify<R> : never;
    };
    readonly matchOrElse: {
        <Cases extends {
            [M in Flattened[number] as M["Type"][Tag]]+?: (value: M["Type"]) => any;
        } & {
            [K in Exclude<keyof Cases, Flattened[number]["Type"][Tag]>]: never;
        }, OrElse extends (value: Exclude<Members[number]["Type"], {
            readonly [K in Tag]: keyof Cases;
        }>) => any>(value: Members[number]["Type"], cases: Cases, orElse: OrElse): MatchOrElseResult<Cases, OrElse>;
        <Cases extends {
            [M in Flattened[number] as M["Type"][Tag]]+?: (value: M["Type"]) => any;
        } & {
            [K in Exclude<keyof Cases, Flattened[number]["Type"][Tag]>]: never;
        }, OrElse extends (value: Exclude<Members[number]["Type"], {
            readonly [K in Tag]: keyof Cases;
        }>) => any>(cases: Cases, orElse: OrElse): (value: Members[number]["Type"]) => MatchOrElseResult<Cases, OrElse>;
    };
};
/**
 * Type-level representation returned by {@link toTaggedUnion}.
 *
 * @stability stable
 * @category combinators
 * @since 4.0.0
 */
export type toTaggedUnion<Tag extends PropertyKey, Members extends ReadonlyArray<Constraint & {
    readonly Type: {
        readonly [K in Tag]: PropertyKey;
    };
}>> = Union<Members> & TaggedUnionUtils<Tag, Members>;
/**
 * Augments an existing {@link Union} of tagged structs with utility methods and an ordered tuple of discriminant
 * values.
 *
 * **Gotchas**
 *
 * Throws when multiple members use the same discriminant property key,
 * including members of nested unions. Numeric and string values such as `1`
 * and `"1"` count as duplicates.
 *
 * **Example** (Adding tagged-union utilities to an existing union)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const A = Schema.TaggedStruct("A", { value: Schema.Number })
 * const B = Schema.TaggedStruct("B", { name: Schema.String })
 *
 * const MyUnion = Schema.Union([A, B]).pipe(Schema.toTaggedUnion("_tag"))
 *
 * // Pattern-match on the union
 * const result = MyUnion.match({ _tag: "A", value: 1 }, {
 *   A: (a) => `number: ${a.value}`,
 *   B: (b) => `name: ${b.name}`
 * })
 * result // => "number: 1"
 * ```
 *
 * @see {@link TaggedUnion} for a shorthand that builds the union from scratch
 * @stability stable
 * @category combinators
 * @since 4.0.0
 */
export declare function toTaggedUnion<const Tag extends PropertyKey>(tag: Tag): <const Members extends ReadonlyArray<Constraint & {
    readonly Type: { readonly [K in Tag]: PropertyKey; };
}>>(self: Union<Members>) => toTaggedUnion<Tag, Members>;
/**
 * Type-level representation returned by {@link TaggedUnion}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface TaggedUnion<Cases extends Record<string, Constraint>> extends BottomLazy<SchemaAST.Union<SchemaAST.Objects>, TaggedUnion<Cases>> {
    readonly "Type": {
        [K in keyof Cases]: Cases[K]["Type"];
    }[keyof Cases];
    readonly "Encoded": {
        [K in keyof Cases]: Cases[K]["Encoded"];
    }[keyof Cases];
    readonly "DecodingServices": {
        [K in keyof Cases]: Cases[K]["DecodingServices"];
    }[keyof Cases];
    readonly "EncodingServices": {
        [K in keyof Cases]: Cases[K]["EncodingServices"];
    }[keyof Cases];
    readonly "~type.make.in": {
        [K in keyof Cases]: Cases[K]["~type.make"];
    }[keyof Cases];
    readonly "~type.make": {
        [K in keyof Cases]: Cases[K]["~type.make"];
    }[keyof Cases];
    readonly "Iso": {
        [K in keyof Cases]: Cases[K]["Type"];
    }[keyof Cases];
    readonly tag: "_tag";
    readonly cases: Cases;
    readonly isAnyOf: <const Keys>(keys: ReadonlyArray<Keys>) => (value: Cases[keyof Cases]["Type"]) => value is Extract<Cases[keyof Cases]["Type"], {
        _tag: Keys;
    }>;
    readonly guards: {
        [K in keyof Cases]: (u: unknown) => u is Cases[K]["Type"];
    };
    readonly match: {
        <Output>(cases: {
            [K in keyof Cases]: (value: Cases[K]["Type"]) => Output;
        }): (value: Cases[keyof Cases]["Type"]) => Output;
        <Output>(value: Cases[keyof Cases]["Type"], cases: {
            [K in keyof Cases]: (value: Cases[K]["Type"]) => Output;
        }): Output;
    };
    readonly matchOrElse: {
        <Output>(value: Cases[keyof Cases]["Type"], cases: {
            [K in keyof Cases]?: (value: Cases[K]["Type"]) => Output;
        }, orElse: (value: Cases[keyof Cases]["Type"]) => Output): Output;
        <Output>(cases: {
            [K in keyof Cases]?: (value: Cases[K]["Type"]) => Output;
        }, orElse: (value: Cases[keyof Cases]["Type"]) => Output): (value: Cases[keyof Cases]["Type"]) => Output;
    };
}
/**
 * Builds a discriminated union from a record of field sets, one per variant.
 * Each key becomes the `_tag` literal and the value is passed to {@link TaggedStruct}.
 * The result includes `tag`, `cases`, `guards`, `isAnyOf`, `match`, and `matchOrElse` utilities.
 *
 * **Example** (Pattern matching a discriminated union)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const Shape = Schema.TaggedUnion({
 *   Circle: { radius: Schema.Number },
 *   Rectangle: { width: Schema.Number, height: Schema.Number }
 * })
 *
 * // Pattern-match on a decoded value
 * const area = Shape.match({ _tag: "Circle", radius: 5 }, {
 *   Circle: (c) => Math.PI * c.radius ** 2,
 *   Rectangle: (r) => r.width * r.height
 * })
 * Math.round(area * 100) / 100 // => 78.54
 * ```
 *
 * @see {@link toTaggedUnion} to augment an existing union instead
 * @stability stable
 * @category constructors
 * @since 4.0.0
 */
export declare function TaggedUnion<const CasesByTag extends Record<string, Struct.Fields>>(casesByTag: CasesByTag): TaggedUnion<{
    readonly [K in keyof CasesByTag & string]: TaggedStruct<K, CasesByTag[K]>;
}>;
/**
 * Type-level representation returned by {@link Opaque}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface Opaque<Self, S extends Top, Brand> extends BottomLazyWithoutNew<S["ast"], S["Rebuild"], S["~type.parameters"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
    readonly "Type": Self;
    readonly "Encoded": S["Encoded"];
    readonly "DecodingServices": S["DecodingServices"];
    readonly "EncodingServices": S["EncodingServices"];
    readonly "~type.make.in": S["~type.make.in"];
    readonly "~type.make": S["~type.make"];
    readonly "Iso": S["Iso"];
    new (_: never): S["Type"] & Brand;
}
/**
 * Wraps a struct schema so that its decoded `Type` becomes a nominally distinct type `Self`.
 * Useful for creating opaque types that are structurally identical to a base struct
 * but type-incompatible with it.
 *
 * **Example** (Defining opaque structs)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * class Person extends Schema.Opaque<Person>()(
 *   Schema.Struct({
 *     name: Schema.String
 *   })
 * ) {}
 *
 * // Decoded value is Person, not { name: string }
 * const person = Schema.decodeUnknownSync(Person)({ name: "Alice" })
 * person.name // => "Alice"
 * ```
 *
 * @stability stable
 * @category constructors
 * @since 4.0.0
 */
export declare function Opaque<Self, Brand = {}>(): <S extends Top>(schema: S) => Opaque<Self, S, Brand> & Omit<S, keyof Top>;
/**
 * Type-level representation returned by {@link instanceOf}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface instanceOf<T, Iso = T> extends declare<T, Iso> {
    readonly "Rebuild": instanceOf<T, Iso>;
}
/**
 * Creates a schema that validates values using `instanceof`.
 * Decoding and encoding pass the value through unchanged.
 *
 * **Example** (Defining a schema for a built-in class)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const DateSchema = Schema.instanceOf(Date)
 *
 * const decoded = Schema.decodeUnknownSync(DateSchema)(new Date("2024-01-01"))
 * decoded.toISOString() // => "2024-01-01T00:00:00.000Z"
 * ```
 *
 * @stability stable
 * @category constructors
 * @since 3.10.0
 */
export declare function instanceOf<C extends abstract new (...args: any) => any, Iso = InstanceType<C>>(constructor: C, annotations?: Annotations.Declaration<InstanceType<C>> | undefined): instanceOf<InstanceType<C>, Iso>;
/**
 * Constructs an `SchemaAST.Link` that describes how a value of type `T` encodes to and decodes from a `To` schema.
 * Used when building low-level AST transformations that bridge two schema types.
 *
 * @stability stable
 * @category transforming
 * @since 4.0.0
 */
export declare function link<T>(): <To extends Constraint>(encodeTo: To, transformation: {
    readonly decode: SchemaGetter.Getter<T, NoInfer<To["Type"]>>;
    readonly encode: SchemaGetter.Getter<NoInfer<To["Type"]>, T>;
}) => SchemaAST.Link;
/**
 * Creates a custom validation filter from a predicate function.
 *
 * **Details**
 *
 * The predicate receives the decoded input value, the schema AST, and parse
 * options, and returns a `FilterOutput`. Non-success outputs are normalized into
 * schema issues. The `annotations` parameter annotates the filter itself; with
 * the default formatter, failures use `message` first, `expected` second, and
 * `<filter>` when neither is provided.
 *
 * When `abort` is `true`, parsing stops after this filter fails instead of
 * collecting later check failures.
 *
 * **Example** (Reporting failure at a nested path)
 *
 * ```ts import.meta.vitest
 * import { Result, Schema } from "effect"
 *
 * const schema = Schema.Struct({ password: Schema.String, confirmPassword: Schema.String }).check(
 *   Schema.makeFilter((o) =>
 *     o.password === o.confirmPassword
 *       ? undefined
 *       : { path: ["password"], issue: "password and confirmPassword must match" }
 *   )
 * )
 *
 * const result = Schema.decodeUnknownResult(schema)({ password: "123456", confirmPassword: "1234567" })
 * if (Result.isFailure(result) && result.failure.issue._tag === "Filter" && result.failure.issue.issue._tag === "Pointer") {
 *   result.failure.issue.issue.path // => ["password"]
 * }
 * ```
 *
 * **Example** (Reporting multiple failures at once)
 *
 * ```ts import.meta.vitest
 * import { Result, Schema } from "effect"
 *
 * const schema = Schema.Struct({ a: Schema.Finite, b: Schema.Finite, c: Schema.Finite }).check(
 *   Schema.makeFilter((o) => {
 *     const issues: Array<Schema.FilterIssue> = []
 *     if (o.a > 0) {
 *       if (o.b <= 0) issues.push({ path: ["b"], issue: "b must be greater than 0" })
 *       if (o.c <= 0) issues.push({ path: ["c"], issue: "c must be greater than 0" })
 *     }
 *     return issues
 *   })
 * )
 *
 * const result = Schema.decodeUnknownResult(schema)({ a: 1, b: 0, c: 0 })
 * if (Result.isFailure(result) && result.failure.issue._tag === "Filter" && result.failure.issue.issue._tag === "Composite") {
 *   result.failure.issue.issue.issues.map((issue) => issue._tag === "Pointer" ? issue.path : []) // => [["b"], ["c"]]
 * }
 * ```
 *
 * @stability stable
 * @category constructors
 * @since 4.0.0
 */
export declare const makeFilter: <T>(filter: (input: T, ast: SchemaAST.AST, options: SchemaAST.ParseOptions) => FilterOutput, annotations?: Annotations.Filter | undefined, abort?: boolean) => SchemaAST.Filter<T>;
/**
 * A single failure reported by a filter predicate. Used as the element type
 * of the array arm of {@link FilterOutput}, and also accepted on its own.
 *
 * **Details**
 *
 * - `string`: failure with that string as the message. Produces an
 *   {@link SchemaIssue.InvalidValue} with the string used as the issue's
 *   `message` annotation and honors `reportInput`.
 * - {@link SchemaIssue.Issue}: a fully-formed issue, returned as-is. It is not
 *   enriched when `reportInput` is enabled.
 * - `{ path, issue }`: failure attached to a nested path. `issue` is either
 *   a `string` (wrapped in an {@link SchemaIssue.InvalidValue} that honors
 *   `reportInput`) or a full {@link SchemaIssue.Issue} (returned unchanged);
 *   the result is wrapped in an {@link SchemaIssue.Pointer} at the given `path`.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export type FilterIssue = string | SchemaIssue.Issue | {
    readonly path: ReadonlyArray<PropertyKey>;
    readonly issue: string | SchemaIssue.Issue;
};
/**
 * The value a filter predicate (see {@link makeFilter}) may return.
 *
 * **Details**
 *
 * Each shape is normalized into an {@link SchemaIssue.Issue} (or `undefined` for
 * success) before being attached to the parse result:
 *
 * - `undefined`: success. The input satisfies the filter.
 * - `true`: success. Equivalent to `undefined`, useful when the predicate is
 *   a plain boolean expression.
 * - `false`: generic failure. Produces an {@link SchemaIssue.InvalidValue}
 *   with no custom message and honors `reportInput`.
 * - {@link FilterIssue}: a single failure. See {@link FilterIssue} for the
 *   shapes (`string`, {@link SchemaIssue.Issue}, or `{ path, issue }`).
 * - `ReadonlyArray<FilterIssue>`: several failures reported together. An
 *   empty array is treated as success; a single-element array is equivalent
 *   to returning that element directly; otherwise the entries are grouped
 *   into an {@link SchemaIssue.Composite}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export type FilterOutput = undefined | boolean | FilterIssue | ReadonlyArray<FilterIssue>;
/**
 * Groups multiple checks into a single {@link SchemaAST.FilterGroup}, applying
 * optional shared annotations to the group as a whole.
 *
 * @stability stable
 * @category constructors
 * @since 4.0.0
 */
export declare function makeFilterGroup<T>(checks: readonly [SchemaAST.Check<T>, ...Array<SchemaAST.Check<T>>], annotations?: Annotations.Filter | undefined): SchemaAST.FilterGroup<T>;
/**
 * Validates that a string has no leading or trailing whitespace.
 *
 * **Details**
 *
 * JSON Schema:
 *
 * This check corresponds to a `pattern` constraint in JSON Schema that
 * matches strings without leading or trailing whitespace.
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies a `patterns`
 * constraint to ensure generated strings match the trimmed pattern.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isTrimmed(annotations?: Annotations.Filter): SchemaAST.Filter<string>;
/**
 * Validates that a string matches the specified regular expression pattern.
 *
 * **Details**
 *
 * JSON Schema:
 *
 * Unless annotations override `toJsonSchema`, JSON Schema receives a `pattern`
 * only when the JavaScript RegExp uses the Unicode flag and its other flags are
 * `d`, `g`, or `y`. Sticky patterns are anchored at the start of the string.
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies a `patterns`
 * constraint to ensure generated strings match the specified RegExp pattern.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isPattern(regExp: globalThis.RegExp, annotations?: Annotations.Filter): SchemaAST.Filter<string>;
/**
 * Validates that a string represents a finite number.
 *
 * **Details**
 *
 * JSON Schema:
 *
 * This check corresponds to a `pattern` constraint in JSON Schema that matches
 * strings representing finite numbers.
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies a `patterns`
 * constraint to ensure generated strings match the number string pattern.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isStringFinite(annotations?: Annotations.Filter): SchemaAST.Filter<string>;
/**
 * Validates that a string is a signed base-10 integer literal for Effect's
 * BigInt string encoding.
 *
 * **Details**
 *
 * The check uses the pattern `^-?\d+$`. It does not accept leading `+`, decimal
 * points, exponent notation, separators, or non-decimal inputs such as
 * hexadecimal strings.
 *
 * JSON Schema:
 * This check corresponds to a `pattern` constraint with the same signed
 * base-10 integer pattern.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isStringBigInt(annotations?: Annotations.Filter): SchemaAST.Filter<string>;
/**
 * Validates that a string has the `Symbol(description)` format used by Effect's
 * symbol string encoding.
 *
 * **Details**
 *
 * The check uses the pattern `^Symbol\((.*)\)$`. It is not a general test for
 * whether a string can be passed to JavaScript's `Symbol()` function.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isStringSymbol(annotations?: Annotations.Filter): SchemaAST.Filter<string>;
/**
 * Validates that a string is a strict Universally Unique Identifier (UUID).
 *
 * **When to use**
 *
 * Use when you need UUID semantics, including version and RFC variant bits,
 * rather than only the dashed hexadecimal shape.
 *
 * **Details**
 *
 * Without a version argument, this accepts UUID versions 1 through 8, the nil
 * UUID (`00000000-0000-0000-0000-000000000000`), and the max UUID
 * (`ffffffff-ffff-ffff-ffff-ffffffffffff`). With a version argument, this
 * accepts only UUIDs with that version and RFC variant bits; nil and max UUIDs
 * are not versioned UUIDs and do not match version-specific checks.
 *
 * JSON Schema:
 *
 * This check corresponds to a `pattern` constraint in JSON Schema that matches
 * UUID format, and includes a `format: "uuid"` annotation.
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies a `patterns`
 * constraint to ensure generated strings match the UUID pattern.
 *
 * @see {@link isGUID} for shape-only GUID validation.
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isUUID(version?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8, annotations?: Annotations.Filter): SchemaAST.Filter<string>;
/**
 * Validates that a string has the GUID / UUID textual shape.
 *
 * **When to use**
 *
 * Use when you need to accept dashed hexadecimal identifiers without enforcing
 * UUID version or variant bits.
 *
 * **Details**
 *
 * This check accepts strings in the `8-4-4-4-12` hexadecimal form. JSON Schema
 * output includes the corresponding `pattern` constraint and intentionally does
 * not include `format: "uuid"` because GUID validation is looser than UUID
 * validation.
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies a `patterns`
 * constraint to ensure generated strings match the GUID pattern.
 *
 * @see {@link isUUID} for strict UUID validation.
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isGUID(annotations?: Annotations.Filter): SchemaAST.Filter<string>;
/**
 * Validates that a string is a valid ULID (Universally Unique Lexicographically
 * Sortable Identifier).
 *
 * **Details**
 *
 * JSON Schema:
 *
 * This check corresponds to a `pattern` constraint in JSON Schema that matches
 * the ULID format.
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies a `patterns`
 * constraint to ensure generated strings match the ULID pattern.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isULID(annotations?: Annotations.Filter): SchemaAST.Filter<string>;
/**
 * Validates that a string is valid Base64 encoded data.
 *
 * **Details**
 *
 * JSON Schema:
 *
 * This check corresponds to a `pattern` constraint in JSON Schema that matches
 * Base64 format.
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies a `patterns`
 * constraint to ensure generated strings match the Base64 pattern.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isBase64(annotations?: Annotations.Filter): SchemaAST.Filter<string>;
/**
 * Validates that a string is valid Base64URL encoded data (Base64 with URL-safe
 * characters).
 *
 * **Details**
 *
 * JSON Schema:
 *
 * This check corresponds to a `pattern` constraint in JSON Schema that matches
 * Base64URL format.
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies a `patterns`
 * constraint to ensure generated strings match the Base64URL pattern.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isBase64Url(annotations?: Annotations.Filter): SchemaAST.Filter<string>;
/**
 * Validates at runtime that a string starts with the specified literal prefix.
 *
 * **Details**
 *
 * RegExp metacharacters in the prefix are escaped in JSON Schema and arbitrary
 * metadata. If the prefix ends with a high surrogate, the JSON Schema pattern
 * omits that code unit so Unicode matching cannot reject a valid string.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isStartingWith(startsWith: string, annotations?: Annotations.Filter): SchemaAST.Filter<string>;
/**
 * Validates at runtime that a string ends with the specified literal suffix.
 *
 * **Details**
 *
 * RegExp metacharacters in the suffix are escaped in JSON Schema and arbitrary
 * metadata. If the suffix begins with a low surrogate, the JSON Schema pattern
 * omits that code unit so Unicode matching cannot reject a valid string.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isEndingWith(endsWith: string, annotations?: Annotations.Filter): SchemaAST.Filter<string>;
/**
 * Validates at runtime that a string contains the specified literal substring.
 *
 * **Details**
 *
 * RegExp metacharacters in the substring are escaped in JSON Schema and
 * arbitrary metadata. A leading low surrogate or trailing high surrogate is
 * omitted from the JSON Schema pattern so Unicode matching cannot reject a
 * valid string.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isIncluding(includes: string, annotations?: Annotations.Filter): SchemaAST.Filter<string>;
/**
 * Validates that a string is unchanged by JavaScript's `toUpperCase()`.
 *
 * **Details**
 *
 * This accepts empty strings and characters that do not have lowercase forms,
 * such as digits, punctuation, and whitespace. It rejects strings that would
 * change when uppercased.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isUppercased(annotations?: Annotations.Filter): SchemaAST.Filter<string>;
/**
 * Validates that a string is unchanged by JavaScript's `toLowerCase()`.
 *
 * **Details**
 *
 * This accepts empty strings and characters that do not have uppercase forms,
 * such as digits, punctuation, and whitespace. It rejects strings that would
 * change when lowercased.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isLowercased(annotations?: Annotations.Filter): SchemaAST.Filter<string>;
/**
 * Validates that the first character of a string is unchanged by
 * `toUpperCase()`.
 *
 * **Details**
 *
 * Empty strings pass. Strings whose first character has no lowercase form, such
 * as a digit, punctuation mark, or whitespace, also pass.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isCapitalized(annotations?: Annotations.Filter): SchemaAST.Filter<string>;
/**
 * Validates that the first character of a string is unchanged by
 * `toLowerCase()`.
 *
 * **Details**
 *
 * Empty strings pass. Strings whose first character has no uppercase form, such
 * as a digit, punctuation mark, or whitespace, also pass.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isUncapitalized(annotations?: Annotations.Filter): SchemaAST.Filter<string>;
/**
 * Type-level representation of {@link Finite}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface Finite extends Number {
    readonly "Rebuild": Finite;
}
/**
 * Schema for finite numbers, rejecting `NaN`, `Infinity`, and `-Infinity`.
 *
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare const Finite: Finite;
/**
 * Validates that a number is finite (not `Infinity`, `-Infinity`, or `NaN`).
 *
 * **Details**
 *
 * JSON Schema:
 *
 * This check does not have a direct JSON Schema equivalent, but ensures the
 * number is valid and finite.
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies a finite-number constraint.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare const isFinite: (annotations?: Annotations.Filter) => SchemaAST.Filter<number>;
/**
 * Creates a greater-than (`>`) check for any ordered type from an
 * `Order.Order` instance.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function makeIsGreaterThan<T>(options: {
    readonly order: Order.Order<T>;
    readonly annotate?: ((exclusiveMinimum: T) => Annotations.Filter) | undefined;
    readonly formatter?: Formatter<T> | undefined;
}): (exclusiveMinimum: T, annotations?: Annotations.Filter) => SchemaAST.Filter<T>;
/**
 * Creates a greater-than-or-equal-to (`>=`) check for any ordered type from an
 * `Order.Order` instance.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function makeIsGreaterThanOrEqualTo<T>(options: {
    readonly order: Order.Order<T>;
    readonly annotate?: ((exclusiveMinimum: T) => Annotations.Filter) | undefined;
    readonly formatter?: Formatter<T> | undefined;
}): (minimum: T, annotations?: Annotations.Filter) => SchemaAST.Filter<T>;
/**
 * Creates a less-than (`<`) check for any ordered type from an `Order.Order`
 * instance.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function makeIsLessThan<T>(options: {
    readonly order: Order.Order<T>;
    readonly annotate?: ((exclusiveMaximum: T) => Annotations.Filter) | undefined;
    readonly formatter?: Formatter<T> | undefined;
}): (exclusiveMaximum: T, annotations?: Annotations.Filter) => SchemaAST.Filter<T>;
/**
 * Creates a less-than-or-equal-to (`<=`) check for any ordered type from an
 * `Order.Order` instance.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function makeIsLessThanOrEqualTo<T>(options: {
    readonly order: Order.Order<T>;
    readonly annotate?: ((exclusiveMaximum: T) => Annotations.Filter) | undefined;
    readonly formatter?: Formatter<T> | undefined;
}): (maximum: T, annotations?: Annotations.Filter) => SchemaAST.Filter<T>;
/**
 * Creates an inclusive or exclusive range check for any ordered type from an
 * `Order.Order` instance.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function makeIsBetween<T>(deriveOptions: {
    readonly order: Order.Order<T>;
    readonly annotate?: ((options: {
        readonly minimum: T;
        readonly maximum: T;
        readonly exclusiveMinimum?: boolean | undefined;
        readonly exclusiveMaximum?: boolean | undefined;
    }) => Annotations.Filter) | undefined;
    readonly formatter?: Formatter<T> | undefined;
}): (options: {
    readonly minimum: T;
    readonly maximum: T;
    readonly exclusiveMinimum?: boolean | undefined;
    readonly exclusiveMaximum?: boolean | undefined;
}, annotations?: Annotations.Filter) => SchemaAST.Filter<T>;
/**
 * Creates a divisibility check for any numeric type from a remainder function
 * and a zero value.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function makeIsMultipleOf<T>(options: {
    readonly remainder: (input: T, divisor: T) => T;
    readonly zero: NoInfer<T>;
    readonly annotate?: ((divisor: T) => Annotations.Filter) | undefined;
    readonly formatter?: Formatter<T> | undefined;
}): (divisor: T, annotations?: Annotations.Filter) => SchemaAST.Filter<T>;
/**
 * Validates that a number is greater than the specified value (exclusive).
 *
 * **Details**
 *
 * JSON Schema:
 *
 * This check corresponds to the `exclusiveMinimum` constraint in JSON Schema.
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies an
 * `exclusiveMinimum` constraint to ensure generated numbers are greater than
 * the specified value.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare const isGreaterThan: (exclusiveMinimum: number, annotations?: Annotations.Filter) => SchemaAST.Filter<number>;
/**
 * Validates that a number is greater than or equal to the specified value
 * (inclusive).
 *
 * **Details**
 *
 * JSON Schema:
 *
 * This check corresponds to the `minimum` constraint in JSON Schema.
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies a `minimum` constraint
 * to ensure generated numbers are greater than or equal to the specified value.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare const isGreaterThanOrEqualTo: (minimum: number, annotations?: Annotations.Filter) => SchemaAST.Filter<number>;
/**
 * Validates that a number is less than the specified value (exclusive).
 *
 * **Details**
 *
 * JSON Schema:
 *
 * This check corresponds to the `exclusiveMaximum` constraint in JSON Schema.
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies an
 * `exclusiveMaximum` constraint to ensure generated numbers are less than the
 * specified value.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare const isLessThan: (exclusiveMaximum: number, annotations?: Annotations.Filter) => SchemaAST.Filter<number>;
/**
 * Validates that a number is less than or equal to the specified value
 * (inclusive).
 *
 * **Details**
 *
 * JSON Schema:
 *
 * This check corresponds to the `maximum` constraint in JSON Schema.
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies a `maximum` constraint
 * to ensure generated numbers are less than or equal to the specified value.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare const isLessThanOrEqualTo: (maximum: number, annotations?: Annotations.Filter) => SchemaAST.Filter<number>;
/**
 * Validates that a number is within a specified range. The range boundaries can
 * be inclusive or exclusive based on the provided options.
 *
 * **Details**
 *
 * JSON Schema:
 *
 * This check corresponds to `minimum`/`maximum` or `exclusiveMinimum`/`exclusiveMaximum`
 * constraints in JSON Schema, depending on the options provided.
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies `minimum` and
 * `maximum` constraints with optional `exclusiveMinimum` and
 * `exclusiveMaximum` flags to ensure generated numbers fall within the
 * specified range.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare const isBetween: (options: {
    readonly minimum: number;
    readonly maximum: number;
    readonly exclusiveMinimum?: boolean | undefined;
    readonly exclusiveMaximum?: boolean | undefined;
}, annotations?: Annotations.Filter) => SchemaAST.Filter<number>;
/**
 * Validates that a number is a multiple of the specified divisor.
 *
 * **Details**
 *
 * JSON Schema:
 *
 * This check corresponds to the `multipleOf` constraint in JSON Schema.
 * Negative divisors are normalized to their absolute value because JSON
 * Schema requires `multipleOf` to be positive.
 *
 * **Gotchas**
 *
 * Throws a `RangeError` when `divisor` is zero or is not finite.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isMultipleOf(divisor: number, annotations?: Annotations.Filter): SchemaAST.Filter<number>;
/**
 * Validates that a number is a safe integer (within the safe integer range
 * that can be exactly represented in JavaScript).
 *
 * **Details**
 *
 * JSON Schema:
 *
 * This check corresponds to `type: "integer"` with `minimum: Number.MIN_SAFE_INTEGER`
 * and `maximum: Number.MAX_SAFE_INTEGER` in JSON Schema.
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies an integer constraint.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isInt(annotations?: Annotations.Filter): SchemaAST.Filter<number>;
/**
 * Type-level representation of {@link Int}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface Int extends Number {
    readonly "Rebuild": Int;
}
/**
 * Schema for integers, rejecting `NaN`, `Infinity`, and `-Infinity`.
 *
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare const Int: Int;
/**
 * Type-level representation of {@link Natural}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface Natural extends Int {
    readonly "Rebuild": Natural;
}
/**
 * Schema for non-negative safe integers, including zero.
 *
 * **When to use**
 *
 * Use when you need a count, index, or size that cannot be negative.
 *
 * @see {@link Int} for safe integers that may be negative
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare const Natural: Natural;
/**
 * Validates that a number is a 32-bit signed integer (range: -2,147,483,648 to
 * 2,147,483,647).
 *
 * **Details**
 *
 * JSON Schema:
 *
 * This check corresponds to the `format: "int32"` constraint in OpenAPI 3.1,
 * or `minimum`/`maximum` constraints in other JSON Schema targets.
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies integer and range
 * constraints to ensure generated numbers are 32-bit signed integers.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isInt32(annotations?: Annotations.Filter): SchemaAST.FilterGroup<number>;
/**
 * Validates that a number is a 32-bit unsigned integer (range: 0 to
 * 4,294,967,295).
 *
 * **Details**
 *
 * JSON Schema:
 *
 * This check corresponds to the `format: "uint32"` constraint in OpenAPI 3.1,
 * or `minimum`/`maximum` constraints in other JSON Schema targets.
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies integer and range
 * constraints to ensure generated numbers are 32-bit unsigned integers.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isUint32(annotations?: Annotations.Filter): SchemaAST.FilterGroup<number>;
/**
 * Validates that a Date is greater than the specified value (exclusive).
 *
 * **Details**
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies an exclusive lower bound.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare const isGreaterThanDate: (exclusiveMinimum: globalThis.Date, annotations?: Annotations.Filter) => SchemaAST.Filter<globalThis.Date>;
/**
 * Validates that a Date is greater than or equal to the specified date
 * (inclusive).
 *
 * **Details**
 *
 * JSON Schema:
 *
 * This check does not have a direct JSON Schema equivalent, as JSON Schema
 * validates date strings, not Date objects.
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies an inclusive lower bound.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare const isGreaterThanOrEqualToDate: (minimum: globalThis.Date, annotations?: Annotations.Filter) => SchemaAST.Filter<globalThis.Date>;
/**
 * Validates that a Date is less than the specified value (exclusive).
 *
 * **Details**
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies an exclusive upper bound.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare const isLessThanDate: (exclusiveMaximum: globalThis.Date, annotations?: Annotations.Filter) => SchemaAST.Filter<globalThis.Date>;
/**
 * Validates that a Date is less than or equal to the specified date
 * (inclusive).
 *
 * **Details**
 *
 * JSON Schema:
 *
 * This check does not have a direct JSON Schema equivalent, as JSON Schema
 * validates date strings, not Date objects.
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies an inclusive upper bound.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare const isLessThanOrEqualToDate: (maximum: globalThis.Date, annotations?: Annotations.Filter) => SchemaAST.Filter<globalThis.Date>;
/**
 * Validates that a Date is within a specified range. The range boundaries can
 * be inclusive or exclusive based on the provided options.
 *
 * **Details**
 *
 * JSON Schema:
 *
 * This check does not have a direct JSON Schema equivalent, as JSON Schema
 * validates date strings, not Date objects.
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies the specified lower and upper bounds.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare const isBetweenDate: (options: {
    readonly minimum: globalThis.Date;
    readonly maximum: globalThis.Date;
    readonly exclusiveMinimum?: boolean | undefined;
    readonly exclusiveMaximum?: boolean | undefined;
}, annotations?: Annotations.Filter) => SchemaAST.Filter<globalThis.Date>;
/**
 * Validates that a BigInt is greater than the specified value (exclusive).
 *
 * **Details**
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies an exclusive lower bound.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare const isGreaterThanBigInt: (exclusiveMinimum: bigint, annotations?: Annotations.Filter) => SchemaAST.Filter<bigint>;
/**
 * Validates that a BigInt is greater than or equal to the specified value
 * (inclusive).
 *
 * **Details**
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies an inclusive lower bound.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare const isGreaterThanOrEqualToBigInt: (minimum: bigint, annotations?: Annotations.Filter) => SchemaAST.Filter<bigint>;
/**
 * Validates that a BigInt is less than the specified value (exclusive).
 *
 * **Details**
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies an exclusive upper bound.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare const isLessThanBigInt: (exclusiveMaximum: bigint, annotations?: Annotations.Filter) => SchemaAST.Filter<bigint>;
/**
 * Validates that a BigInt is less than or equal to the specified value
 * (inclusive).
 *
 * **Details**
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies an inclusive upper bound.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare const isLessThanOrEqualToBigInt: (maximum: bigint, annotations?: Annotations.Filter) => SchemaAST.Filter<bigint>;
/**
 * Validates that a BigInt is within a specified range. The range boundaries can
 * be inclusive or exclusive based on the provided options.
 *
 * **Details**
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies the specified lower and upper bounds.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare const isBetweenBigInt: (options: {
    readonly minimum: bigint;
    readonly maximum: bigint;
    readonly exclusiveMinimum?: boolean | undefined;
    readonly exclusiveMaximum?: boolean | undefined;
}, annotations?: Annotations.Filter) => SchemaAST.Filter<bigint>;
/**
 * Validates that a value has at least the specified length. Works with strings
 * and arrays.
 *
 * **Details**
 *
 * JSON Schema:
 *
 * The bound must be finite; it is rounded down and clamped to zero. For arrays,
 * this check corresponds to `minItems`. JavaScript counts UTF-16 code units
 * while JSON Schema counts Unicode code points, so strings use
 * `minLength: Math.ceil(minLength / 2)`, the tightest lower bound that cannot
 * reject a string accepted by this check.
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies a `minLength`
 * constraint to ensure generated strings or arrays have at least the required
 * length.
 *
 * **Example** (Checking minimum length)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const NonEmptyStringSchema = Schema.String.check(Schema.isMinLength(1))
 * const NonEmptyArraySchema = Schema.Array(Schema.Number).check(Schema.isMinLength(1))
 * Schema.is(NonEmptyStringSchema)("a") // => true
 * Schema.is(NonEmptyArraySchema)([1]) // => true
 * ```
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isMinLength(minLength: number, annotations?: Annotations.Filter): SchemaAST.Filter<{
    readonly length: number;
}>;
/**
 * Validates that a value has at least one element. Works with strings and arrays.
 * This is equivalent to `isMinLength(1)`.
 *
 * **Details**
 *
 * JSON Schema:
 *
 * This check corresponds to the `minLength: 1` constraint for strings or the
 * `minItems: 1` constraint for arrays in JSON Schema.
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies a `minLength: 1`
 * constraint to ensure generated strings or arrays are non-empty.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isNonEmpty(annotations?: Annotations.Filter): SchemaAST.Filter<{
    readonly length: number;
}>;
/**
 * Validates that a value has at most the specified length. Works with strings
 * and arrays.
 *
 * **Details**
 *
 * JSON Schema:
 *
 * The bound must be finite; it is rounded down and clamped to zero. This check
 * corresponds to `maxItems` for arrays. Strings use the same bound for
 * `maxLength`, which cannot reject a string accepted by this check because a
 * string has no more code points than UTF-16 code units.
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies a `maxLength`
 * constraint to ensure generated strings or arrays have at most the required
 * length.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isMaxLength(maxLength: number, annotations?: Annotations.Filter): SchemaAST.Filter<{
    readonly length: number;
}>;
/**
 * Validates that a value's length is within the specified range. Works with
 * strings and arrays.
 *
 * **Details**
 *
 * JSON Schema:
 *
 * Both bounds must be finite; they are rounded down and clamped to zero. Arrays
 * use the same bounds for `minItems` and `maxItems`. JavaScript counts UTF-16
 * code units while JSON Schema counts Unicode code points, so strings use
 * `Math.ceil(minimum / 2)` for `minLength` and `maximum` for `maxLength`. These
 * are the tightest bounds that cannot reject a string accepted by this check.
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies `minLength` and
 * `maxLength` constraints to ensure generated strings or arrays have a length
 * within the specified range.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isBetweenLength(minimum: number, maximum: number, annotations?: Annotations.Filter): SchemaAST.Filter<{
    readonly length: number;
}>;
/**
 * Validates that a string contains at least the specified number of Unicode code points.
 *
 * **Details**
 *
 * The bound must be finite; it is rounded down and clamped to zero. This check
 * corresponds to `minLength` in JSON Schema and guides arbitrary generation by
 * code point count.
 *
 * **Gotchas**
 *
 * Code points are not grapheme clusters: combining marks and joined emoji can
 * contribute multiple code points to one visible character. Unpaired UTF-16
 * surrogates count as one code point each. This check does not normalize strings.
 *
 * @see {@link isMinLength} for counting UTF-16 code units
 * @see {@link isMaxCodePoints}
 * @see {@link isBetweenCodePoints}
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isMinCodePoints(minCodePoints: number, annotations?: Annotations.Filter): SchemaAST.Filter<string>;
/**
 * Validates that a string contains at most the specified number of Unicode code points.
 *
 * **Details**
 *
 * The bound must be finite; it is rounded down and clamped to zero. This check
 * corresponds to `maxLength` in JSON Schema and guides arbitrary generation by
 * code point count.
 *
 * **Gotchas**
 *
 * Code points are not grapheme clusters: combining marks and joined emoji can
 * contribute multiple code points to one visible character. Unpaired UTF-16
 * surrogates count as one code point each. This check does not normalize strings.
 *
 * @see {@link isMaxLength} for counting UTF-16 code units
 * @see {@link isMinCodePoints}
 * @see {@link isBetweenCodePoints}
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isMaxCodePoints(maxCodePoints: number, annotations?: Annotations.Filter): SchemaAST.Filter<string>;
/**
 * Validates that a string's Unicode code point count is within the specified inclusive range.
 *
 * **Details**
 *
 * Bounds must be finite; they are rounded down and clamped to zero. Equal bounds
 * require an exact count. This check corresponds to `minLength` and `maxLength`
 * in JSON Schema and guides arbitrary generation by code point count.
 *
 * **Gotchas**
 *
 * Code points are not grapheme clusters: combining marks and joined emoji can
 * contribute multiple code points to one visible character. Unpaired UTF-16
 * surrogates count as one code point each. This check does not normalize strings.
 *
 * @see {@link isBetweenLength} for counting UTF-16 code units
 * @see {@link isMinCodePoints}
 * @see {@link isMaxCodePoints}
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isBetweenCodePoints(minimum: number, maximum: number, annotations?: Annotations.Filter): SchemaAST.Filter<string>;
/**
 * Validates that a value has at least the specified size. Works with values
 * that have a `size` property, such as `Set` or `Map`.
 *
 * **Details**
 *
 * The bound must be finite; it is rounded down and clamped to zero.
 *
 * JSON Schema:
 *
 * This check does not have a direct JSON Schema equivalent, as it applies to
 * values with a `size` property rather than standard JSON Schema types.
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies a node-local `minSize` constraint.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isMinSize(minSize: number, annotations?: Annotations.Filter): SchemaAST.Filter<{
    readonly size: number;
}>;
/**
 * Validates that a value has at most the specified size. Works with values
 * that have a `size` property, such as `Set` or `Map`.
 *
 * **Details**
 *
 * The bound must be finite; it is rounded down and clamped to zero.
 *
 * JSON Schema:
 *
 * This check does not have a direct JSON Schema equivalent, as it applies to
 * values with a `size` property rather than standard JSON Schema types.
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies a node-local `maxSize` constraint.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isMaxSize(maxSize: number, annotations?: Annotations.Filter): SchemaAST.Filter<{
    readonly size: number;
}>;
/**
 * Validates that a value's size is within the specified range. Works with
 * values that have a `size` property, such as `Set` or `Map`.
 *
 * **Details**
 *
 * Both bounds must be finite; they are rounded down and clamped to zero.
 *
 * JSON Schema:
 *
 * This check does not have a direct JSON Schema equivalent, as it applies to
 * values with a `size` property rather than standard JSON Schema types.
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies node-local `minSize` and `maxSize` constraints.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isBetweenSize(minimum: number, maximum: number, annotations?: Annotations.Filter): SchemaAST.Filter<{
    readonly size: number;
}>;
/**
 * Validates that an object contains at least the specified number of
 * properties. This includes both string and symbol keys when counting
 * properties.
 *
 * **Details**
 *
 * The bound must be finite; it is rounded down and clamped to zero.
 *
 * JSON Schema:
 *
 * This check corresponds to `minProperties` in JSON Schema. Effect applies the
 * check to the decoded object, while JSON Schema applies it to the original
 * input. Defaults and property transformations can therefore produce different
 * results.
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies a node-local `minProperties` constraint.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isMinProperties(minProperties: number, annotations?: Annotations.Filter): SchemaAST.Filter<object>;
/**
 * Validates that an object contains at most the specified number of properties.
 * This includes both string and symbol keys when counting properties.
 *
 * **Details**
 *
 * The bound must be finite; it is rounded down and clamped to zero.
 *
 * JSON Schema:
 *
 * This check corresponds to `maxProperties` in JSON Schema. Effect applies the
 * check to the decoded object, while JSON Schema applies it to the original
 * input. Excess-property handling and property transformations can therefore
 * produce different results.
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies a node-local `maxProperties` constraint.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isMaxProperties(maxProperties: number, annotations?: Annotations.Filter): SchemaAST.Filter<object>;
/**
 * Validates that an object contains between `minimum` and `maximum` properties (inclusive).
 * This includes both string and symbol keys when counting properties.
 *
 * **Details**
 *
 * Both bounds must be finite; they are rounded down and clamped to zero.
 *
 * JSON Schema:
 *
 * This check corresponds to `minProperties` and `maxProperties` in JSON
 * Schema. Effect applies the check to the decoded object, while JSON Schema
 * applies it to the original input. Defaults, excess-property handling, and
 * property transformations can therefore produce different results.
 *
 * Arbitrary:
 *
 * During arbitrary generation, this applies node-local `minProperties` and `maxProperties` constraints.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isBetweenProperties(minimum: number, maximum: number, annotations?: Annotations.Filter): SchemaAST.Filter<object>;
/**
 * Validates that every own property key of an object satisfies the encoded side
 * of the provided key schema.
 *
 * **Details**
 *
 * This check uses `Reflect.ownKeys`, so symbol keys are validated in addition to
 * string property names.
 *
 * JSON Schema:
 * This check corresponds to `propertyNames` in JSON Schema. Effect checks the
 * decoded object's keys, including symbols, while JSON Schema checks the string
 * names in the original input. Property transformations and excess-property
 * handling can therefore produce different results.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isPropertyNames(keySchema: Constraint, annotations?: Annotations.Filter): SchemaAST.Filter<object>;
/**
 * Validates that all items in an array are unique according to Effect equality.
 *
 * **Details**
 *
 * JSON Schema:
 * This check corresponds to the `uniqueItems: true` constraint in JSON Schema.
 *
 * Arbitrary:
 * During arbitrary generation, this applies a node-local identity selector
 * for constructive uniqueness using Effect equality.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isUnique<T>(annotations?: Annotations.Filter): SchemaAST.Filter<readonly T[]>;
/**
 * Validates that all first elements in an array of key-value tuples are unique according to Effect equality.
 *
 * **Details**
 *
 * Arbitrary:
 * During arbitrary generation, this projects each entry to its key for constructive uniqueness.
 *
 * JSON Schema:
 * JSON Schema has no equivalent constraint, so this check is omitted from generated documents.
 *
 * @see {@link isUnique} for validating uniqueness of complete array elements
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare function isUniqueKey<Key, Value>(annotations?: Annotations.Filter): SchemaAST.Filter<readonly (readonly [Key, Value])[]>;
/**
 * Type-level representation of {@link NonEmptyString}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface NonEmptyString extends String {
    readonly "Rebuild": NonEmptyString;
}
/**
 * Schema for non-empty strings. Validates that a string has at least one
 * character.
 *
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare const NonEmptyString: NonEmptyString;
/**
 * Type-level representation of {@link Char}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface Char extends String {
    readonly "Rebuild": Char;
}
/**
 * Schema for strings whose JavaScript `length` is exactly `1`.
 *
 * **When to use**
 *
 * Use to validate string values that must have `length === 1`.
 *
 * **Gotchas**
 *
 * This schema uses JavaScript `String.length`, so visible characters made from
 * multiple UTF-16 code units do not satisfy `length === 1`.
 *
 * @see {@link String} for unconstrained string values
 * @see {@link NonEmptyString} for strings with length greater than zero
 * @see {@link isBetweenLength} for the underlying length check
 *
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare const Char: Char;
/**
 * Type-level representation of {@link ErrorInstance}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface ErrorInstance extends instanceOf<globalThis.Error> {
    readonly "Rebuild": ErrorInstance;
}
/**
 * Options for {@link ErrorInstance} and {@link Defect}.
 *
 * @stability stable
 * @category options
 * @since 4.0.0
 */
export interface ErrorOptions {
    /**
     * Includes string stack traces in encoded `Error` values when set to `true`.
     *
     * @default false
     */
    readonly includeStack?: boolean | undefined;
    /**
     * Excludes `Error.cause` values from encoded `Error` values when set to
     * `true`.
     *
     * @default false
     */
    readonly excludeCause?: boolean | undefined;
}
/**
 * Schema for JavaScript `Error` objects.
 *
 * **Details**
 *
 * Default JSON serializer:
 *
 * Encodes an `Error` as an object with `message`, optional `name`, and optional
 * `cause` properties, and decodes that object back into an `Error`. Stack
 * traces are omitted by default for security. Pass `{ includeStack: true }` to
 * include stack traces, or `{ excludeCause: true }` to omit causes.
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare function ErrorInstance(options?: ErrorOptions): ErrorInstance;
/**
 * Type-level representation of {@link Defect}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface Defect extends decodeTo<Unknown, typeof Json> {
    readonly "Rebuild": Defect;
}
/**
 * Schema for unexpected defect values represented as `unknown` with a JSON
 * encoded form.
 *
 * **When to use**
 *
 * Use when you need a schema for `Cause` defects or other unexpected failures
 * whose runtime value may be any value.
 *
 * **Details**
 *
 * The encoded side is {@link Json}. During decoding, JSON objects with a string
 * `message` property are decoded into JavaScript `Error` values, preserving a
 * non-default `name` and any string `stack`. Other JSON values decode
 * unchanged.
 *
 * During encoding, JavaScript `Error` values encode to JSON objects with
 * `name`, `message`, and optional `cause` properties. Pass
 * `{ includeStack: true }` to include string stack traces in encoded `Error`
 * defects, or `{ excludeCause: true }` to omit causes. Other values are
 * serialized through Effect's JSON formatter and then parsed back into JSON
 * when possible.
 *
 * **Gotchas**
 *
 * This schema is for carrying defects across JSON boundaries, not for
 * preserving every JavaScript value exactly. Some values cannot round-trip
 * unchanged:
 *
 * - A non-`Error` object such as `{ message: "boom" }` encodes as an
 *   error-shaped JSON object and decodes back as an `Error`.
 * - JSON serialization normalizes unsupported values. For example,
 *   `undefined` array elements encode as `null`, unsupported object properties
 *   are omitted, and circular references are dropped.
 * - Values that cannot be represented as JSON fall back to Effect's formatted
 *   string representation.
 *
 * @see {@link ErrorInstance} for a schema that only accepts JavaScript `Error` values.
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare function Defect(options?: ErrorOptions): Defect;
/**
 * Type-level representation returned by {@link ReadonlyMap}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface $ReadonlyMap<Key extends Constraint, Value extends Constraint> extends declareConstructor<globalThis.ReadonlyMap<Key["Type"], Value["Type"]>, globalThis.ReadonlyMap<Key["Encoded"], Value["Encoded"]>, readonly [Key, Value], ReadonlyMapIso<Key, Value>> {
    readonly "Rebuild": $ReadonlyMap<Key, Value>;
    readonly key: Key;
    readonly value: Value;
}
/**
 * Iso representation used for `ReadonlyMap` schemas: an array of readonly
 * `[key, value]` tuples using each entry schema's `Iso` type.
 *
 * @stability stable
 * @category utility types
 * @since 4.0.0
 */
export type ReadonlyMapIso<Key extends Constraint, Value extends Constraint> = ReadonlyArray<readonly [Key["Iso"], Value["Iso"]]>;
/**
 * Schema for readonly maps whose keys and values conform to the provided
 * schemas.
 *
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare function ReadonlyMap<Key extends Constraint, Value extends Constraint>(key: Key, value: Value): $ReadonlyMap<Key, Value>;
/**
 * Type-level representation returned by {@link ReadonlySet}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface $ReadonlySet<Value extends Constraint> extends declareConstructor<globalThis.ReadonlySet<Value["Type"]>, globalThis.ReadonlySet<Value["Encoded"]>, readonly [Value], ReadonlySetIso<Value>> {
    readonly "Rebuild": $ReadonlySet<Value>;
    readonly value: Value;
}
/**
 * Iso representation used for `ReadonlySet` schemas: an array of element values
 * using the element schema's `Iso` type.
 *
 * @stability stable
 * @category utility types
 * @since 4.0.0
 */
export type ReadonlySetIso<Value extends Constraint> = ReadonlyArray<Value["Iso"]>;
/**
 * Schema for readonly sets whose values conform to the provided element schema.
 *
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare function ReadonlySet<Value extends Constraint>(value: Value): $ReadonlySet<Value>;
/**
 * Type-level representation of {@link RegExp}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface RegExp extends instanceOf<globalThis.RegExp> {
    readonly "Rebuild": RegExp;
}
/**
 * Schema for JavaScript `RegExp` objects.
 *
 * **Details**
 *
 * The default JSON serializer encodes a `RegExp` as `{ source, flags }`.
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare const RegExp: RegExp;
/**
 * Type-level representation of {@link URL}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface URL extends instanceOf<globalThis.URL> {
    readonly "Rebuild": URL;
}
/**
 * Schema for JavaScript `URL` objects.
 *
 * **Details**
 *
 * Default JSON serializer:
 *
 * - encodes `URL` as a `string`
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare const URL: URL;
/**
 * Type-level representation of {@link URLFromString}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface URLFromString extends decodeTo<URL, String> {
    readonly "Rebuild": URLFromString;
}
/**
 * Schema that decodes a `string` into a `URL`.
 *
 * **Details**
 *
 * Decoding:
 * - A **valid** URL `string` is decoded as a `URL`
 *
 * Encoding:
 * - A `URL` is encoded as a `string`
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare const URLFromString: URLFromString;
/**
 * Type-level representation of {@link Date}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface Date extends declare<globalThis.Date> {
    readonly "Rebuild": Date;
}
/**
 * Schema for valid JavaScript `Date` objects.
 *
 * **When to use**
 *
 * Use to validate in-memory values that must already be valid JavaScript date
 * objects.
 *
 * **Details**
 *
 * This schema accepts `Date` instances whose timestamp is not `NaN`. The
 * default JSON serializer encodes dates as ISO 8601 strings.
 *
 * **Example** (Defining a Date schema)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const date = Schema.decodeUnknownSync(Schema.Date)(new Date("2024-01-01"))
 * date.toISOString() // => "2024-01-01T00:00:00.000Z"
 * ```
 *
 * @see {@link DateFromString} for decoding strings into Date instances
 * @see {@link DateFromMillis} for decoding epoch milliseconds into Date instances
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare const Date: Date;
/**
 * Type-level representation of {@link DateFromString}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface DateFromString extends decodeTo<Date, String> {
    readonly "Rebuild": DateFromString;
}
/**
 * Schema that decodes a string into a JavaScript `Date`.
 *
 * **When to use**
 *
 * Use to model string-encoded dates that decode to JavaScript `Date` objects
 * and encode back to strings.
 *
 * **Details**
 *
 * Decoding:
 * The string is passed to JavaScript `Date` construction.
 *
 * Encoding:
 * A `Date` is encoded as an ISO string.
 *
 * Invalid date strings fail decoding.
 *
 * @see {@link DateFromMillis} for decoding epoch milliseconds into Date instances
 * @see {@link DateTimeUtcFromString} for decoding date-time strings into UTC values
 * @see {@link Date} for accepting Date instances directly
 *
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare const DateFromString: DateFromString;
/**
 * Type-level representation of {@link DateFromMillis}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface DateFromMillis extends decodeTo<Date, Int> {
    readonly "Rebuild": DateFromMillis;
}
/**
 * Schema that decodes epoch milliseconds into a JavaScript `Date`.
 *
 * **When to use**
 *
 * Use to model numeric millisecond timestamps that decode to JavaScript `Date`
 * objects and encode back to numbers.
 *
 * **Details**
 *
 * Decoding:
 * A safe integer number of milliseconds since the Unix epoch is decoded as a
 * `Date`.
 *
 * Encoding:
 * A `Date` is encoded as its millisecond timestamp.
 *
 * **Gotchas**
 *
 * JavaScript `Date` supports a narrower range than safe integers, so integers
 * outside the supported `Date` range fail decoding.
 *
 * @see {@link DateFromString} for decoding string-encoded dates
 * @see {@link DateTimeUtcFromMillis} for decoding epoch milliseconds into UTC values
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare const DateFromMillis: DateFromMillis;
/**
 * Type-level representation returned by {@link fromJsonString}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface fromJsonString<S extends Constraint> extends decodeTo<S, String> {
    readonly "Rebuild": fromJsonString<S>;
}
/**
 * Returns a schema that decodes a JSON string and then decodes the parsed value
 * using the given schema.
 *
 * **Details**
 *
 * This is useful when working with JSON-encoded strings where the actual
 * structure of the value is known and described by an existing schema.
 *
 * During decoding, the resulting schema first parses the input string as JSON,
 * using `reviver` when provided, and then runs the provided schema on the
 * parsed result. During encoding, it first encodes with the provided schema and
 * then passes the result to `JSON.stringify` with the optional `replacer` and
 * `space`.
 *
 * **Example** (Formatting encoded JSON)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const schema = Schema.Struct({ a: Schema.Number })
 * const schemaFromJsonString = Schema.fromJsonString(schema, { space: 2 })
 *
 * Schema.encodeSync(schemaFromJsonString)({ a: 1 }) // => "{\n  \"a\": 1\n}"
 * ```
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare function fromJsonString<S extends Constraint>(schema: S, options?: {
    readonly reviver?: Parameters<typeof JSON.parse>[1] | undefined;
    readonly replacer?: SchemaGetter.JsonReplacer | undefined;
    readonly space?: Parameters<typeof JSON.stringify>[2] | undefined;
}): fromJsonString<S>;
/**
 * Type-level representation of {@link File}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface File extends instanceOf<globalThis.File> {
    readonly "Rebuild": File;
}
/**
 * Schema for JavaScript `File` objects.
 *
 * **Details**
 *
 * The default JSON serializer encodes a `File` as `{ data, type, name, lastModified }`
 * where `data` is base64-encoded.
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare const File: File;
/**
 * Type-level representation of {@link FormData}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface FormData extends instanceOf<globalThis.FormData> {
    readonly "Rebuild": FormData;
}
/**
 * Schema for JavaScript `FormData` objects.
 *
 * **Details**
 *
 * The default JSON serializer encodes a `FormData` as an array of `[key, entry]`
 * pairs where each entry is tagged as `"String"` or `"File"`.
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare const FormData: FormData;
/**
 * Type-level representation returned by {@link fromFormData}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface fromFormData<S extends Constraint> extends decodeTo<S, FormData> {
    readonly "Rebuild": fromFormData<S>;
}
/**
 * Schema for decoding `FormData` through a bracket-notation tree.
 *
 * **When to use**
 *
 * Use to decode browser or multipart form data into a structured schema value.
 *
 * **Details**
 *
 * The decoding process has two steps:
 *
 * 1. Parse `FormData` into a nested tree record.
 * 2. Decode the parsed value with the given schema.
 *
 * You can express nested values using bracket notation.
 *
 * If you want to decode string fields into non-string primitive values, use
 * `Schema.toCodecStringTree`.
 *
 * **Example** (Decoding a flat structure)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const schema = Schema.fromFormData(
 *   Schema.Struct({
 *     a: Schema.String
 *   })
 * )
 *
 * const formData = new FormData()
 * formData.append("a", "1")
 * formData.append("b", "2")
 *
 * Schema.decodeUnknownSync(schema)(formData) // => { a: "1" }
 * ```
 *
 * **Example** (Decoding nested fields)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const schema = Schema.fromFormData(
 *   Schema.Struct({
 *     a: Schema.String,
 *     b: Schema.Struct({
 *       c: Schema.String,
 *       d: Schema.String
 *     })
 *   })
 * )
 *
 * const formData = new FormData()
 * formData.append("a", "1")
 * formData.append("b[c]", "2")
 * formData.append("b[d]", "3")
 *
 * Schema.decodeUnknownSync(schema)(formData) // => { a: "1", b: { c: "2", d: "3" } }
 * ```
 *
 * **Example** (Parsing non-string values)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const schema = Schema.fromFormData(
 *   Schema.toCodecStringTree(
 *     Schema.Struct({
 *       a: Schema.Int
 *     })
 *   )
 * )
 *
 * const formData = new FormData()
 * formData.append("a", "1")
 *
 * Schema.decodeUnknownSync(schema)(formData) // => { a: 1 }
 * ```
 *
 * @stability stable
 * @category decoding
 * @since 4.0.0
 */
export declare function fromFormData<S extends Constraint>(schema: S): fromFormData<S>;
/**
 * Type-level representation of {@link URLSearchParams}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface URLSearchParams extends instanceOf<globalThis.URLSearchParams> {
    readonly "Rebuild": URLSearchParams;
}
/**
 * Schema for JavaScript `URLSearchParams` objects.
 *
 * **Details**
 *
 * The default JSON serializer encodes a `URLSearchParams` as a query string.
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare const URLSearchParams: URLSearchParams;
/**
 * Type-level representation returned by {@link fromURLSearchParams}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface fromURLSearchParams<S extends Constraint> extends decodeTo<S, URLSearchParams> {
    readonly "Rebuild": fromURLSearchParams<S>;
}
/**
 * Schema for decoding `URLSearchParams` through a bracket-notation tree.
 *
 * **When to use**
 *
 * Use to decode query parameters into a structured schema value.
 *
 * **Details**
 *
 * The decoding process has two steps:
 *
 * 1. Parse `URLSearchParams` into a nested tree record.
 * 2. Decode the parsed value with the given schema.
 *
 * You can express nested values using bracket notation.
 *
 * If you want to decode values that are not strings, use
 * `Schema.toCodecStringTree`. This serializer preserves values such as
 * numbers when compatible with the schema.
 *
 * **Example** (Decoding a flat structure)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const schema = Schema.fromURLSearchParams(
 *   Schema.Struct({
 *     a: Schema.String
 *   })
 * )
 *
 * const urlSearchParams = new URLSearchParams("a=1&b=2")
 *
 * Schema.decodeUnknownSync(schema)(urlSearchParams) // => { a: "1" }
 * ```
 *
 * **Example** (Decoding nested fields)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const schema = Schema.fromURLSearchParams(
 *   Schema.Struct({
 *     a: Schema.String,
 *     b: Schema.Struct({
 *       c: Schema.String,
 *       d: Schema.String
 *     })
 *   })
 * )
 *
 * const urlSearchParams = new URLSearchParams("a=1&b[c]=2&b[d]=3")
 *
 * Schema.decodeUnknownSync(schema)(urlSearchParams) // => { a: "1", b: { c: "2", d: "3" } }
 * ```
 *
 * **Example** (Parsing non-string values)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const schema = Schema.fromURLSearchParams(
 *   Schema.toCodecStringTree(
 *     Schema.Struct({
 *       a: Schema.Int
 *     })
 *   )
 * )
 *
 * const urlSearchParams = new URLSearchParams("a=1&b=2")
 *
 * Schema.decodeUnknownSync(schema)(urlSearchParams) // => { a: 1 }
 * ```
 *
 * @stability stable
 * @category decoding
 * @since 4.0.0
 */
export declare function fromURLSearchParams<S extends Constraint>(schema: S): fromURLSearchParams<S>;
/**
 * Type-level representation of {@link NumberFromString}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface NumberFromString extends decodeTo<Number, String> {
    readonly "Rebuild": NumberFromString;
}
/**
 * Schema that parses a string into a `number` using JavaScript
 * number coercion.
 *
 * **Details**
 *
 * Decoding:
 * A `string` is decoded as a number, including possible non-finite values such as
 * `NaN`, `Infinity`, and `-Infinity`. Use `FiniteFromString` to reject non-finite
 * numbers.
 *
 * Encoding:
 * A number is encoded as a `string`.
 *
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare const NumberFromString: NumberFromString;
/**
 * Type-level representation of {@link FiniteFromString}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface FiniteFromString extends decodeTo<Finite, String> {
    readonly "Rebuild": FiniteFromString;
}
/**
 * Schema that parses a string into a finite number.
 *
 * **Details**
 *
 * Decoding:
 * - A `string` is decoded as a finite number, rejecting `NaN`, `Infinity`, and
 *   `-Infinity` values.
 *
 * Encoding:
 * - A finite number is encoded as a `string`.
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare const FiniteFromString: FiniteFromString;
/**
 * Type-level representation of {@link BigIntFromString}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface BigIntFromString extends decodeTo<BigInt, String> {
    readonly "Rebuild": BigIntFromString;
}
/**
 * Schema that parses a string into a `bigint`.
 *
 * **When to use**
 *
 * Use to parse signed base-10 integer strings into bigint values while encoding
 * bigint values back to decimal strings.
 *
 * **Details**
 *
 * Decoding:
 * - A `string` is decoded as a `bigint`.
 *
 * Encoding:
 * - A `bigint` is encoded as a `string`.
 *
 * **Gotchas**
 *
 * Decoding accepts only strings matching `^-?\d+$`.
 *
 * @see {@link isStringBigInt} for the string predicate used by this schema
 * @see {@link BigInt} for validating values that are already bigint values
 * @see {@link NumberFromString} for parsing JavaScript number strings, including non-finite values
 * @see {@link BigDecimalFromString} for parsing decimal number strings
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare const BigIntFromString: BigIntFromString;
/**
 * Type-level representation of {@link Trimmed}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface Trimmed extends String {
    readonly "Rebuild": Trimmed;
}
/**
 * Schema for strings that contains no leading or trailing whitespaces.
 *
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare const Trimmed: Trimmed;
/**
 * Type-level representation of {@link Trim}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface Trim extends decodeTo<Trimmed, String> {
    readonly "Rebuild": Trim;
}
/**
 * Schema that trims whitespace from a string.
 *
 * **Details**
 *
 * Decoding:
 * - A `string` is decoded as a string with no leading or trailing whitespaces.
 *
 * Encoding:
 * - The trimmed string is encoded as is.
 *
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare const Trim: Trim;
/**
 * Type-level representation of {@link StringFromBase64}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface StringFromBase64 extends decodeTo<String, String> {
    readonly "Rebuild": StringFromBase64;
}
/**
 * Decodes a base64 (RFC4648) encoded string into a UTF-8 string.
 *
 * **Details**
 *
 * Decoding:
 * - A **valid** base64 encoded string is decoded as a UTF-8 `string`.
 *
 * Encoding:
 * - A `string` is encoded as a base64-encoded string.
 *
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare const StringFromBase64: StringFromBase64;
/**
 * Type-level representation of {@link StringFromBase64Url}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface StringFromBase64Url extends decodeTo<String, String> {
    readonly "Rebuild": StringFromBase64Url;
}
/**
 * Decodes a base64 (URL) encoded string into a UTF-8 string.
 *
 * **Details**
 *
 * Decoding:
 * - A **valid** base64 (URL) encoded string is decoded as a UTF-8 `string`.
 *
 * Encoding:
 * - A `string` is encoded as a base64 (URL) encoded string.
 *
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare const StringFromBase64Url: StringFromBase64Url;
/**
 * Type-level representation of {@link StringFromHex}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface StringFromHex extends decodeTo<String, String> {
    readonly "Rebuild": StringFromHex;
}
/**
 * Decodes a hex encoded string into a UTF-8 string.
 *
 * **Details**
 *
 * Decoding:
 * - A **valid** hex encoded string is decoded as a UTF-8 `string`.
 *
 * Encoding:
 * - A `string` is encoded as a hex string.
 *
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare const StringFromHex: StringFromHex;
/**
 * Type-level representation of {@link StringFromUriComponent}.
 *
 * @stability stable
 * @category models
 * @since 3.12.0
 */
export interface StringFromUriComponent extends decodeTo<String, String> {
    readonly "Rebuild": StringFromUriComponent;
}
/**
 * Decodes a URI component encoded string into a UTF-8 string.
 * Can be used to store data in a URL.
 *
 * **Details**
 *
 * Decoding:
 * - A **valid** URI component encoded string is decoded as a UTF-8 `string`.
 *
 * Encoding:
 * - A `string` is encoded as a URI component encoded string.
 *
 * **Example** (Decoding URI component strings)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const PaginationSchema = Schema.Struct({
 *   maxItemPerPage: Schema.Number,
 *   page: Schema.Number
 * })
 *
 * const UrlSchema = Schema.StringFromUriComponent.pipe(
 *   Schema.decodeTo(Schema.fromJsonString(PaginationSchema))
 * )
 *
 * Schema.encodeSync(UrlSchema)({ maxItemPerPage: 10, page: 1 }) // => "%7B%22maxItemPerPage%22%3A10%2C%22page%22%3A1%7D"
 * ```
 *
 * @stability stable
 * @category schemas
 * @since 3.12.0
 */
export declare const StringFromUriComponent: StringFromUriComponent;
/**
 * Schema for property keys accepted by Effect schemas: finite `number`,
 * `symbol`, or `string`.
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare const PropertyKey: Union<readonly [Finite, Symbol, String]>;
/**
 * Schema for a Standard Schema v1 failure result.
 *
 * **Details**
 *
 * The result contains an `issues` array where each issue has a message and an
 * optional path made of property keys or keyed path segments.
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare const StandardSchemaV1FailureResult: Struct<{
    readonly issues: $Array<Struct<{
        readonly message: String;
        readonly path: optional<$Array<Union<readonly [
            Union<readonly [Finite, Symbol, String]>,
            Struct<{
                readonly key: Union<readonly [Finite, Symbol, String]>;
            }>
        ]>>>;
    }>>;
}>;
/**
 * Type-level representation of {@link BooleanFromBit}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface BooleanFromBit extends decodeTo<Boolean, Literals<readonly [0, 1]>> {
    readonly "Rebuild": BooleanFromBit;
}
/**
 * Schema for a boolean parsed from 0 or 1.
 *
 * **When to use**
 *
 * Use when decoding data sources that represent booleans as `0 | 1` while
 * keeping boolean values in the decoded model.
 *
 * **Details**
 *
 * Decoding accepts only `0 | 1`, maps `1` to `true`, and maps `0` to `false`.
 * Encoding maps `true` to `1` and `false` to `0`.
 *
 * @see {@link Boolean} for validating values that are already booleans
 * @see {@link Literals} for keeping bit literals instead of decoding them
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare const BooleanFromBit: BooleanFromBit;
/**
 * Type-level representation of {@link Uint8Array}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface Uint8Array extends instanceOf<globalThis.Uint8Array<ArrayBufferLike>> {
    readonly "Rebuild": Uint8Array;
}
/**
 * Schema for JavaScript `Uint8Array` objects.
 *
 * **Details**
 *
 * Default JSON serializer:
 *
 * The default JSON serializer encodes Uint8Array as a Base64 encoded string.
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare const Uint8Array: Uint8Array;
/**
 * Type-level representation of {@link Uint8ArrayFromBase64}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface Uint8ArrayFromBase64 extends decodeTo<Uint8Array, String> {
    readonly "Rebuild": Uint8ArrayFromBase64;
}
/**
 * Schema that decodes a base64 encoded string into a
 * `Uint8Array`.
 *
 * **Details**
 *
 * Decoding:
 * - A **valid** base64 encoded string is decoded as a `Uint8Array`.
 *
 * Encoding:
 * - A `Uint8Array` is encoded as a base64-encoded string.
 *
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare const Uint8ArrayFromBase64: Uint8ArrayFromBase64;
/**
 * Type-level representation of {@link Uint8ArrayFromBase64Url}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface Uint8ArrayFromBase64Url extends decodeTo<Uint8Array, String> {
    readonly "Rebuild": Uint8ArrayFromBase64Url;
}
/**
 * Schema that decodes a base64 (URL) encoded string into a
 * `Uint8Array`.
 *
 * **Details**
 *
 * Decoding:
 * - A **valid** base64 (URL) encoded string is decoded as a `Uint8Array`.
 *
 * Encoding:
 * - A `Uint8Array` is encoded as a base64 (URL) encoded string.
 *
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare const Uint8ArrayFromBase64Url: Uint8ArrayFromBase64Url;
/**
 * Type-level representation of {@link Uint8ArrayFromHex}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface Uint8ArrayFromHex extends decodeTo<Uint8Array, String> {
    readonly "Rebuild": Uint8ArrayFromHex;
}
/**
 * Schema that decodes a hex encoded string into a
 * `Uint8Array`.
 *
 * **Details**
 *
 * Decoding:
 * - A **valid** hex encoded string is decoded as a `Uint8Array`.
 *
 * Encoding:
 * - A `Uint8Array` is encoded as a hex encoded string.
 *
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare const Uint8ArrayFromHex: Uint8ArrayFromHex;
/**
 * Validates that a BigDecimal is greater than the specified value (exclusive).
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare const isGreaterThanBigDecimal: (exclusiveMinimum: BigDecimal_.BigDecimal, annotations?: Annotations.Filter) => SchemaAST.Filter<BigDecimal_.BigDecimal>;
/**
 * Validates that a BigDecimal is greater than or equal to the specified value
 * (inclusive).
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare const isGreaterThanOrEqualToBigDecimal: (minimum: BigDecimal_.BigDecimal, annotations?: Annotations.Filter) => SchemaAST.Filter<BigDecimal_.BigDecimal>;
/**
 * Validates that a BigDecimal is less than the specified value (exclusive).
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare const isLessThanBigDecimal: (exclusiveMaximum: BigDecimal_.BigDecimal, annotations?: Annotations.Filter) => SchemaAST.Filter<BigDecimal_.BigDecimal>;
/**
 * Validates that a BigDecimal is less than or equal to the specified value
 * (inclusive).
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare const isLessThanOrEqualToBigDecimal: (maximum: BigDecimal_.BigDecimal, annotations?: Annotations.Filter) => SchemaAST.Filter<BigDecimal_.BigDecimal>;
/**
 * Validates that a `BigDecimal` is within a specified range.
 *
 * **Details**
 *
 * The minimum and maximum boundaries are inclusive by default. Pass
 * `exclusiveMinimum` or `exclusiveMaximum` to exclude either boundary.
 *
 * @stability stable
 * @category validation
 * @since 4.0.0
 */
export declare const isBetweenBigDecimal: (options: {
    readonly minimum: BigDecimal_.BigDecimal;
    readonly maximum: BigDecimal_.BigDecimal;
    readonly exclusiveMinimum?: boolean | undefined;
    readonly exclusiveMaximum?: boolean | undefined;
}, annotations?: Annotations.Filter) => SchemaAST.Filter<BigDecimal_.BigDecimal>;
/**
 * Type-level representation of {@link BigDecimal}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface BigDecimal extends declare<BigDecimal_.BigDecimal> {
    readonly "Rebuild": BigDecimal;
}
/**
 * Schema for `BigDecimal` values.
 *
 * **When to use**
 *
 * Use when you already have Effect decimal instances and need schema
 * validation, formatting, equivalence, and JSON string serialization.
 *
 * **Details**
 *
 * Default JSON serializer:
 *
 * - encodes `BigDecimal` as a `string`
 *
 * @see {@link BigDecimalFromString} for parsing string input into a BigDecimal
 *
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare const BigDecimal: BigDecimal;
/**
 * Type-level representation of {@link BigDecimalFromString}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface BigDecimalFromString extends decodeTo<BigDecimal, String> {
    readonly "Rebuild": BigDecimalFromString;
}
/**
 * Schema that parses a string into a `BigDecimal`.
 *
 * **When to use**
 *
 * Use to parse decimal or exponent-notation strings into arbitrary-precision
 * BigDecimal values while encoding them back to strings.
 *
 * **Details**
 *
 * Decoding:
 * - A `string` is decoded with `BigDecimal.fromString`.
 *
 * Encoding:
 * - A `BigDecimal` is encoded with `BigDecimal.format`.
 *
 * **Gotchas**
 *
 * An empty string decodes as zero.
 *
 * @see {@link BigDecimal} for validating values that are already BigDecimal values
 * @see {@link BigIntFromString} for parsing base-10 integer strings into bigint values
 * @see {@link NumberFromString} for parsing JavaScript number strings
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare const BigDecimalFromString: BigDecimalFromString;
/**
 * Type-level representation of {@link ByteSize}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface ByteSize extends declare<ByteSize_.ByteSize> {
    readonly "Rebuild": ByteSize;
}
/**
 * Schema for exact, non-negative `ByteSize` values.
 *
 * **Details**
 *
 * The JSON codec encodes the byte count as a bigint string, preserving values
 * beyond JavaScript's safe-integer range. The StringTree codec uses the
 * human-readable byte-size syntax exposed by {@link ByteSizeFromString}.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const ByteSize: ByteSize;
/**
 * Type-level representation of {@link ByteSizeFromString}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface ByteSizeFromString extends decodeTo<ByteSize, String> {
    readonly "Rebuild": ByteSizeFromString;
}
/**
 * Schema that decodes byte-size strings into exact, non-negative `ByteSize`
 * values.
 *
 * **Details**
 *
 * Decoding accepts an unsigned base-10 integer or decimal followed by optional
 * whitespace and one of these case-sensitive units:
 *
 * - bytes: `B`, `byte`, or `bytes`
 * - decimal SI units (powers of 1,000): `kB`, `MB`, `GB`, `TB`, `PB`, `EB`,
 *   `ZB`, `YB`, `RB`, or `QB`, plus their lowercase singular and plural names
 * - binary IEC units (powers of 1,024): `KiB`, `MiB`, `GiB`, `TiB`, `PiB`,
 *   `EiB`, `ZiB`, or `YiB`, plus their lowercase singular and plural names
 *
 * Leading and trailing whitespace is ignored. A decimal quantity must resolve
 * to an integral number of bytes, so `1.5 kB` is accepted while `0.1 KiB` is
 * rejected.
 *
 * Encoding returns the exact byte count as `<count> byte` or `<count> bytes`.
 *
 * **Gotchas**
 *
 * A unit is required. Signs, exponent notation, digit separators, and ambiguous
 * unit spellings such as `KB`, `mb`, `Mb`, or `b` are rejected.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const ByteSizeFromString: ByteSizeFromString;
/**
 * Type-level representation of {@link ByteSizeFromBigInt}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface ByteSizeFromBigInt extends decodeTo<ByteSize, BigInt> {
    readonly "Rebuild": ByteSizeFromBigInt;
}
/**
 * Schema that decodes non-negative bigint byte counts.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const ByteSizeFromBigInt: ByteSizeFromBigInt;
/**
 * Type-level representation of {@link ByteSizeFromNumber}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface ByteSizeFromNumber extends decodeTo<ByteSize, Number> {
    readonly "Rebuild": ByteSizeFromNumber;
}
/**
 * Schema that decodes non-negative safe-integer byte counts.
 *
 * **Details**
 *
 * Encoding fails when the byte count exceeds `Number.MAX_SAFE_INTEGER`.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const ByteSizeFromNumber: ByteSizeFromNumber;
/**
 * Type-level representation returned by {@link CauseReason}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface CauseReason<E extends Constraint, D extends Constraint> extends declareConstructor<Cause_.Reason<E["Type"]>, Cause_.Reason<E["Encoded"]>, readonly [E, D], CauseReasonIso<E, D>> {
    readonly "Rebuild": CauseReason<E, D>;
    readonly error: E;
    readonly defect: D;
}
/**
 * Iso representation used for `CauseReason` schemas.
 *
 * **Details**
 *
 * Failures are represented with a `Fail` tag and encoded error, defects with a
 * `Die` tag and encoded defect, and interrupts with an optional `fiberId`.
 *
 * @stability stable
 * @category utility types
 * @since 4.0.0
 */
export type CauseReasonIso<E extends Constraint, D extends Constraint> = {
    readonly _tag: "Fail";
    readonly error: E["Iso"];
} | {
    readonly _tag: "Die";
    readonly error: D["Iso"];
} | {
    readonly _tag: "Interrupt";
    readonly fiberId: number | undefined;
};
/**
 * Creates a schema for `Cause.Reason` values using separate schemas for typed
 * failures and unexpected defects.
 *
 * **When to use**
 *
 * Use when serializing or decoding individual cause reasons separately from a
 * full failure cause, with distinct schemas for typed errors and defects.
 *
 * **Details**
 *
 * `Fail` reasons use the `error` schema, `Die` reasons use the `defect` schema,
 * and `Interrupt` reasons carry only an optional fiber id.
 *
 * @see {@link Cause} for constructing schemas for full Cause values
 * @see {@link CauseReasonIso} for the ISO shape of each cause reason
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare function CauseReason<E extends Constraint, D extends Constraint>(error: E, defect: D): CauseReason<E, D>;
/**
 * Type-level representation returned by {@link Cause}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface Cause<E extends Constraint, D extends Constraint> extends declareConstructor<Cause_.Cause<E["Type"]>, Cause_.Cause<E["Encoded"]>, readonly [E, D], CauseIso<E, D>> {
    readonly "Rebuild": Cause<E, D>;
    readonly error: E;
    readonly defect: D;
}
/**
 * Iso representation used for `Cause` schemas: an ordered array of
 * `CauseReasonIso` values.
 *
 * **When to use**
 *
 * Use when working with the ISO shape of a `Cause` schema, such as `toIso`
 * optics or codecs that expose a cause as its ordered array of encoded reasons.
 *
 * @see {@link Cause} for constructing schemas for full Cause values
 * @see {@link CauseReasonIso} for the ISO shape of each array element
 *
 * @stability stable
 * @category utility types
 * @since 4.0.0
 */
export type CauseIso<E extends Constraint, D extends Constraint> = ReadonlyArray<CauseReasonIso<E, D>>;
/**
 * Creates a schema for `Cause` values using separate schemas for typed failures
 * and unexpected defects.
 *
 * **When to use**
 *
 * Use to validate, transform, or serialize Effect failure causes when typed
 * failures and unexpected defects need separate schemas.
 *
 * **Details**
 *
 * The `error` schema is applied to `Fail` reasons and the `defect` schema is
 * applied to `Die` reasons. Interrupt reasons do not use either schema and
 * carry only an optional fiber id.
 *
 * @see {@link CauseReason} for the schema used by each individual cause reason
 * @see {@link CauseIso} for the ordered array representation used by the schema ISO
 *
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare function Cause<E extends Constraint, D extends Constraint>(error: E, defect: D): Cause<E, D>;
/**
 * Type-level representation returned by {@link Chunk}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface Chunk<Value extends Constraint> extends declareConstructor<Chunk_.Chunk<Value["Type"]>, Chunk_.Chunk<Value["Encoded"]>, readonly [Value], ChunkIso<Value>> {
    readonly "Rebuild": Chunk<Value>;
    readonly value: Value;
}
/**
 * Iso representation used for `Chunk` schemas: an array of element values using
 * the element schema's `Iso` type.
 *
 * **When to use**
 *
 * Use when annotating type-level helpers that work with the readonly-array ISO
 * shape of a `Chunk` schema.
 *
 * @see {@link Chunk} for the schema interface and constructor that use this ISO representation
 *
 * @stability stable
 * @category utility types
 * @since 4.0.0
 */
export type ChunkIso<Value extends Constraint> = ReadonlyArray<Value["Iso"]>;
/**
 * Schema for chunks whose values conform to the provided element schema.
 *
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare function Chunk<Value extends Constraint>(value: Value): Chunk<Value>;
/**
 * Type-level representation of {@link DateTimeUtc}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface DateTimeUtc extends declare<DateTime.Utc> {
    readonly "Rebuild": DateTimeUtc;
}
/**
 * Schema for `DateTime.Utc` values.
 *
 * **When to use**
 *
 * Use to validate existing `DateTime.Utc` schema values and use the default JSON
 * codec that represents them as UTC ISO strings.
 *
 * **Details**
 *
 * The default JSON codec decodes UTC ISO strings into `DateTime.Utc` values and
 * encodes `DateTime.Utc` values as UTC ISO strings.
 *
 * @see {@link DateTimeUtcFromString} for decoding date-time strings into UTC values
 * @see {@link DateTimeUtcFromDate} for decoding JavaScript Date values into UTC values
 * @see {@link DateTimeUtcFromMillis} for decoding epoch milliseconds into UTC values
 * @see {@link DateTimeZoned} for preserving zoned DateTime values
 *
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare const DateTimeUtc: DateTimeUtc;
/**
 * Type-level representation of {@link DateTimeUtcFromDate}.
 *
 * @stability stable
 * @category models
 * @since 3.12.0
 */
export interface DateTimeUtcFromDate extends decodeTo<DateTimeUtc, Date> {
    readonly "Rebuild": DateTimeUtcFromDate;
}
/**
 * Schema that decodes a `Date` into a `DateTime.Utc`.
 *
 * **When to use**
 *
 * Use when you need to decode valid JavaScript `Date` objects into
 * `DateTime.Utc` values.
 *
 * **Details**
 *
 * Decoding:
 * - A **valid** `Date` is decoded as a `DateTime.Utc`
 *
 * Encoding:
 * - A `DateTime.Utc` is encoded as a `Date`
 *
 * @see {@link DateTimeUtc} for validating values that are already `DateTime.Utc`
 * @see {@link DateTimeUtcFromString} for decoding date-time strings into UTC values
 * @see {@link DateTimeUtcFromMillis} for decoding epoch milliseconds into UTC values
 * @see {@link Date} for validating Date instances without converting them
 *
 * @stability stable
 * @category schemas
 * @since 3.12.0
 */
export declare const DateTimeUtcFromDate: DateTimeUtcFromDate;
/**
 * Type-level representation of {@link DateTimeUtcFromString}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface DateTimeUtcFromString extends decodeTo<DateTimeUtc, String> {
    readonly "Rebuild": DateTimeUtcFromString;
}
/**
 * Schema that decodes a date-time string into a `DateTime.Utc`.
 *
 * **Details**
 *
 * Decoding:
 *
 * - A string accepted by `DateTime.make` is parsed and normalized to UTC. Strings
 *   without an explicit zone are interpreted as UTC.
 *
 * Encoding:
 *
 * - A `DateTime.Utc` is encoded as a UTC ISO 8601 string.
 *
 * @see {@link DateTimeUtcFromDate} for decoding JavaScript Date values into UTC values
 * @see {@link DateTimeUtcFromMillis} for decoding epoch milliseconds into UTC values
 * @see {@link DateFromString} for decoding strings into JavaScript Date instances
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare const DateTimeUtcFromString: DateTimeUtcFromString;
/**
 * Type-level representation of {@link DateTimeUtcFromHttpDate}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface DateTimeUtcFromHttpDate extends decodeTo<DateTimeUtc, String> {
    readonly "Rebuild": DateTimeUtcFromHttpDate;
}
/**
 * Schema for HTTP date header values, such as `Date`, `Last-Modified` and
 * `Expires`, decoded as `DateTime.Utc`.
 *
 * **When to use**
 *
 * Use with HTTP API header schemas that carry dates. Decoding accepts the
 * three formats of RFC 9110 §5.6.7 and reads them as UTC; encoding emits the
 * preferred IMF-fixdate form (`Sun, 06 Nov 1994 08:49:37 GMT`).
 *
 * **Example** (Decoding an HTTP date)
 *
 * ```ts
 * import { DateTime, Schema } from "effect"
 *
 * const date = Schema.decodeSync(Schema.DateTimeUtcFromHttpDate)("Sun, 06 Nov 1994 08:49:37 GMT")
 * const millis = DateTime.toEpochMillis(date) // => 784111777000
 * ```
 *
 * @see {@link DateTimeUtcFromString} for ISO 8601 strings
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const DateTimeUtcFromHttpDate: DateTimeUtcFromHttpDate;
/**
 * Type-level representation of {@link DateTimeUtcFromMillis}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface DateTimeUtcFromMillis extends decodeTo<instanceOf<DateTime.Utc>, Int> {
    readonly "Rebuild": DateTimeUtcFromMillis;
}
/**
 * Schema that decodes a number into a `DateTime.Utc`.
 *
 * **Details**
 *
 * Decoding:
 * - A number of milliseconds since the Unix epoch is decoded as a `DateTime.Utc`
 *
 * Encoding:
 * - A `DateTime.Utc` is encoded as a number of milliseconds since the Unix epoch.
 *
 * @see {@link DateTimeUtcFromDate} for decoding JavaScript Date values into UTC values
 * @see {@link DateTimeUtcFromString} for decoding date-time strings into UTC values
 * @see {@link DateFromMillis} for decoding epoch milliseconds into JavaScript Date instances
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare const DateTimeUtcFromMillis: DateTimeUtcFromMillis;
/**
 * Type-level representation of {@link TimeZoneOffset}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface TimeZoneOffset extends declare<DateTime.TimeZone.Offset> {
    readonly "Rebuild": TimeZoneOffset;
}
/**
 * Schema for `DateTime.TimeZone.Offset` values.
 *
 * **Details**
 *
 * Default JSON serializer:
 *
 * - encodes `DateTime.TimeZone.Offset` as a number (offset in milliseconds)
 *
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare const TimeZoneOffset: TimeZoneOffset;
/**
 * Type-level representation of {@link TimeZoneNamed}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface TimeZoneNamed extends declare<DateTime.TimeZone.Named> {
    readonly "Rebuild": TimeZoneNamed;
}
/**
 * Schema for `DateTime.TimeZone.Named` values.
 *
 * **Details**
 *
 * Default JSON serializer:
 *
 * - encodes `DateTime.TimeZone.Named` as a string (IANA time zone identifier)
 *
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare const TimeZoneNamed: TimeZoneNamed;
/**
 * Type-level representation of {@link TimeZoneNamedFromString}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface TimeZoneNamedFromString extends decodeTo<TimeZoneNamed, String> {
    readonly "Rebuild": TimeZoneNamedFromString;
}
/**
 * Schema that parses an IANA time zone identifier string into a `DateTime.TimeZone.Named`.
 *
 * **Details**
 *
 * Decoding:
 * - A `string` is decoded as a `DateTime.TimeZone.Named`.
 *
 * Encoding:
 * - A `DateTime.TimeZone.Named` is encoded as a `string`.
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare const TimeZoneNamedFromString: TimeZoneNamedFromString;
/**
 * Type-level representation of {@link TimeZone}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface TimeZone extends declare<DateTime.TimeZone> {
    readonly "Rebuild": TimeZone;
}
/**
 * Schema for `DateTime.TimeZone` values.
 *
 * **Details**
 *
 * Default JSON serializer:
 *
 * - encodes `DateTime.TimeZone` as a string (IANA identifier or offset like
 *   `+03:00`)
 *
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare const TimeZone: TimeZone;
/**
 * Type-level representation of {@link TimeZoneFromString}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface TimeZoneFromString extends decodeTo<TimeZone, String> {
    readonly "Rebuild": TimeZoneFromString;
}
/**
 * Schema that parses a time zone string into a `DateTime.TimeZone`.
 *
 * **Details**
 *
 * Decoding:
 * - A `string` (IANA identifier or offset like `+03:00`) is decoded as a `DateTime.TimeZone`.
 *
 * Encoding:
 * - A `DateTime.TimeZone` is encoded as a `string`.
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare const TimeZoneFromString: TimeZoneFromString;
/**
 * Type-level representation of {@link DateTimeZoned}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface DateTimeZoned extends declare<DateTime.Zoned> {
    readonly "Rebuild": DateTimeZoned;
}
/**
 * Schema for `DateTime.Zoned` values.
 *
 * **Details**
 *
 * Default JSON serializer:
 *
 * - encodes offset zones as an ISO date-time with a numeric offset, such as
 *   `YYYY-MM-DDTHH:mm:ss.sss+HH:MM`
 * - encodes named zones by appending the IANA identifier in brackets, such as
 *   `YYYY-MM-DDTHH:mm:ss.sss+HH:MM[Time/Zone]`
 *
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare const DateTimeZoned: DateTimeZoned;
/**
 * Type-level representation of {@link DateTimeZonedFromString}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface DateTimeZonedFromString extends decodeTo<DateTimeZoned, String> {
    readonly "Rebuild": DateTimeZonedFromString;
}
/**
 * Schema that parses a zoned DateTime string into a `DateTime.Zoned`.
 *
 * **Details**
 *
 * Decoding:
 * - A `string` (e.g. `2024-01-01T00:00:00.000+00:00[Europe/London]`) is decoded as a `DateTime.Zoned`.
 *
 * Encoding:
 * - A `DateTime.Zoned` is encoded as a `string`.
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare const DateTimeZonedFromString: DateTimeZonedFromString;
/**
 * Type-level representation of {@link MacAddress}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface MacAddress extends declare<NetAddress_.MacAddress> {
    readonly "Rebuild": MacAddress;
}
/**
 * Schema for already-constructed MAC address values.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const MacAddress: MacAddress;
/**
 * Type-level representation of {@link MacAddressFromString}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface MacAddressFromString extends decodeTo<MacAddress, String> {
    readonly "Rebuild": MacAddressFromString;
}
/**
 * Schema for MAC addresses encoded as canonical colon-separated hexadecimal strings.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const MacAddressFromString: MacAddressFromString;
/**
 * Type-level representation of {@link Ipv4Address}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface Ipv4Address extends declare<NetAddress_.Ipv4Address> {
    readonly "Rebuild": Ipv4Address;
}
/**
 * Schema for already-constructed IPv4 address values.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const Ipv4Address: Ipv4Address;
/**
 * Type-level representation of {@link Ipv4AddressFromString}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface Ipv4AddressFromString extends decodeTo<Ipv4Address, String> {
    readonly "Rebuild": Ipv4AddressFromString;
}
/**
 * Schema for IPv4 addresses encoded as canonical dotted-decimal strings.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const Ipv4AddressFromString: Ipv4AddressFromString;
/**
 * Type-level representation of {@link Ipv6Address}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface Ipv6Address extends declare<NetAddress_.Ipv6Address> {
    readonly "Rebuild": Ipv6Address;
}
/**
 * Schema for already-constructed IPv6 address values.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const Ipv6Address: Ipv6Address;
/**
 * Type-level representation of {@link Ipv6AddressFromString}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface Ipv6AddressFromString extends decodeTo<Ipv6Address, String> {
    readonly "Rebuild": Ipv6AddressFromString;
}
/**
 * Schema for IPv6 addresses encoded as canonical strings.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const Ipv6AddressFromString: Ipv6AddressFromString;
/**
 * Type-level representation of {@link IpAddress}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface IpAddress extends declare<NetAddress_.IpAddress> {
    readonly "Rebuild": IpAddress;
}
/**
 * Schema for already-constructed IPv4 or IPv6 address values.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const IpAddress: IpAddress;
/**
 * Type-level representation of {@link IpAddressFromString}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface IpAddressFromString extends decodeTo<IpAddress, String> {
    readonly "Rebuild": IpAddressFromString;
}
/**
 * Schema for IP addresses encoded as canonical numeric strings.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const IpAddressFromString: IpAddressFromString;
/**
 * Type-level representation of {@link IpMulticastAddress}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface IpMulticastAddress extends refine<NetAddress_.MulticastAddress<NetAddress_.IpAddress>, IpAddress> {
    readonly "Rebuild": IpMulticastAddress;
}
/**
 * Schema for already-constructed multicast IP addresses.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const IpMulticastAddress: IpMulticastAddress;
/**
 * Type-level representation of {@link IpMulticastAddressFromString}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface IpMulticastAddressFromString extends refine<NetAddress_.MulticastAddress<NetAddress_.IpAddress>, IpAddressFromString> {
    readonly "Rebuild": IpMulticastAddressFromString;
}
/**
 * Schema for multicast IP addresses encoded as numeric strings.
 *
 * **Example** (Decoding a validated multicast address)
 *
 * ```ts import.meta.vitest
 * import { assert } from "@effect/vitest"
 * import { Schema } from "effect"
 * import { NetAddress } from "effect/net"
 *
 * const address = Schema.decodeUnknownSync(Schema.IpMulticastAddressFromString)("239.255.0.1")
 * assert.isTrue(NetAddress.isMulticast(address))
 * ```
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const IpMulticastAddressFromString: IpMulticastAddressFromString;
/**
 * Type-level representation of {@link MacMulticastAddress}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface MacMulticastAddress extends refine<NetAddress_.MulticastAddress<NetAddress_.MacAddress>, MacAddress> {
    readonly "Rebuild": MacMulticastAddress;
}
/**
 * Schema for already-constructed multicast MAC addresses.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const MacMulticastAddress: MacMulticastAddress;
/**
 * Type-level representation of {@link MacMulticastAddressFromString}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface MacMulticastAddressFromString extends refine<NetAddress_.MulticastAddress<NetAddress_.MacAddress>, MacAddressFromString> {
    readonly "Rebuild": MacMulticastAddressFromString;
}
/**
 * Schema for multicast MAC addresses encoded as canonical strings.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const MacMulticastAddressFromString: MacMulticastAddressFromString;
/**
 * Type-level representation of {@link IpUnicastAddress}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface IpUnicastAddress extends refine<NetAddress_.UnicastAddress<NetAddress_.IpAddress>, IpAddress> {
    readonly "Rebuild": IpUnicastAddress;
}
/**
 * Schema for already-constructed syntactic unicast IP addresses.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const IpUnicastAddress: IpUnicastAddress;
/**
 * Type-level representation of {@link IpUnicastAddressFromString}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface IpUnicastAddressFromString extends refine<NetAddress_.UnicastAddress<NetAddress_.IpAddress>, IpAddressFromString> {
    readonly "Rebuild": IpUnicastAddressFromString;
}
/**
 * Schema for syntactic unicast IP addresses encoded as numeric strings.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const IpUnicastAddressFromString: IpUnicastAddressFromString;
/**
 * Type-level representation of {@link MacUnicastAddress}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface MacUnicastAddress extends refine<NetAddress_.UnicastAddress<NetAddress_.MacAddress>, MacAddress> {
    readonly "Rebuild": MacUnicastAddress;
}
/**
 * Schema for already-constructed unicast MAC addresses.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const MacUnicastAddress: MacUnicastAddress;
/**
 * Type-level representation of {@link MacUnicastAddressFromString}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface MacUnicastAddressFromString extends refine<NetAddress_.UnicastAddress<NetAddress_.MacAddress>, MacAddressFromString> {
    readonly "Rebuild": MacUnicastAddressFromString;
}
/**
 * Schema for unicast MAC addresses encoded as canonical strings.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const MacUnicastAddressFromString: MacUnicastAddressFromString;
/**
 * Type-level representation of {@link Ipv4BroadcastAddress}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface Ipv4BroadcastAddress extends refine<NetAddress_.BroadcastAddress<NetAddress_.Ipv4Address>, Ipv4Address> {
    readonly "Rebuild": Ipv4BroadcastAddress;
}
/**
 * Schema for the already-constructed IPv4 limited broadcast address.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const Ipv4BroadcastAddress: Ipv4BroadcastAddress;
/**
 * Type-level representation of {@link Ipv4BroadcastAddressFromString}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface Ipv4BroadcastAddressFromString extends refine<NetAddress_.BroadcastAddress<NetAddress_.Ipv4Address>, Ipv4AddressFromString> {
    readonly "Rebuild": Ipv4BroadcastAddressFromString;
}
/**
 * Schema for the IPv4 limited broadcast address encoded as a string.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const Ipv4BroadcastAddressFromString: Ipv4BroadcastAddressFromString;
/**
 * Type-level representation of {@link MacBroadcastAddress}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface MacBroadcastAddress extends refine<NetAddress_.BroadcastAddress<NetAddress_.MacAddress>, MacAddress> {
    readonly "Rebuild": MacBroadcastAddress;
}
/**
 * Schema for the already-constructed MAC all-ones broadcast address.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const MacBroadcastAddress: MacBroadcastAddress;
/**
 * Type-level representation of {@link MacBroadcastAddressFromString}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface MacBroadcastAddressFromString extends refine<NetAddress_.BroadcastAddress<NetAddress_.MacAddress>, MacAddressFromString> {
    readonly "Rebuild": MacBroadcastAddressFromString;
}
/**
 * Schema for the MAC all-ones broadcast address encoded as a string.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const MacBroadcastAddressFromString: MacBroadcastAddressFromString;
/**
 * Type-level representation of {@link IpLoopbackAddress}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface IpLoopbackAddress extends refine<NetAddress_.LoopbackAddress<NetAddress_.IpAddress>, IpAddress> {
    readonly "Rebuild": IpLoopbackAddress;
}
/**
 * Schema for already-constructed loopback IP addresses.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const IpLoopbackAddress: IpLoopbackAddress;
/**
 * Type-level representation of {@link IpLoopbackAddressFromString}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface IpLoopbackAddressFromString extends refine<NetAddress_.LoopbackAddress<NetAddress_.IpAddress>, IpAddressFromString> {
    readonly "Rebuild": IpLoopbackAddressFromString;
}
/**
 * Schema for loopback IP addresses encoded as numeric strings.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const IpLoopbackAddressFromString: IpLoopbackAddressFromString;
/**
 * Type-level representation of {@link IpLinkLocalAddress}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface IpLinkLocalAddress extends refine<NetAddress_.LinkLocalAddress<NetAddress_.IpAddress>, IpAddress> {
    readonly "Rebuild": IpLinkLocalAddress;
}
/**
 * Schema for already-constructed link-local IP addresses.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const IpLinkLocalAddress: IpLinkLocalAddress;
/**
 * Type-level representation of {@link IpLinkLocalAddressFromString}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface IpLinkLocalAddressFromString extends refine<NetAddress_.LinkLocalAddress<NetAddress_.IpAddress>, IpAddressFromString> {
    readonly "Rebuild": IpLinkLocalAddressFromString;
}
/**
 * Schema for link-local IP addresses encoded as numeric strings.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const IpLinkLocalAddressFromString: IpLinkLocalAddressFromString;
/**
 * Type-level representation of {@link IpUnspecifiedAddress}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface IpUnspecifiedAddress extends refine<NetAddress_.UnspecifiedAddress<NetAddress_.IpAddress>, IpAddress> {
    readonly "Rebuild": IpUnspecifiedAddress;
}
/**
 * Schema for already-constructed unspecified IP addresses.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const IpUnspecifiedAddress: IpUnspecifiedAddress;
/**
 * Type-level representation of {@link IpUnspecifiedAddressFromString}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface IpUnspecifiedAddressFromString extends refine<NetAddress_.UnspecifiedAddress<NetAddress_.IpAddress>, IpAddressFromString> {
    readonly "Rebuild": IpUnspecifiedAddressFromString;
}
/**
 * Schema for unspecified IP addresses encoded as numeric strings.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const IpUnspecifiedAddressFromString: IpUnspecifiedAddressFromString;
/**
 * Type-level representation of {@link Ipv4PrivateAddress}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface Ipv4PrivateAddress extends refine<NetAddress_.PrivateAddress<NetAddress_.Ipv4Address>, Ipv4Address> {
    readonly "Rebuild": Ipv4PrivateAddress;
}
/**
 * Schema for already-constructed RFC 1918 private-use addresses.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const Ipv4PrivateAddress: Ipv4PrivateAddress;
/**
 * Type-level representation of {@link Ipv4PrivateAddressFromString}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface Ipv4PrivateAddressFromString extends refine<NetAddress_.PrivateAddress<NetAddress_.Ipv4Address>, Ipv4AddressFromString> {
    readonly "Rebuild": Ipv4PrivateAddressFromString;
}
/**
 * Schema for RFC 1918 private-use addresses encoded as strings.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const Ipv4PrivateAddressFromString: Ipv4PrivateAddressFromString;
/**
 * Type-level representation of {@link Ipv6UniqueLocalAddress}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface Ipv6UniqueLocalAddress extends refine<NetAddress_.UniqueLocalAddress<NetAddress_.Ipv6Address>, Ipv6Address> {
    readonly "Rebuild": Ipv6UniqueLocalAddress;
}
/**
 * Schema for already-constructed IPv6 unique-local addresses.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const Ipv6UniqueLocalAddress: Ipv6UniqueLocalAddress;
/**
 * Type-level representation of {@link Ipv6UniqueLocalAddressFromString}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface Ipv6UniqueLocalAddressFromString extends refine<NetAddress_.UniqueLocalAddress<NetAddress_.Ipv6Address>, Ipv6AddressFromString> {
    readonly "Rebuild": Ipv6UniqueLocalAddressFromString;
}
/**
 * Schema for IPv6 unique-local addresses encoded as strings.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const Ipv6UniqueLocalAddressFromString: Ipv6UniqueLocalAddressFromString;
/**
 * Type-level representation of {@link MacLocallyAdministeredAddress}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface MacLocallyAdministeredAddress extends refine<NetAddress_.LocallyAdministeredAddress<NetAddress_.MacAddress>, MacAddress> {
    readonly "Rebuild": MacLocallyAdministeredAddress;
}
/**
 * Schema for already-constructed locally administered MAC addresses.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const MacLocallyAdministeredAddress: MacLocallyAdministeredAddress;
/**
 * Type-level representation of {@link MacLocallyAdministeredAddressFromString}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface MacLocallyAdministeredAddressFromString extends refine<NetAddress_.LocallyAdministeredAddress<NetAddress_.MacAddress>, MacAddressFromString> {
    readonly "Rebuild": MacLocallyAdministeredAddressFromString;
}
/**
 * Schema for locally administered MAC addresses encoded as strings.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const MacLocallyAdministeredAddressFromString: MacLocallyAdministeredAddressFromString;
/**
 * Type-level representation of {@link MacUniversallyAdministeredAddress}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface MacUniversallyAdministeredAddress extends refine<NetAddress_.UniversallyAdministeredAddress<NetAddress_.MacAddress>, MacAddress> {
    readonly "Rebuild": MacUniversallyAdministeredAddress;
}
/**
 * Schema for already-constructed universally administered MAC addresses.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const MacUniversallyAdministeredAddress: MacUniversallyAdministeredAddress;
/**
 * Type-level representation of {@link MacUniversallyAdministeredAddressFromString}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface MacUniversallyAdministeredAddressFromString extends refine<NetAddress_.UniversallyAdministeredAddress<NetAddress_.MacAddress>, MacAddressFromString> {
    readonly "Rebuild": MacUniversallyAdministeredAddressFromString;
}
/**
 * Schema for universally administered MAC addresses encoded as strings.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const MacUniversallyAdministeredAddressFromString: MacUniversallyAdministeredAddressFromString;
/**
 * Type-level representation of {@link Ipv4Interface}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface Ipv4Interface extends declare<IpInterface_.Ipv4Interface> {
    readonly "Rebuild": Ipv4Interface;
}
/**
 * Schema for already-constructed IPv4 interface address values.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const Ipv4Interface: Ipv4Interface;
/**
 * Type-level representation of {@link Ipv4InterfaceFromString}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface Ipv4InterfaceFromString extends decodeTo<Ipv4Interface, String> {
    readonly "Rebuild": Ipv4InterfaceFromString;
}
/**
 * Schema for IPv4 interface addresses encoded as an address and prefix length.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const Ipv4InterfaceFromString: Ipv4InterfaceFromString;
/**
 * Type-level representation of {@link Ipv6Interface}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface Ipv6Interface extends declare<IpInterface_.Ipv6Interface> {
    readonly "Rebuild": Ipv6Interface;
}
/**
 * Schema for already-constructed IPv6 interface address values.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const Ipv6Interface: Ipv6Interface;
/**
 * Type-level representation of {@link Ipv6InterfaceFromString}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface Ipv6InterfaceFromString extends decodeTo<Ipv6Interface, String> {
    readonly "Rebuild": Ipv6InterfaceFromString;
}
/**
 * Schema for IPv6 interface addresses encoded as an address and prefix length.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const Ipv6InterfaceFromString: Ipv6InterfaceFromString;
/**
 * Type-level representation of {@link IpInterface}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface IpInterface extends declare<IpInterface_.IpInterface> {
    readonly "Rebuild": IpInterface;
}
/**
 * Schema for already-constructed IPv4 or IPv6 interface address values.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const IpInterface: IpInterface;
/**
 * Type-level representation of {@link IpInterfaceFromString}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface IpInterfaceFromString extends decodeTo<IpInterface, String> {
    readonly "Rebuild": IpInterfaceFromString;
}
/**
 * Schema for IPv4 or IPv6 interface addresses encoded as an address and prefix length.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const IpInterfaceFromString: IpInterfaceFromString;
/**
 * Type-level representation of {@link Ipv4Network}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface Ipv4Network extends declare<IpNetwork_.Ipv4Network> {
    readonly "Rebuild": Ipv4Network;
}
/**
 * Schema for already-constructed canonical IPv4 network prefixes.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const Ipv4Network: Ipv4Network;
/**
 * Type-level representation of {@link Ipv4NetworkFromString}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface Ipv4NetworkFromString extends decodeTo<Ipv4Network, String> {
    readonly "Rebuild": Ipv4NetworkFromString;
}
/**
 * Schema for canonical IPv4 network prefixes encoded in CIDR notation.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const Ipv4NetworkFromString: Ipv4NetworkFromString;
/**
 * Type-level representation of {@link Ipv6Network}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface Ipv6Network extends declare<IpNetwork_.Ipv6Network> {
    readonly "Rebuild": Ipv6Network;
}
/**
 * Schema for already-constructed canonical IPv6 network prefixes.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const Ipv6Network: Ipv6Network;
/**
 * Type-level representation of {@link Ipv6NetworkFromString}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface Ipv6NetworkFromString extends decodeTo<Ipv6Network, String> {
    readonly "Rebuild": Ipv6NetworkFromString;
}
/**
 * Schema for canonical IPv6 network prefixes encoded in CIDR notation.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const Ipv6NetworkFromString: Ipv6NetworkFromString;
/**
 * Type-level representation of {@link IpNetwork}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface IpNetwork extends declare<IpNetwork_.IpNetwork> {
    readonly "Rebuild": IpNetwork;
}
/**
 * Schema for already-constructed canonical IPv4 or IPv6 network prefixes.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const IpNetwork: IpNetwork;
/**
 * Type-level representation of {@link IpNetworkFromString}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface IpNetworkFromString extends decodeTo<IpNetwork, String> {
    readonly "Rebuild": IpNetworkFromString;
}
/**
 * Schema for canonical IPv4 or IPv6 network prefixes encoded in CIDR notation.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const IpNetworkFromString: IpNetworkFromString;
/**
 * Type-level representation of {@link InetAddressV4}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface InetAddressV4 extends declare<NetAddress_.InetAddressV4> {
    readonly "Rebuild": InetAddressV4;
}
/**
 * Schema for already-constructed resolved IPv4 internet addresses.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const InetAddressV4: InetAddressV4;
/**
 * Type-level representation of {@link InetAddressV6}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface InetAddressV6 extends declare<NetAddress_.InetAddressV6> {
    readonly "Rebuild": InetAddressV6;
}
/**
 * Schema for already-constructed resolved IPv6 internet addresses.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const InetAddressV6: InetAddressV6;
/**
 * Type-level representation of {@link InetAddress}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface InetAddress extends declare<NetAddress_.InetAddress> {
    readonly "Rebuild": InetAddress;
}
/**
 * Schema for already-constructed resolved internet addresses.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const InetAddress: InetAddress;
/**
 * Type-level representation of {@link InetAddressFromString}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface InetAddressFromString extends decodeTo<InetAddress, String> {
    readonly "Rebuild": InetAddressFromString;
}
/**
 * Schema for resolved internet addresses encoded as numeric socket strings.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const InetAddressFromString: InetAddressFromString;
/**
 * Type-level representation of {@link UnixPathAddress}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface UnixPathAddress extends declare<NetAddress_.UnixPathAddress> {
    readonly "Rebuild": UnixPathAddress;
}
/**
 * Schema for already-constructed Unix-domain filesystem addresses.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const UnixPathAddress: UnixPathAddress;
/**
 * Type-level representation of {@link UnixPathAddressFromString}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface UnixPathAddressFromString extends decodeTo<UnixPathAddress, String> {
    readonly "Rebuild": UnixPathAddressFromString;
}
/**
 * Schema for Unix-domain filesystem addresses encoded as opaque path strings.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const UnixPathAddressFromString: UnixPathAddressFromString;
/**
 * Type-level representation of {@link SocketAddress}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface SocketAddress extends declare<NetAddress_.SocketAddress> {
    readonly "Rebuild": SocketAddress;
}
/**
 * Schema for already-constructed portable concrete socket addresses.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const SocketAddress: SocketAddress;
/**
 * Type-level representation of {@link DomainName}.
 *
 * @stability experimental
 * @category models
 * @since 4.0.0
 */
export interface DomainName extends brand<String, "~effect/net/Host/DomainName"> {
    readonly "Rebuild": DomainName;
}
/**
 * Schema for normalized DNS domain names.
 *
 * **Details**
 *
 * Only names already in normalized form (lowercase ASCII, with
 * internationalized labels in `xn--` form) are accepted. Use
 * {@link DomainNameFromString} to normalize arbitrary input.
 *
 * @stability experimental
 * @category schemas
 * @since 4.0.0
 */
export declare const DomainName: DomainName;
/**
 * Type-level representation of {@link DomainNameFromString}.
 *
 * @stability experimental
 * @category models
 * @since 4.0.0
 */
export interface DomainNameFromString extends decodeTo<DomainName, String> {
    readonly "Rebuild": DomainNameFromString;
}
/**
 * Schema for DNS domain names decoded from strings, normalizing case and
 * converting internationalized names to their ASCII form.
 *
 * @stability experimental
 * @category schemas
 * @since 4.0.0
 */
export declare const DomainNameFromString: DomainNameFromString;
/**
 * Type-level representation of {@link ScopedIpv6Literal}.
 *
 * @stability experimental
 * @category models
 * @since 4.0.0
 */
export interface ScopedIpv6Literal extends brand<String, "~effect/net/NetAddress/ScopedIpv6Literal"> {
    readonly "Rebuild": ScopedIpv6Literal;
}
/**
 * Schema for canonical scoped IPv6 literals such as `fe80::1%eth0`.
 *
 * @stability experimental
 * @category schemas
 * @since 4.0.0
 */
export declare const ScopedIpv6Literal: ScopedIpv6Literal;
/**
 * Type-level representation of {@link ScopedIpv6LiteralFromString}.
 *
 * @stability experimental
 * @category models
 * @since 4.0.0
 */
export interface ScopedIpv6LiteralFromString extends decodeTo<ScopedIpv6Literal, String> {
    readonly "Rebuild": ScopedIpv6LiteralFromString;
}
/**
 * Schema for scoped IPv6 literals decoded from strings, normalizing the address
 * and numeric zones.
 *
 * @stability experimental
 * @category schemas
 * @since 4.0.0
 */
export declare const ScopedIpv6LiteralFromString: ScopedIpv6LiteralFromString;
/**
 * Type-level representation of {@link Host}.
 *
 * @stability experimental
 * @category models
 * @since 4.0.0
 */
export interface Host extends Union<readonly [IpAddress, ScopedIpv6Literal, DomainName]> {
    readonly "Rebuild": Host;
}
/**
 * Schema for hosts: numeric IP addresses, scoped IPv6 literals, or domain names.
 *
 * @stability experimental
 * @category schemas
 * @since 4.0.0
 */
export declare const Host: Host;
/**
 * Type-level representation of {@link HostFromString}.
 *
 * @stability experimental
 * @category models
 * @since 4.0.0
 */
export interface HostFromString extends Union<readonly [IpAddressFromString, ScopedIpv6LiteralFromString, DomainNameFromString]> {
    readonly "Rebuild": HostFromString;
}
/**
 * Schema for hosts decoded from strings. Numeric IP strings decode to IP
 * addresses; other strings decode to scoped IPv6 literals or domain names.
 *
 * @stability experimental
 * @category schemas
 * @since 4.0.0
 */
export declare const HostFromString: HostFromString;
/**
 * Type-level representation of {@link HostPort}.
 *
 * @stability experimental
 * @category models
 * @since 4.0.0
 */
export interface HostPort extends declare<Host_.HostPort> {
    readonly "Rebuild": HostPort;
}
/**
 * Schema for already-constructed unresolved host and port values.
 *
 * @stability experimental
 * @category schemas
 * @since 4.0.0
 */
export declare const HostPort: HostPort;
/**
 * Type-level representation of {@link HostPortFromString}.
 *
 * @stability experimental
 * @category models
 * @since 4.0.0
 */
export interface HostPortFromString extends decodeTo<HostPort, String> {
    readonly "Rebuild": HostPortFromString;
}
/**
 * Schema for unresolved endpoints encoded as `host:port` or `[IPv6]:port`
 * strings.
 *
 * @stability experimental
 * @category schemas
 * @since 4.0.0
 */
export declare const HostPortFromString: HostPortFromString;
/**
 * Type-level representation of {@link Port}.
 *
 * @stability experimental
 * @category models
 * @since 4.0.0
 */
export interface Port extends Int {
    readonly "Rebuild": Port;
}
/**
 * Schema for TCP and UDP port numbers from 0 through 65535.
 *
 * **Details**
 *
 * Port 0 is accepted because it asks the operating system to choose a port
 * when binding, and it matches the port range of `InetAddress` and `HostPort`.
 * `Config.Port` accepts only 1 through 65535.
 *
 * @stability experimental
 * @category schemas
 * @since 4.0.0
 */
export declare const Port: Port;
/**
 * Type-level representation of {@link Duration}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface Duration extends declare<Duration_.Duration> {
    readonly "Rebuild": Duration;
}
/**
 * Schema for `Duration` values.
 *
 * **Details**
 *
 * The default JSON serializer encodes `Duration` as a tagged object with the
 * duration type and value.
 *
 * **Example** (Defining a Duration schema)
 *
 * ```ts import.meta.vitest
 * import { Duration, Schema } from "effect"
 *
 * Schema.decodeUnknownSync(Schema.Duration)(Duration.seconds(5)) // => Duration.seconds(5)
 * ```
 *
 * @stability stable
 * @category schemas
 *
 * @since 3.10.0
 */
export declare const Duration: Duration;
/**
 * Type-level representation of {@link DurationFromString}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface DurationFromString extends decodeTo<Duration, String> {
    readonly "Rebuild": DurationFromString;
}
/**
 * Schema that parses a string into a `Duration`.
 *
 * **Details**
 *
 * Decoding:
 * - A `string` is decoded as a `Duration`, accepting any format that
 *   `Duration.fromInput` can parse.
 *
 * Encoding:
 * - A `Duration` is encoded as a parseable `string`.
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare const DurationFromString: DurationFromString;
/**
 * Type-level representation of {@link DurationFromNanos}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface DurationFromNanos extends decodeTo<Duration, BigInt> {
    readonly "Rebuild": DurationFromNanos;
}
/**
 * Schema that decodes a `bigint` into a `Duration`, treating the bigint as
 * nanoseconds.
 *
 * **Details**
 *
 * Decoding:
 * A `bigint` representing nanoseconds is decoded as a `Duration`.
 *
 * Encoding:
 * Finite durations are encoded as a `bigint` number of nanoseconds. Encoding
 * fails when the duration cannot be represented as nanoseconds, such as
 * `Duration.infinity` or `Duration.negativeInfinity`.
 *
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare const DurationFromNanos: DurationFromNanos;
/**
 * Type-level representation of {@link DurationFromMillis}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface DurationFromMillis extends decodeTo<Duration, Number> {
    readonly "Rebuild": DurationFromMillis;
}
/**
 * Schema that decodes a number into a `Duration`, treating the number as
 * milliseconds.
 *
 * **Details**
 *
 * Decoding:
 * - A finite or infinite number is decoded as a `Duration`
 *
 * Encoding:
 * - A `Duration` is encoded to a finite or infinite number of milliseconds
 *
 * **Gotchas**
 *
 * `NaN` is decoded as `Duration.zero`, matching `Duration.millis`.
 *
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare const DurationFromMillis: DurationFromMillis;
/**
 * Type-level representation of {@link DnsRecordType}.
 *
 * @stability experimental
 * @category models
 * @since 4.0.0
 */
export interface DnsRecordType extends Literals<ReadonlyArray<Dns_.RecordType>> {
}
/**
 * Schema for supported DNS record types such as `"A"` or `"SRV"`.
 *
 * @stability experimental
 * @category schemas
 * @since 4.0.0
 */
export declare const DnsRecordType: DnsRecordType;
/**
 * Type-level representation of {@link DnsARecord}.
 *
 * @stability experimental
 * @category models
 * @since 4.0.0
 */
export interface DnsARecord extends declare<Dns_.A> {
    readonly "Rebuild": DnsARecord;
}
/**
 * Schema for already-constructed IPv4 address (`A`) DNS records.
 *
 * @stability experimental
 * @category schemas
 * @since 4.0.0
 */
export declare const DnsARecord: DnsARecord;
/**
 * Type-level representation of {@link DnsAaaaRecord}.
 *
 * @stability experimental
 * @category models
 * @since 4.0.0
 */
export interface DnsAaaaRecord extends declare<Dns_.Aaaa> {
    readonly "Rebuild": DnsAaaaRecord;
}
/**
 * Schema for already-constructed IPv6 address (`AAAA`) DNS records.
 *
 * @stability experimental
 * @category schemas
 * @since 4.0.0
 */
export declare const DnsAaaaRecord: DnsAaaaRecord;
/**
 * Type-level representation of {@link DnsCaaRecord}.
 *
 * @stability experimental
 * @category models
 * @since 4.0.0
 */
export interface DnsCaaRecord extends declare<Dns_.Caa> {
    readonly "Rebuild": DnsCaaRecord;
}
/**
 * Schema for already-constructed certification authority authorization (`CAA`) DNS records.
 *
 * @stability experimental
 * @category schemas
 * @since 4.0.0
 */
export declare const DnsCaaRecord: DnsCaaRecord;
/**
 * Type-level representation of {@link DnsCnameRecord}.
 *
 * @stability experimental
 * @category models
 * @since 4.0.0
 */
export interface DnsCnameRecord extends declare<Dns_.Cname> {
    readonly "Rebuild": DnsCnameRecord;
}
/**
 * Schema for already-constructed canonical name (`CNAME`) DNS records.
 *
 * @stability experimental
 * @category schemas
 * @since 4.0.0
 */
export declare const DnsCnameRecord: DnsCnameRecord;
/**
 * Type-level representation of {@link DnsMxRecord}.
 *
 * @stability experimental
 * @category models
 * @since 4.0.0
 */
export interface DnsMxRecord extends declare<Dns_.Mx> {
    readonly "Rebuild": DnsMxRecord;
}
/**
 * Schema for already-constructed mail exchange (`MX`) DNS records.
 *
 * @stability experimental
 * @category schemas
 * @since 4.0.0
 */
export declare const DnsMxRecord: DnsMxRecord;
/**
 * Type-level representation of {@link DnsNaptrRecord}.
 *
 * @stability experimental
 * @category models
 * @since 4.0.0
 */
export interface DnsNaptrRecord extends declare<Dns_.Naptr> {
    readonly "Rebuild": DnsNaptrRecord;
}
/**
 * Schema for already-constructed naming authority pointer (`NAPTR`) DNS records.
 *
 * @stability experimental
 * @category schemas
 * @since 4.0.0
 */
export declare const DnsNaptrRecord: DnsNaptrRecord;
/**
 * Type-level representation of {@link DnsNsRecord}.
 *
 * @stability experimental
 * @category models
 * @since 4.0.0
 */
export interface DnsNsRecord extends declare<Dns_.Ns> {
    readonly "Rebuild": DnsNsRecord;
}
/**
 * Schema for already-constructed name server (`NS`) DNS records.
 *
 * @stability experimental
 * @category schemas
 * @since 4.0.0
 */
export declare const DnsNsRecord: DnsNsRecord;
/**
 * Type-level representation of {@link DnsPtrRecord}.
 *
 * @stability experimental
 * @category models
 * @since 4.0.0
 */
export interface DnsPtrRecord extends declare<Dns_.Ptr> {
    readonly "Rebuild": DnsPtrRecord;
}
/**
 * Schema for already-constructed pointer (`PTR`) DNS records.
 *
 * @stability experimental
 * @category schemas
 * @since 4.0.0
 */
export declare const DnsPtrRecord: DnsPtrRecord;
/**
 * Type-level representation of {@link DnsSoaRecord}.
 *
 * @stability experimental
 * @category models
 * @since 4.0.0
 */
export interface DnsSoaRecord extends declare<Dns_.Soa> {
    readonly "Rebuild": DnsSoaRecord;
}
/**
 * Schema for already-constructed start of authority (`SOA`) DNS records.
 *
 * @stability experimental
 * @category schemas
 * @since 4.0.0
 */
export declare const DnsSoaRecord: DnsSoaRecord;
/**
 * Type-level representation of {@link DnsSrvRecord}.
 *
 * @stability experimental
 * @category models
 * @since 4.0.0
 */
export interface DnsSrvRecord extends declare<Dns_.Srv> {
    readonly "Rebuild": DnsSrvRecord;
}
/**
 * Schema for already-constructed service locator (`SRV`) DNS records.
 *
 * @stability experimental
 * @category schemas
 * @since 4.0.0
 */
export declare const DnsSrvRecord: DnsSrvRecord;
/**
 * Type-level representation of {@link DnsTlsaRecord}.
 *
 * @stability experimental
 * @category models
 * @since 4.0.0
 */
export interface DnsTlsaRecord extends declare<Dns_.Tlsa> {
    readonly "Rebuild": DnsTlsaRecord;
}
/**
 * Schema for already-constructed TLS authentication (`TLSA`) DNS records.
 *
 * **Details**
 *
 * The default JSON serializer encodes the certificate association `data` as a
 * hex string.
 *
 * @stability experimental
 * @category schemas
 * @since 4.0.0
 */
export declare const DnsTlsaRecord: DnsTlsaRecord;
/**
 * Type-level representation of {@link DnsTxtRecord}.
 *
 * @stability experimental
 * @category models
 * @since 4.0.0
 */
export interface DnsTxtRecord extends declare<Dns_.Txt> {
    readonly "Rebuild": DnsTxtRecord;
}
/**
 * Schema for already-constructed text (`TXT`) DNS records.
 *
 * @stability experimental
 * @category schemas
 * @since 4.0.0
 */
export declare const DnsTxtRecord: DnsTxtRecord;
/**
 * Type-level representation of {@link DnsRecord}.
 *
 * @stability experimental
 * @category models
 * @since 4.0.0
 */
export interface DnsRecord extends Union<readonly [
    DnsARecord,
    DnsAaaaRecord,
    DnsCaaRecord,
    DnsCnameRecord,
    DnsMxRecord,
    DnsNaptrRecord,
    DnsNsRecord,
    DnsPtrRecord,
    DnsSoaRecord,
    DnsSrvRecord,
    DnsTlsaRecord,
    DnsTxtRecord
]> {
    readonly "Rebuild": DnsRecord;
}
/**
 * Schema for already-constructed DNS records of any supported record type.
 *
 * **Details**
 *
 * The default JSON serializer encodes records as objects tagged by record type,
 * with addresses and names as canonical strings, SOA timers as whole seconds,
 * and TLSA data as hex, such as
 * `{ "_tag": "SRV", "target": "db.internal", "port": 5432, "priority": 10, "weight": 5 }`.
 * Decoding accepts only canonical addresses and normalized domain names, and
 * reports invalid fields with their path.
 *
 * @stability experimental
 * @category schemas
 * @since 4.0.0
 */
export declare const DnsRecord: DnsRecord;
/**
 * Type-level representation returned by {@link Exit}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface Exit<A extends Constraint, E extends Constraint, D extends Constraint> extends declareConstructor<Exit_.Exit<A["Type"], E["Type"]>, Exit_.Exit<A["Encoded"], E["Encoded"]>, readonly [A, E, D], ExitIso<A, E, D>> {
    readonly "Rebuild": Exit<A, E, D>;
    readonly value: A;
    readonly error: E;
    readonly defect: D;
}
/**
 * Iso representation used for `Exit` schemas.
 *
 * **Details**
 *
 * Successful exits are represented as `{ _tag: "Success", value }`, while failed
 * exits are represented as `{ _tag: "Failure", cause }`.
 *
 * @stability stable
 * @category utility types
 * @since 4.0.0
 */
export type ExitIso<A extends Constraint, E extends Constraint, D extends Constraint> = {
    readonly _tag: "Success";
    readonly value: A["Iso"];
} | {
    readonly _tag: "Failure";
    readonly cause: CauseIso<E, D>;
};
/**
 * Creates a schema for `Exit` values using schemas for the success value, typed
 * failure, and unexpected defect channels.
 *
 * **When to use**
 *
 * Use when serializing or validating an effect outcome where success, typed
 * failure, and defects each need their own schema.
 *
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare function Exit<A extends Constraint, E extends Constraint, D extends Constraint>(value: A, error: E, defect: D): Exit<A, E, D>;
/**
 * Encoded representation of an immutable Effect graph.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export type EncodedGraph<N, E, T extends Graph_.Kind> = Graph_.Snapshot<N, E, T>;
/**
 * Iso representation used for {@link Graph} schemas.
 *
 * @stability unstable
 * @category utility types
 * @since 4.0.0
 */
export type GraphIso<T extends Graph_.Kind, Node extends Constraint, Edge extends Constraint> = EncodedGraph<Node["Iso"], Edge["Iso"], T>;
/**
 * Type-level representation returned by {@link Graph}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface Graph<T extends Graph_.Kind, Node extends Constraint, Edge extends Constraint> extends declareConstructor<Graph_.Graph<Node["Type"], Edge["Type"], T>, Graph_.Graph<Node["Encoded"], Edge["Encoded"], T>, readonly [Node, Edge], GraphIso<T, Node, Edge>> {
    readonly "Rebuild": Graph<T, Node, Edge>;
    readonly type: T;
    readonly node: Node;
    readonly edge: Edge;
}
/**
 * Creates a schema for immutable directed or undirected Effect graphs.
 *
 * **Details**
 *
 * Encoding preserves active node and edge indexes, payloads, endpoints,
 * isolated nodes, self-loops, parallel edges, and stored edge orientation. It
 * does not encode removed-ID allocator history; after decoding, future allocation starts
 * after the highest active decoded index. Encoding rejects mutable graphs.
 * `Graph.toJSON()` remains an inspection summary and is not this wire format.
 *
 * **Example** (Encoding a directed graph as JSON)
 *
 * ```ts import.meta.vitest
 * import { Graph, Schema } from "effect"
 *
 * const codec = Schema.toCodecJson(Schema.Graph("directed", Schema.String, Schema.Number))
 * const graph = Graph.directed<string, number>((mutable) => {
 *   const source = Graph.addNode(mutable, "A")
 *   const target = Graph.addNode(mutable, "B")
 *   Graph.addEdge(mutable, source, target, 1)
 * })
 *
 * const encoded = Schema.encodeSync(codec)(graph)
 *
 * encoded.type // => "directed"
 * encoded.nodes // => [{ index: 0, data: "A" }, { index: 1, data: "B" }]
 * encoded.edges // => [{ index: 0, source: 0, target: 1, data: 1 }]
 * ```
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare function Graph<Node extends Constraint, Edge extends Constraint>(type: "directed", node: Node, edge: Edge): Graph<"directed", Node, Edge>;
export declare function Graph<Node extends Constraint, Edge extends Constraint>(type: "undirected", node: Node, edge: Edge): Graph<"undirected", Node, Edge>;
export declare function Graph<T extends Graph_.Kind, Node extends Constraint, Edge extends Constraint>(type: T, node: Node, edge: Edge): Graph<T, Node, Edge>;
/**
 * Type-level representation returned by {@link HashMap}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface HashMap<Key extends Constraint, Value extends Constraint> extends declareConstructor<HashMap_.HashMap<Key["Type"], Value["Type"]>, HashMap_.HashMap<Key["Encoded"], Value["Encoded"]>, readonly [Key, Value], HashMapIso<Key, Value>> {
    readonly "Rebuild": HashMap<Key, Value>;
    readonly key: Key;
    readonly value: Value;
}
/**
 * Iso representation used for `HashMap` schemas: an array of readonly
 * `[key, value]` tuples using each entry schema's `Iso` type.
 *
 * @stability stable
 * @category utility types
 * @since 4.0.0
 */
export type HashMapIso<Key extends Constraint, Value extends Constraint> = ReadonlyArray<readonly [Key["Iso"], Value["Iso"]]>;
/**
 * Schema for hash maps whose keys and values conform to the provided schemas.
 *
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare function HashMap<Key extends Constraint, Value extends Constraint>(key: Key, value: Value): HashMap<Key, Value>;
/**
 * Type-level representation returned by {@link HashSet}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface HashSet<Value extends Constraint> extends declareConstructor<HashSet_.HashSet<Value["Type"]>, HashSet_.HashSet<Value["Encoded"]>, readonly [Value], HashSetIso<Value>> {
    readonly "Rebuild": HashSet<Value>;
    readonly value: Value;
}
/**
 * Iso representation used for `HashSet` schemas: an array of element values
 * using the element schema's `Iso` type.
 *
 * @stability stable
 * @category utility types
 * @since 4.0.0
 */
export type HashSetIso<Value extends Constraint> = ReadonlyArray<Value["Iso"]>;
/**
 * Schema for hash sets whose values conform to the provided element schema.
 *
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare function HashSet<Value extends Constraint>(value: Value): HashSet<Value>;
/**
 * Type-level representation returned by {@link Option}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface Option<A extends Constraint> extends declareConstructor<Option_.Option<A["Type"]>, Option_.Option<A["Encoded"]>, readonly [A], OptionIso<A>> {
    readonly "Rebuild": Option<A>;
    readonly value: A;
}
/**
 * Iso representation used for `Option` schemas.
 *
 * **Details**
 *
 * `None` is represented as `{ _tag: "None" }`, while `Some` is represented as
 * `{ _tag: "Some", value }` using the wrapped schema's `Iso` type.
 *
 * @stability stable
 * @category utility types
 * @since 4.0.0
 */
export type OptionIso<A extends Constraint> = {
    readonly _tag: "None";
} | {
    readonly _tag: "Some";
    readonly value: A["Iso"];
};
/**
 * Schema for `Option<A>` values.
 *
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare function Option<A extends Constraint>(value: A): Option<A>;
/**
 * Type-level representation returned by {@link OptionFromNullOr}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface OptionFromNullOr<S extends Constraint> extends decodeTo<Option<toType<S>>, NullOr<S>> {
    readonly "Rebuild": OptionFromNullOr<S>;
}
/**
 * Decodes a nullable, required value `T` to a required `Option<T>` value.
 *
 * **Details**
 *
 * Decoding maps `null` to `None` and all other values to `Some`. Encoding maps
 * `None` to `null` and maps `Some` to its value.
 *
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare function OptionFromNullOr<S extends Constraint>(schema: S): OptionFromNullOr<S>;
/**
 * Type-level representation returned by {@link OptionFromUndefinedOr}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface OptionFromUndefinedOr<S extends Constraint> extends decodeTo<Option<toType<S>>, UndefinedOr<S>> {
    readonly "Rebuild": OptionFromUndefinedOr<S>;
}
/**
 * Decodes a required value that may be `undefined` to a required `Option<T>`
 * value.
 *
 * **Details**
 *
 * Decoding maps `undefined` to `None` and all other values to `Some`. Encoding
 * maps `None` to `undefined` and maps `Some` to its value.
 *
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare function OptionFromUndefinedOr<S extends Constraint>(schema: S): OptionFromUndefinedOr<S>;
/**
 * Type-level representation returned by {@link OptionFromNullishOr}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface OptionFromNullishOr<S extends Constraint> extends decodeTo<Option<toType<S>>, NullishOr<S>> {
    readonly "Rebuild": OptionFromNullishOr<S>;
}
/**
 * Decodes a nullish value `T` to a required `Option<T>` value.
 *
 * **Details**
 *
 * Decoding maps `null` and `undefined` to `None` and all other values to
 * `Some`. Encoding maps `None` to `null` or `undefined` depending on
 * `options.onNoneEncoding`, which defaults to `undefined`, and maps `Some` to
 * its value.
 *
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare function OptionFromNullishOr<S extends Constraint>(schema: S, options?: {
    onNoneEncoding: null | undefined;
}): OptionFromNullishOr<S>;
/**
 * Type-level representation of {@link Cookie}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface Cookie extends declare<Cookies_.Cookie> {
    readonly "Rebuild": Cookie;
}
/**
 * Schema for HTTP cookie values.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const Cookie: Cookie;
/**
 * Type-level representation of {@link Cookies}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface Cookies extends declare<Cookies_.Cookies, Record_.ReadonlyRecord<string, Cookies_.Cookie>> {
    readonly "Rebuild": Cookies;
}
/**
 * Schema for HTTP cookie collections.
 *
 * **Details**
 *
 * JSON encoding uses `Set-Cookie` header strings, while isomorphic encoding uses
 * a readonly record of cookie values.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const Cookies: Cookies;
/**
 * Type-level representation of {@link RecordFromCookies}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface RecordFromCookies extends decodeTo<$Record<String, String>, Cookies> {
    readonly "Rebuild": RecordFromCookies;
}
/**
 * Schema that decodes HTTP cookies into a record of decoded string values keyed
 * by cookie name.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const RecordFromCookies: RecordFromCookies;
/**
 * Type-level representation of {@link Headers}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface Headers extends declare<Headers_.Headers, {
    readonly [x: string]: string;
}> {
    readonly "Rebuild": Headers;
}
/**
 * Schema for HTTP headers encoded as records of string values.
 *
 * **Details**
 *
 * Decoding normalizes header names; encoding returns a plain record.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const Headers: Headers;
/**
 * Type-level representation of {@link RetryAfter}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface RetryAfter extends Union<readonly [
    Struct<{
        readonly _tag: tag<"Duration">;
        readonly duration: Duration;
    }>,
    Struct<{
        readonly _tag: tag<"DateTime">;
        readonly dateTime: DateTimeUtc;
    }>
]> {
    readonly "Rebuild": RetryAfter;
}
/**
 * Schema for parsed `Retry-After` header values.
 *
 * **Details**
 *
 * Matches `Headers.RetryAfter`: either `{ _tag: "Duration", duration }` or
 * `{ _tag: "DateTime", dateTime }`. The duration must be finite and
 * non-negative. Use {@link RetryAfterFromString} for the header string form.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const RetryAfter: RetryAfter;
/**
 * Type-level representation of {@link RetryAfterFromString}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface RetryAfterFromString extends decodeTo<RetryAfter, String> {
    readonly "Rebuild": RetryAfterFromString;
}
/**
 * Schema for `Retry-After` header values, decoded with
 * `Headers.parseRetryAfter`.
 *
 * **When to use**
 *
 * Use with HTTP API header schemas that carry `Retry-After`. Decoding accepts
 * whole non-negative seconds or an HTTP date and rejects anything else;
 * encoding emits the delay as whole seconds, rounding a fractional second up,
 * or the date as an IMF-fixdate.
 *
 * **Example** (Decoding a Retry-After header)
 *
 * ```ts
 * import { Schema } from "effect"
 *
 * const value = Schema.decodeSync(Schema.RetryAfterFromString)("120")
 * // => { _tag: "Duration", duration: Duration.seconds(120) }
 * ```
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const RetryAfterFromString: RetryAfterFromString;
/**
 * Type-level representation of {@link UrlParams}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface UrlParams extends declare<UrlParams_.UrlParams, ReadonlyArray<readonly [string, string]>> {
    readonly "Rebuild": UrlParams;
}
/**
 * Schema for HTTP URL parameters.
 *
 * **Details**
 *
 * The encoded representation is an array of string key-value tuples.
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const UrlParams: UrlParams;
/**
 * Type-level representation of {@link JsonFromUrlParamsField}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface JsonFromUrlParamsField extends decodeTo<fromJsonString<Unknown>, UrlParams> {
    readonly "Rebuild": JsonFromUrlParamsField;
}
/**
 * Extracts a JSON value from the first occurrence of the given `field` in URL
 * parameters.
 *
 * **Example** (Decoding a JSON parameter field)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 * import { UrlParams } from "effect/http"
 *
 * const extractFoo = Schema.JsonFromUrlParamsField("foo").pipe(
 *   Schema.decodeTo(Schema.Struct({
 *     some: Schema.String,
 *     number: Schema.Number
 *   }))
 * )
 *
 * const decoded = Schema.decodeSync(extractFoo)(UrlParams.fromInput({
 *   foo: `{"some":"bar","number":42}`,
 *   baz: "qux"
 * }))
 * const result = [decoded.some, decoded.number] // => ["bar", 42]
 * ```
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const JsonFromUrlParamsField: (field: string, options?: {
    readonly reviver?: Parameters<typeof JSON.parse>[1] | undefined;
} | undefined) => JsonFromUrlParamsField;
/**
 * Type-level representation of {@link RecordFromUrlParams}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.0
 */
export interface RecordFromUrlParams extends decodeTo<$Record<String, Union<readonly [String, NonEmptyArray<String>]>>, UrlParams, never, never> {
    readonly "Rebuild": RecordFromUrlParams;
}
/**
 * Schema that decodes URL parameters into a record of string values.
 *
 * **Details**
 *
 * Keys with one value decode to a string, and keys with multiple values decode to
 * a non-empty readonly array of strings.
 *
 * **Example** (Decoding URL parameters to a record)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 * import { UrlParams } from "effect/http"
 *
 * const toStruct = Schema.RecordFromUrlParams.pipe(
 *   Schema.decodeTo(Schema.Struct({
 *     some: Schema.String,
 *     number: Schema.FiniteFromString
 *   }))
 * )
 *
 * const decoded = Schema.decodeSync(toStruct)(UrlParams.fromInput({
 *   some: "value",
 *   number: 42
 * }))
 * const result = [decoded.some, decoded.number] // => ["value", 42]
 * ```
 *
 * @stability unstable
 * @category schemas
 * @since 4.0.0
 */
export declare const RecordFromUrlParams: RecordFromUrlParams;
/**
 * Type-level representation returned by {@link OptionFromOptionalKey}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface OptionFromOptionalKey<S extends Constraint> extends decodeTo<Option<toType<S>>, optionalKey<S>> {
    readonly "Rebuild": OptionFromOptionalKey<S>;
}
/**
 * Decodes an optional value `A` to a required `Option<A>` value.
 *
 * **Details**
 *
 * Decoding maps a missing key to `None` and a present value to `Some`.
 * Encoding maps `None` to a missing key and maps `Some` to its value.
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare function OptionFromOptionalKey<S extends Constraint>(schema: S): OptionFromOptionalKey<S>;
/**
 * Type-level representation returned by {@link OptionFromOptional}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface OptionFromOptional<S extends Constraint> extends decodeTo<Option<toType<S>>, optional<S>> {
    readonly "Rebuild": OptionFromOptional<S>;
}
/**
 * Decodes an optional or `undefined` value `A` to a required `Option<A>`
 * value.
 *
 * **Details**
 *
 * Decoding maps a missing key or a present `undefined` value to `None`, and
 * maps all other values to `Some`. Encoding maps `None` to a missing key and
 * maps `Some` to its value.
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare function OptionFromOptional<S extends Constraint>(schema: S): OptionFromOptional<S>;
/**
 * Type-level representation returned by {@link OptionFromOptionalNullOr}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface OptionFromOptionalNullOr<S extends Constraint> extends decodeTo<Option<toType<S>>, optional<NullOr<S>>> {
    readonly "Rebuild": OptionFromOptionalNullOr<S>;
}
/**
 * Decodes an optional or `null` or `undefined` value `A` to a required `Option<A>`
 * value.
 *
 * **Details**
 *
 * Decoding maps a missing key, `undefined`, or `null` to `None`, and maps all
 * other values to `Some`. Encoding maps `Some` to its value. `None` is encoded
 * according to `options.onNoneEncoding`: `"omit"` encodes a missing key,
 * `null` encodes `null`, and `undefined` encodes `undefined`.
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare function OptionFromOptionalNullOr<S extends Constraint>(schema: S, options?: {
    readonly onNoneEncoding: "omit" | null | undefined;
}): OptionFromOptionalNullOr<S>;
/**
 * Type-level representation returned by {@link Redacted}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface Redacted<S extends Constraint> extends declareConstructor<Redacted_.Redacted<S["Type"]>, Redacted_.Redacted<S["Encoded"]>, readonly [S]> {
    readonly "Rebuild": Redacted<S>;
    readonly value: S;
}
/**
 * Schema for `Redacted` values, which hide their contents from inspection.
 *
 * **Details**
 *
 * Options:
 *
 * - `label`: When provided, the schema will behave as follows:
 *   - Values will be validated against the label in addition to the wrapped schema
 *   - The default JSON serializer will deserialize into a `Redacted` instance with the label
 *   - The arbitrary generator will produce a `Redacted` instance with the label
 *   - The formatter will return the label
 * - `disallowJsonEncode`: When set to `true`, when attempting to encode a `Redacted` instance
 *   into JSON, it will fail with an error. This is useful when the wrapped schema is
 *   sensitive and should not be exposed in JSON.
 *
 * @see {@link RedactedFromValue} for decoding raw values and wrapping them in `Redacted`.
 * @stability stable
 * @category schemas
 * @since 3.10.0
 */
export declare function Redacted<S extends Constraint>(value: S, options?: {
    readonly label?: string | undefined;
    readonly disallowJsonEncode?: boolean | undefined;
}): Redacted<S>;
/**
 * Type-level representation returned by {@link RedactedFromValue}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface RedactedFromValue<S extends Constraint> extends decodeTo<Redacted<toType<S>>, S> {
    readonly "Rebuild": RedactedFromValue<S>;
}
/**
 * Decodes a value and wraps it in `Redacted<A>`. Unlike {@link Redacted} which
 * expects the input to already be a `Redacted` instance, this schema decodes
 * the raw value and wraps it.
 *
 * @see {@link Redacted} for schemas whose input is already a `Redacted` value.
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare function RedactedFromValue<S extends Constraint>(value: S, options?: {
    readonly label?: string | undefined;
    readonly disallowEncode?: boolean | undefined;
}): RedactedFromValue<S>;
/**
 * Type-level representation returned by {@link Result}.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface Result<A extends Constraint, E extends Constraint> extends declareConstructor<Result_.Result<A["Type"], E["Type"]>, Result_.Result<A["Encoded"], E["Encoded"]>, readonly [A, E], ResultIso<A, E>> {
    readonly "Rebuild": Result<A, E>;
    readonly success: A;
    readonly failure: E;
}
/**
 * Iso representation used for `Result` schemas.
 *
 * **Details**
 *
 * Successful results are represented as `{ _tag: "Success", success }`, while
 * failed results are represented as `{ _tag: "Failure", failure }`.
 *
 * @stability stable
 * @category utility types
 * @since 4.0.0
 */
export type ResultIso<A extends Constraint, E extends Constraint> = {
    readonly _tag: "Success";
    readonly success: A["Iso"];
} | {
    readonly _tag: "Failure";
    readonly failure: E["Iso"];
};
/**
 * Schema for `Result<A, E>` values.
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare function Result<A extends Constraint, E extends Constraint>(success: A, failure: E): Result<A, E>;
/**
 * Type-level representation of {@link SemVer}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.6
 */
export interface SemVer extends declare<SemVer_.SemVer> {
    readonly "Rebuild": SemVer;
}
/**
 * Schema for `SemVer` values.
 *
 * **Details**
 *
 * The JSON and StringTree codecs encode a version as its canonical string,
 * including build metadata.
 *
 * @see {@link SemVerFromString} for parsing version strings
 * @stability unstable
 * @category schemas
 * @since 4.0.6
 */
export declare const SemVer: SemVer;
/**
 * Type-level representation of {@link SemVerFromString}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.6
 */
export interface SemVerFromString extends decodeTo<SemVer, String> {
    readonly "Rebuild": SemVerFromString;
}
/**
 * Schema that parses a Semantic Versioning 2.0.0 string into a `SemVer`.
 *
 * **Details**
 *
 * Decodes with `SemVer.parse`, rejecting a `v` prefix, surrounding whitespace,
 * partial versions, and leading zeros. Encodes with `SemVer.format`, including
 * build metadata.
 *
 * @see {@link SemVer} for validating values that are already SemVer values
 * @stability unstable
 * @category schemas
 * @since 4.0.6
 */
export declare const SemVerFromString: SemVerFromString;
/**
 * Type-level representation of {@link SemVerRange}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.6
 */
export interface SemVerRange extends declare<SemVerRange_.SemVerRange> {
    readonly "Rebuild": SemVerRange;
}
/**
 * Schema for `SemVerRange` values.
 *
 * **Details**
 *
 * The JSON and StringTree codecs encode a range with `SemVerRange.format`.
 *
 * @see {@link SemVerRangeFromString} for parsing range strings
 * @stability unstable
 * @category schemas
 * @since 4.0.6
 */
export declare const SemVerRange: SemVerRange;
/**
 * Type-level representation of {@link SemVerRangeFromString}.
 *
 * @stability unstable
 * @category models
 * @since 4.0.6
 */
export interface SemVerRangeFromString extends decodeTo<SemVerRange, String> {
    readonly "Rebuild": SemVerRangeFromString;
}
/**
 * Schema that parses an npm-style version range string into a `SemVerRange`.
 *
 * **Details**
 *
 * Decodes with `SemVerRange.parse` and encodes with `SemVerRange.format`,
 * preserving parsed operators and normalizing wildcard spellings.
 *
 * @see {@link SemVerRange} for validating values that are already ranges
 * @stability unstable
 * @category schemas
 * @since 4.0.6
 */
export declare const SemVerRangeFromString: SemVerRangeFromString;
/**
 * Type-level representation returned by {@link Class}.
 *
 * @stability stable
 * @category models
 * @since 3.10.0
 */
export interface Class<Self, S extends Constraint & {
    readonly fields: Struct.Fields;
}, Inherited> extends BottomLazyWithoutNew<SchemaAST.Declaration, decodeTo<declareConstructor<Self, S["Encoded"], readonly [S], S["Iso"]>, S>, readonly [S], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
    /**
     * `make`, `makeOption`, and `makeEffect` preserve an existing instance of
     * this class. Use `new` when a distinct instance is required.
     */
    readonly "Type": Self;
    readonly "Encoded": S["Encoded"];
    readonly "DecodingServices": S["DecodingServices"];
    readonly "EncodingServices": S["EncodingServices"];
    readonly "~type.make.in": RequiredKeys<S["~type.make.in"]> extends never ? void | S["~type.make.in"] : S["~type.make.in"];
    readonly "~type.make": Self;
    readonly "Iso": S["Iso"];
    new (...args: {} extends S["~type.make.in"] ? [props?: S["~type.make.in"], options?: MakeOptions] : [props: S["~type.make.in"], options?: MakeOptions]): S["Type"] & Inherited;
    readonly identifier: string;
    readonly fields: S["fields"];
    /**
     * Returns a new struct with the fields modified by the provided function.
     *
     * **Details**
     *
     * Options:
     *
     * - `unsafePreserveChecks` - if `true`, keep any `.check(...)` constraints
     *   that were attached to the original struct. Defaults to `false`.
     *
     *   **Warning**: This is an unsafe operation. Since `mapFields`
     *   transformations change the schema type, the original refinement functions
     *   may no longer be valid or safe to apply to the transformed schema. Only
     *   use this option if you have verified that your refinements remain correct
     *   after the transformation.
     */
    mapFields<To extends Struct.Fields>(f: (fields: S["fields"]) => To, options?: {
        readonly unsafePreserveChecks?: boolean | undefined;
    } | undefined): Struct<Simplify<Readonly<To>>>;
    /**
     * Returns a function that creates a schema-backed subclass with this class's
     * fields plus additional fields.
     *
     * **When to use**
     *
     * Use when you need a subclass whose constructor validates both inherited
     * fields and newly added fields.
     *
     * **Details**
     *
     * The returned function accepts either a field map or a `Struct`. When you
     * pass a `Struct`, checks attached to that extension schema are preserved and
     * combined with checks from the base class schema.
     *
     * **Gotchas**
     *
     * Fields with the same name replace inherited fields. Use this to refine
     * validation or change encoding. Effect does not check compatibility; the
     * caller must ensure the replacement preserves the base class contract.
     *
     * Checks from a `Struct` argument are evaluated against the full subclass
     * value after inherited and extension fields are merged. Object-wide checks
     * such as `isMaxProperties` count inherited fields too.
     */
    extend<Extended = never, Static = {}, Brand = {}>(identifier: string): {
        <NewFields extends Struct.Fields>(fields: NewFields, annotations?: Annotations.Declaration<Extended, readonly [Struct<Simplify<Assign<S["fields"], NewFields>>>]>): [Extended] extends [never] ? MissingSelfGeneric<"Base.extend"> : InheritStaticMembers<Class<Extended, Struct<Simplify<Assign<S["fields"], NewFields>>>, Self & Brand>, Static>;
        <Extension extends Struct<Struct.Fields>>(schema: Extension, annotations?: Annotations.Declaration<Extended, readonly [Struct<Simplify<Assign<S["fields"], Extension["fields"]>>>]>): [Extended] extends [never] ? MissingSelfGeneric<"Base.extend"> : InheritStaticMembers<Class<Extended, Struct<Simplify<Assign<S["fields"], Extension["fields"]>>>, Self & Brand>, Static>;
    };
}
type InheritStaticMembers<C, Static> = C & Pick<Static, Exclude<keyof Static, keyof C>>;
type MissingSelfGeneric<Usage extends string> = `Missing \`Self\` generic - use \`class Self extends ${Usage}<Self>(...)\``;
/**
 * Creates a schema-backed class whose constructor validates input against a
 * {@link Struct} schema. Construction throws an `Error` with a
 * `SchemaIssue.Issue` in its `cause` on invalid input.
 *
 * **When to use**
 *
 * Use when you need a schema-backed data class with validated construction,
 * schema-derived decoding/encoding, and class-style methods or inheritance.
 *
 * **Details**
 *
 * Pass the desired class type as the first type parameter. The second optional
 * type parameter can be used to add nominal brands.
 *
 * The `identifier` is the schema's stable runtime name. It is exposed on the
 * class, stored in the schema AST, and used to label diagnostics and generated
 * references as well as to format class instances.
 *
 * It also derives a runtime marker that recognizes instances across hot module
 * reloads, where `instanceof` can fail because the constructor has been
 * replaced. The identifier is explicit because the outer JavaScript class name
 * is not available while the `extends` expression is evaluated and may change
 * through renaming or minification.
 *
 * **Gotchas**
 *
 * Passing `disableChecks: true` skips filters and checks, not parsing of types
 * and structure. Wrong types and shapes are still rejected, and constructor
 * defaults still apply.
 *
 * **Example** (Defining a basic class)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * class Person extends Schema.Class<Person>("Person")({
 *   name: Schema.String,
 *   age: Schema.Number
 * }) {}
 *
 * const alice = new Person({ name: "Alice", age: 30 })
 * alice.name // => "Alice"
 * String(alice) // => "Person({\"name\":\"Alice\",\"age\":30})"
 * ```
 *
 * **Example** (Extending a class)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * class Animal extends Schema.Class<Animal>("Animal")({
 *   name: Schema.String
 * }) {}
 *
 * class Dog extends Animal.extend<Dog>("Dog")({
 *   breed: Schema.String
 * }) {}
 *
 * const dog = new Dog({ name: "Rex", breed: "Labrador" })
 * dog.name // => "Rex"
 * dog.breed // => "Labrador"
 * ```
 *
 * @see {@link TaggedClass} for adding a `_tag` literal field to the class schema
 * @see {@link Error} for defining schema-backed error classes
 * @see {@link TaggedError} for defining tagged schema-backed error classes
 *
 * @stability stable
 * @category constructors
 * @since 3.10.0
 */
export declare const Class: {
    /**
     * Creates a schema-backed class whose constructor validates input against a
     * {@link Struct} schema. Construction throws an `Error` with a
     * `SchemaIssue.Issue` in its `cause` on invalid input.
     *
     * **When to use**
     *
     * Use when you need a schema-backed data class with validated construction,
     * schema-derived decoding/encoding, and class-style methods or inheritance.
     *
     * **Details**
     *
     * Pass the desired class type as the first type parameter. The second optional
     * type parameter can be used to add nominal brands.
     *
     * The `identifier` is the schema's stable runtime name. It is exposed on the
     * class, stored in the schema AST, and used to label diagnostics and generated
     * references as well as to format class instances.
     *
     * It also derives a runtime marker that recognizes instances across hot module
     * reloads, where `instanceof` can fail because the constructor has been
     * replaced. The identifier is explicit because the outer JavaScript class name
     * is not available while the `extends` expression is evaluated and may change
     * through renaming or minification.
     *
     * **Gotchas**
     *
     * Passing `disableChecks: true` skips filters and checks, not parsing of types
     * and structure. Wrong types and shapes are still rejected, and constructor
     * defaults still apply.
     *
     * **Example** (Defining a basic class)
     *
     * ```ts import.meta.vitest
     * import { Schema } from "effect"
     *
     * class Person extends Schema.Class<Person>("Person")({
     *   name: Schema.String,
     *   age: Schema.Number
     * }) {}
     *
     * const alice = new Person({ name: "Alice", age: 30 })
     * alice.name // => "Alice"
     * String(alice) // => "Person({\"name\":\"Alice\",\"age\":30})"
     * ```
     *
     * **Example** (Extending a class)
     *
     * ```ts import.meta.vitest
     * import { Schema } from "effect"
     *
     * class Animal extends Schema.Class<Animal>("Animal")({
     *   name: Schema.String
     * }) {}
     *
     * class Dog extends Animal.extend<Dog>("Dog")({
     *   breed: Schema.String
     * }) {}
     *
     * const dog = new Dog({ name: "Rex", breed: "Labrador" })
     * dog.name // => "Rex"
     * dog.breed // => "Labrador"
     * ```
     *
     * @see {@link TaggedClass} for adding a `_tag` literal field to the class schema
     * @see {@link Error} for defining schema-backed error classes
     * @see {@link TaggedError} for defining tagged schema-backed error classes
     *
     * @stability stable
     * @category constructors
     * @since 3.10.0
     */
    <Self = never, Brand = {}>(identifier: string): {
        <const Fields extends Struct.Fields>(fields: Fields, annotations?: Annotations.Declaration<Self, readonly [Struct<Fields>]>): [Self] extends [never] ? MissingSelfGeneric<"Schema.Class"> : Class<Self, Struct<Fields>, Brand>;
        <S extends Struct<Struct.Fields>>(schema: S, annotations?: Annotations.Declaration<Self, readonly [S]>): [Self] extends [never] ? MissingSelfGeneric<"Schema.Class"> : Class<Self, S, Brand>;
    };
};
/**
 * Defines a schema-backed class with an automatically populated `_tag` field.
 *
 * **When to use**
 *
 * Use to define class instances that are validated by a schema and participate
 * in tagged union matching.
 *
 * **Details**
 *
 * The optional `identifier` parameter overrides the schema identifier;
 * it defaults to the `tag` value.
 *
 * **Example** (Defining a tagged class)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * class Circle extends Schema.TaggedClass<Circle>()("Circle", {
 *   radius: Schema.Number
 * }) {}
 *
 * const c = new Circle({ radius: 5 })
 * c._tag // => "Circle"
 * c.radius // => 5
 * ```
 *
 * @stability stable
 * @category constructors
 * @since 3.10.0
 */
export declare const TaggedClass: {
    /**
     * Defines a schema-backed class with an automatically populated `_tag` field.
     *
     * **When to use**
     *
     * Use to define class instances that are validated by a schema and participate
     * in tagged union matching.
     *
     * **Details**
     *
     * The optional `identifier` parameter overrides the schema identifier;
     * it defaults to the `tag` value.
     *
     * **Example** (Defining a tagged class)
     *
     * ```ts import.meta.vitest
     * import { Schema } from "effect"
     *
     * class Circle extends Schema.TaggedClass<Circle>()("Circle", {
     *   radius: Schema.Number
     * }) {}
     *
     * const c = new Circle({ radius: 5 })
     * c._tag // => "Circle"
     * c.radius // => 5
     * ```
     *
     * @stability stable
     * @category constructors
     * @since 3.10.0
     */
    <Self = never, Brand = {}>(identifier?: string): {
        <Tag extends string, const Fields extends Struct.Fields>(tag: Tag, fields: Fields, annotations?: Annotations.Declaration<Self, readonly [TaggedStruct<Tag, Fields>]>): [Self] extends [never] ? MissingSelfGeneric<"Schema.TaggedClass"> : Class<Self, TaggedStruct<Tag, Fields>, Brand>;
        <Tag extends string, S extends Struct<Struct.Fields>>(tag: Tag, schema: S, annotations?: Annotations.Declaration<Self, readonly [Struct<Simplify<{
            readonly _tag: tag<Tag>;
        } & S["fields"]>>]>): [Self] extends [never] ? MissingSelfGeneric<"Schema.TaggedClass"> : Class<Self, Struct<Simplify<{
            readonly _tag: tag<Tag>;
        } & S["fields"]>>, Brand>;
    };
};
/**
 * Creates a schema-backed error class that can be used as a typed,
 * yieldable error in Effect programs. Combines {@link Class} validation with
 * the `YieldableError` interface so instances can be yielded directly inside
 * `Effect.gen`.
 *
 * **Example** (Schema-backed error)
 *
 * ```ts import.meta.vitest
 * import { Effect, Schema } from "effect"
 *
 * class NotFound extends Schema.Error<NotFound>("NotFound")({
 *   id: Schema.Number
 * }) {}
 *
 * const program = Effect.gen(function*() {
 *   yield* new NotFound({ id: 1 })
 * })
 * const error = await Effect.runPromise(Effect.flip(program))
 * error.id // => 1
 * ```
 *
 * @stability stable
 * @category constructors
 * @since 4.0.0
 */
export declare const Error: {
    /**
     * Creates a schema-backed error class that can be used as a typed,
     * yieldable error in Effect programs. Combines {@link Class} validation with
     * the `YieldableError` interface so instances can be yielded directly inside
     * `Effect.gen`.
     *
     * **Example** (Schema-backed error)
     *
     * ```ts import.meta.vitest
     * import { Effect, Schema } from "effect"
     *
     * class NotFound extends Schema.Error<NotFound>("NotFound")({
     *   id: Schema.Number
     * }) {}
     *
     * const program = Effect.gen(function*() {
     *   yield* new NotFound({ id: 1 })
     * })
     * const error = await Effect.runPromise(Effect.flip(program))
     * error.id // => 1
     * ```
     *
     * @stability stable
     * @category constructors
     * @since 4.0.0
     */
    <Self = never, Brand = {}>(identifier: string): {
        <const Fields extends Struct.Fields>(fields: Fields, annotations?: Annotations.Declaration<Self, readonly [Struct<Fields>]>): [Self] extends [never] ? MissingSelfGeneric<"Schema.Error"> : Class<Self, Struct<Fields>, Cause_.YieldableError & Brand>;
        <S extends Struct<Struct.Fields>>(schema: S, annotations?: Annotations.Declaration<Self, readonly [S]>): [Self] extends [never] ? MissingSelfGeneric<"Schema.Error"> : Class<Self, S, Cause_.YieldableError & Brand>;
    };
};
/**
 * Defines a schema-backed yieldable error class with an automatically populated
 * `_tag` field.
 *
 * **When to use**
 *
 * Use to define typed errors that are schema validated, yielded in `Effect.gen`,
 * and matched as tagged union members.
 *
 * **Example** (Defining a tagged error class)
 *
 * ```ts import.meta.vitest
 * import { Effect, Schema } from "effect"
 *
 * class NotFound extends Schema.TaggedError<NotFound>()("NotFound", {
 *   id: Schema.Number
 * }) {}
 *
 * const program = Effect.gen(function*() {
 *   yield* new NotFound({ id: 42 })
 * })
 * const error = await Effect.runPromise(Effect.flip(program))
 * error._tag // => "NotFound"
 * error.id // => 42
 * ```
 *
 * @stability stable
 * @category constructors
 * @since 3.10.0
 */
export declare const TaggedError: {
    /**
     * Defines a schema-backed yieldable error class with an automatically populated
     * `_tag` field.
     *
     * **When to use**
     *
     * Use to define typed errors that are schema validated, yielded in `Effect.gen`,
     * and matched as tagged union members.
     *
     * **Example** (Defining a tagged error class)
     *
     * ```ts import.meta.vitest
     * import { Effect, Schema } from "effect"
     *
     * class NotFound extends Schema.TaggedError<NotFound>()("NotFound", {
     *   id: Schema.Number
     * }) {}
     *
     * const program = Effect.gen(function*() {
     *   yield* new NotFound({ id: 42 })
     * })
     * const error = await Effect.runPromise(Effect.flip(program))
     * error._tag // => "NotFound"
     * error.id // => 42
     * ```
     *
     * @stability stable
     * @category constructors
     * @since 3.10.0
     */
    <Self = never, Brand = {}>(identifier?: string): {
        <Tag extends string, const Fields extends Struct.Fields>(tag: Tag, fields: Fields, annotations?: Annotations.Declaration<Self, readonly [TaggedStruct<Tag, Fields>]>): [Self] extends [never] ? MissingSelfGeneric<"Schema.TaggedError"> : Class<Self, TaggedStruct<Tag, Fields>, Cause_.YieldableError & Brand>;
        <Tag extends string, S extends Struct<Struct.Fields>>(tag: Tag, schema: S, annotations?: Annotations.Declaration<Self, readonly [Struct<Simplify<{
            readonly _tag: tag<Tag>;
        } & S["fields"]>>]>): [Self] extends [never] ? MissingSelfGeneric<"Schema.TaggedError"> : Class<Self, Struct<Simplify<{
            readonly _tag: tag<Tag>;
        } & S["fields"]>>, Cause_.YieldableError & Brand>;
    };
};
/**
 * Attaches a custom formatter used by `toFormatter`.
 *
 * **Details**
 *
 * Use this when the formatter derived from the schema structure is not suitable.
 * The annotation is applied through this helper because adding it directly to
 * `Annotations.Bottom` would make schemas invariant.
 *
 * @stability stable
 * @category formatting
 * @since 4.0.0
 */
export declare function overrideToFormatter<S extends Top>(toFormatter: () => Formatter<S["Type"]>): (self: S) => S["Rebuild"];
/**
 * Derives a string formatter function from a schema. The formatter converts
 * a value to its human-readable string representation, recursing into structs,
 * arrays, and unions.
 *
 * **Details**
 *
 * The optional `onBefore` hook lets you intercept specific AST nodes before
 * the default formatting logic runs.
 *
 * @stability stable
 * @category formatting
 * @since 4.0.0
 */
export declare function toFormatter<S extends Constraint>(schema: S, options?: {
    readonly onBefore?: ((ast: SchemaAST.AST, recur: (ast: SchemaAST.AST) => Formatter<any>) => Formatter<any> | undefined) | undefined;
}): Formatter<S["Type"]>;
/**
 * Overrides the equivalence derivation for a schema by supplying a custom
 * `Equivalence`.
 *
 * **When to use**
 *
 * Use when you need a custom equivalence instead of the default structural
 * equivalence derived by {@link toEquivalence}.
 *
 * @stability stable
 * @category instances
 * @since 4.0.0
 */
export declare function overrideToEquivalence<S extends Top>(toEquivalence: () => Equivalence.Equivalence<S["Type"]>): (self: S) => S["Rebuild"];
/**
 * Derives an `Equivalence` from a schema. Two values are considered equal when
 * every field (and nested field) compares equal according to the schema
 * structure.
 *
 * **Example** (Comparing structs)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const eq = Schema.toEquivalence(Schema.Struct({ id: Schema.Number, name: Schema.String }))
 *
 * eq({ id: 1, name: "Alice" }, { id: 1, name: "Alice" }) // => true
 * eq({ id: 1, name: "Alice" }, { id: 2, name: "Alice" }) // => false
 * ```
 *
 * @stability stable
 * @category instances
 * @since 4.0.0
 */
export declare function toEquivalence<T>(schema: Schema<T>): Equivalence.Equivalence<T>;
/**
 * Derives an intermediate `SchemaRepresentation.Document` from the encoded
 * side of a schema.
 *
 * **When to use**
 *
 * Use when you have a `Schema` and need its live structural representation for inspection, persistence, or compilation.
 *
 * **Details**
 *
 * Use {@link toType} before this function to represent the type side instead.
 * The optional reference policy controls which candidates are extracted into the document's reference table. By
 * default, only candidates with a resolved identifier become references; recursive candidates always require one.
 * TypeScript-only distinctions such as those added by {@link brand} are not
 * part of the schema AST and are therefore omitted.
 *
 * @see {@link SchemaRepresentation.toRepresentation} for converting a `SchemaAST.AST` directly
 *
 * @stability stable
 * @category converting
 * @since 4.0.0
 */
export declare function toRepresentation(schema: Constraint, options?: SchemaRepresentation.ToRepresentationOptions): SchemaRepresentation.Document;
/**
 * Options for reference allocation and JSON Schema generation in {@link toJsonSchemaDocument}.
 *
 * **Details**
 *
 * The inherited `referencePolicy` runs after the input schema is converted to its canonical JSON codec, so it receives
 * canonical JSON-encoded ASTs. The remaining options control compilation of the resulting live representation.
 *
 * **Gotchas**
 *
 * When these options are passed directly to `SchemaRepresentation.toJsonSchemaDocument` or
 * `SchemaRepresentation.toJsonSchemaMultiDocument`, reference allocation has already happened and `referencePolicy`
 * has no effect.
 *
 * @stability stable
 * @category options
 * @since 4.0.0
 */
export interface ToJsonSchemaOptions extends SchemaRepresentation.ToRepresentationOptions {
    /**
     * Controls whether generated object schemas accept properties that are not
     * modeled by the Effect schema.
     *
     * **Details**
     *
     * The default, `"ignore"`, matches the decoder's default excess-property
     * behavior and leaves unmodeled properties open. Use `"error"` together
     * with the decoder option of the same name to reject unmodeled properties
     * whenever the key space can be represented.
     *
     * Index signatures still determine the schema for properties they model.
     * When an index-signature key cannot be used as a `patternProperties`
     * selector, `"ignore"` leaves unmatched properties open. `"error"` instead
     * constrains their names with `propertyNames` and uses the candidate index
     * value schemas for `additionalProperties`.
     */
    readonly onExcessProperty?: "ignore" | "error" | undefined;
    /**
     * Controls whether to generate descriptions for checks (if the user has not
     * provided them) based on the `expected` annotation of the check.
     */
    readonly generateDescriptions?: boolean | undefined;
    /**
     * A predicate that controls which additional annotation keys (beyond the
     * standard JSON Schema keys) are included in the generated output.
     *
     * **When to use**
     *
     * Use when you need to include non-standard annotation keys in the generated
     * JSON Schema, such as Monaco Editor properties (`markdownDescription`,
     * `defaultSnippets`) or vendor extensions (`x-*`).
     *
     * **Details**
     *
     * Standard JSON Schema keys (`title`, `description`, `default`, `examples`,
     * `readOnly`, `writeOnly`, `format`, `contentEncoding`, `contentMediaType`,
     * `contentSchema`) are always included. This predicate is checked for any
     * *other* annotation key.
     *
     * **Gotchas**
     *
     * Prefer whitelisting the custom annotation keys you want to emit instead of
     * using a broad predicate such as `() => true`, because broad predicates can
     * include Effect-specific annotations that are preserved for internal schema
     * generation.
     *
     * **Example** (Including custom annotations)
     *
     * ```ts import.meta.vitest
     * import { Schema } from "effect"
     *
     * const schema = Schema.String.annotate({
     *   description: "A name",
     *   markdownDescription: "The **name** field"
     * })
     *
     * const doc = Schema.toJsonSchemaDocument(schema, {
     *   includeAnnotationKey: (key) =>
     *     key === "markdownDescription" || key.startsWith("x-")
     * })
     *
     * doc.schema // => { type: "string", description: "A name", markdownDescription: "The **name** field" }
     * ```
     */
    readonly includeAnnotationKey?: ((key: string) => boolean) | undefined;
}
/**
 * Returns a JSON Schema document using draft 2020-12.
 *
 * **When to use**
 *
 * Use when you need a draft-2020-12 description of the canonical JSON form of a runtime schema.
 *
 * **Details**
 *
 * The document describes the encoded side of `Schema.toCodecJson(schema)`.
 * Use that codec to decode JSON inputs. For example, it decodes JSON `null`
 * to JavaScript `undefined` for a field defined with `Schema.optional(Schema.String)`.
 * Decoding the same input with the original schema rejects `null`.
 *
 * The `options` parameter controls reference extraction and generation details
 * such as excess properties and synthesized check descriptions; it does not
 * change the draft target. The reference policy receives canonical JSON
 * encoded ASTs. By default, anonymous non-recursive candidates remain inline,
 * while candidates with resolved identifiers become definitions. Declarations
 * are lowered through their `toCodecJson` or `toCodec` annotation when
 * available before the representation document is compiled.
 *
 * The generated document is intended for preliminary validation. JSON Schema
 * and Effect checks do not always have identical semantics, so the Effect
 * decoder remains the final authority. Passing JSON Schema validation does not
 * guarantee that Effect decoding will succeed.
 *
 * **Gotchas**
 *
 * JSON Schema generation is best-effort. String length uses Unicode code points
 * in JSON Schema and UTF-16 code units in Effect. A generated `pattern` cannot
 * retain JavaScript RegExp flags. Object property checks apply to the original
 * input in JSON Schema but to the decoded object in Effect. When a `oneOf`
 * branch contains a known approximation, the compiler emits `anyOf` so that
 * the approximation cannot create a false rejection. Unions with only exact
 * branches retain `oneOf`. Custom `toJsonSchema` callbacks return `[schema, true]` for safe,
 * looser approximations and are responsible for the semantics they declare. When
 * canonical JSON derivation adds an artificial transformation, checks and
 * annotations on its source node are not copied to the JSON target, so they do
 * not appear in the emitted document. Opaque declarations without a structural
 * codec are represented by an unconstrained JSON Schema. The default
 * `onExcessProperty: "ignore"` matches the decoder default and leaves
 * index-signature keys without exact selectors open. In `"error"` mode, the compiler
 * constrains those keys with `propertyNames` and applies a permissive choice of
 * candidate index value schemas. The Effect decoder enforces the exact
 * key-value association.
 *
 * **Example** (Decoding JSON with the matching codec)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const schema = Schema.Struct({
 *   name: Schema.optional(Schema.String)
 * })
 *
 * const document = Schema.toJsonSchemaDocument(schema)
 * const jsonCodec = Schema.toCodecJson(schema)
 *
 * Schema.decodeUnknownResult(schema)({ name: null })._tag // => "Failure"
 * Schema.decodeUnknownSync(jsonCodec)({ name: null }) // => { name: undefined }
 * Schema.decodeUnknownSync(jsonCodec)({}) // => {}
 * Schema.encodeSync(jsonCodec)({ name: undefined }) // => { name: null }
 * ```
 *
 * @see {@link toCodecJson} for decoding and encoding the canonical JSON representation
 * @see {@link SchemaRepresentation.toJsonSchemaDocument} for compiling an existing live representation document
 *
 * @stability stable
 * @category converting
 * @since 4.0.0
 */
export declare function toJsonSchemaDocument(schema: Constraint, options?: ToJsonSchemaOptions): JsonSchema.Document<"draft-2020-12">;
/**
 * Type-level representation returned by {@link toCodecJson}.
 *
 * @stability stable
 * @category converting
 * @since 4.0.0
 */
export interface toCodecJson<S extends Constraint> extends BottomLazy<S["ast"], toCodecJson<S>, S["~type.parameters"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
    readonly "Type": S["Type"];
    readonly "Encoded": Json;
    readonly "DecodingServices": S["DecodingServices"];
    readonly "EncodingServices": S["EncodingServices"];
    readonly "~type.make.in": S["~type.make.in"];
    readonly "~type.make": S["~type.make"];
    readonly "Iso": S["Iso"];
    readonly schema: S;
}
/**
 * Derives a canonical JSON codec from a schema. The encoded form is `Json`, and
 * decoding produces the schema's `Type`.
 *
 * **Details**
 *
 * Derivation does not run transformations. Annotation links may be asynchronous,
 * may fail, and may use optional services; the consuming parser chooses the
 * execution and failure handling. Because hooks do not widen the returned
 * service types, links cannot require services not declared by the input schema.
 *
 * **Gotchas**
 *
 * Declarations without a `toCodecJson` or `toCodec` annotation use `Json` as
 * their encoded schema. This keeps codec construction total, but encoding or
 * decoding can still fail when declaration values are not JSON values. A
 * `toCodecJson` callback can return `undefined` when the declaration is already
 * in canonical JSON form. When derivation adds an artificial transformation,
 * checks and annotations remain on its source node rather than being copied to
 * the JSON target. Source checks still run after the transformation.
 *
 * @stability stable
 * @category converting
 * @since 4.0.0
 */
export declare const toCodecJson: {
    /**
     * Derives a canonical JSON codec from a schema. The encoded form is `Json`, and
     * decoding produces the schema's `Type`.
     *
     * **Details**
     *
     * Derivation does not run transformations. Annotation links may be asynchronous,
     * may fail, and may use optional services; the consuming parser chooses the
     * execution and failure handling. Because hooks do not widen the returned
     * service types, links cannot require services not declared by the input schema.
     *
     * **Gotchas**
     *
     * Declarations without a `toCodecJson` or `toCodec` annotation use `Json` as
     * their encoded schema. This keeps codec construction total, but encoding or
     * decoding can still fail when declaration values are not JSON values. A
     * `toCodecJson` callback can return `undefined` when the declaration is already
     * in canonical JSON form. When derivation adds an artificial transformation,
     * checks and annotations remain on its source node rather than being copied to
     * the JSON target. Source checks still run after the transformation.
     *
     * @stability stable
     * @category converting
     * @since 4.0.0
     */
    <S extends Constraint>(schema: S): toCodecJson<S>;
};
/**
 * Derives an isomorphism codec from a schema. The encoded form is the schema's
 * `Iso` type — the intermediate representation used for round-tripping.
 *
 * **Details**
 *
 * Annotation links may be asynchronous, may fail, and may use optional services;
 * the consuming parser chooses the execution and failure handling.
 *
 * **Gotchas**
 *
 * Links cannot require services because the returned `Codec` does not expose
 * service requirements.
 *
 * @stability stable
 * @category converting
 * @since 4.0.0
 */
export declare const toCodecIso: {
    /**
     * Derives an isomorphism codec from a schema. The encoded form is the schema's
     * `Iso` type — the intermediate representation used for round-tripping.
     *
     * **Details**
     *
     * Annotation links may be asynchronous, may fail, and may use optional services;
     * the consuming parser chooses the execution and failure handling.
     *
     * **Gotchas**
     *
     * Links cannot require services because the returned `Codec` does not expose
     * service requirements.
     *
     * @stability stable
     * @category converting
     * @since 4.0.0
     */
    <S extends Constraint>(schema: S): Codec<S["Type"], S["Iso"]>;
};
/**
 * A {@link Tree} of `string | undefined` nodes. Leaf values are either a
 * string representation or `undefined` for opaque/declaration types.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export type StringTree = Tree<string | undefined>;
/**
 * Type-level representation returned by {@link toCodecStringTree}.
 *
 * @stability stable
 * @category converting
 * @since 4.0.0
 */
export interface toCodecStringTree<S extends Constraint> extends BottomLazy<S["ast"], toCodecStringTree<S>, ReadonlyArray<Constraint>, S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
    readonly "Type": S["Type"];
    readonly "Encoded": StringTree;
    readonly "DecodingServices": S["DecodingServices"];
    readonly "EncodingServices": S["EncodingServices"];
    readonly "~type.make.in": S["~type.make.in"];
    readonly "~type.make": S["~type.make"];
    readonly "Iso": S["Iso"];
    readonly schema: S;
}
/**
 * Converts a schema to the StringTree canonical codec, where every leaf value
 * becomes a string while preserving the original structure.
 *
 * **Details**
 *
 * Derivation does not run transformations. Annotation links may be asynchronous,
 * may fail, and may use optional services; the consuming parser chooses the
 * execution and failure handling. Links cannot require services not declared by
 * the input schema because hooks do not widen the returned service types.
 *
 * **Gotchas**
 *
 * Declarations must provide a structural `toCodecStringTree`, `toCodecJson`, or
 * `toCodec` encoding. A callback can return `undefined` when the declaration is
 * already in canonical StringTree form.
 *
 * @stability stable
 * @category converting
 * @since 4.0.0
 */
export declare const toCodecStringTree: {
    /**
     * Converts a schema to the StringTree canonical codec, where every leaf value
     * becomes a string while preserving the original structure.
     *
     * **Details**
     *
     * Derivation does not run transformations. Annotation links may be asynchronous,
     * may fail, and may use optional services; the consuming parser chooses the
     * execution and failure handling. Links cannot require services not declared by
     * the input schema because hooks do not widen the returned service types.
     *
     * **Gotchas**
     *
     * Declarations must provide a structural `toCodecStringTree`, `toCodecJson`, or
     * `toCodec` encoding. A callback can return `undefined` when the declaration is
     * already in canonical StringTree form.
     *
     * @stability stable
     * @category converting
     * @since 4.0.0
     */
    <S extends Constraint>(schema: S): toCodecStringTree<S>;
};
/**
 * Type-level representation returned by {@link toCodecArrayFromSingle}.
 *
 * @stability stable
 * @category converting
 * @since 4.0.0
 */
export interface toCodecArrayFromSingle<S extends Constraint> extends BottomLazy<S["ast"], toCodecArrayFromSingle<S>, S["~type.parameters"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
    readonly "Type": S["Type"];
    readonly "Encoded": S["Encoded"];
    readonly "DecodingServices": S["DecodingServices"];
    readonly "EncodingServices": S["EncodingServices"];
    readonly "~type.make.in": S["~type.make.in"];
    readonly "~type.make": S["~type.make"];
    readonly "Iso": S["Iso"];
}
/**
 * Allows array schemas to decode from either an array input or a single value
 * input.
 *
 * **When to use**
 *
 * Use when you need to accept transport formats that may represent a
 * single-item array as a bare value, such as query-string or form-data adapters.
 *
 * **Gotchas**
 *
 * This combinator is intentionally not part of `toCodecStringTree`; it adds a
 * decoding convenience rather than a canonical StringTree representation. It
 * does not parse comma-separated strings.
 *
 * @stability stable
 * @category converting
 * @since 4.0.0
 */
export declare const toCodecArrayFromSingle: {
    /**
     * Allows array schemas to decode from either an array input or a single value
     * input.
     *
     * **When to use**
     *
     * Use when you need to accept transport formats that may represent a
     * single-item array as a bare value, such as query-string or form-data adapters.
     *
     * **Gotchas**
     *
     * This combinator is intentionally not part of `toCodecStringTree`; it adds a
     * decoding convenience rather than a canonical StringTree representation. It
     * does not parse comma-separated strings.
     *
     * @stability stable
     * @category converting
     * @since 4.0.0
     */
    <S extends Constraint>(schema: S): toCodecArrayFromSingle<S>;
};
/**
 * Type-level representation returned by {@link toCodecGoJson}.
 *
 * @stability unstable
 * @category converting
 * @since 4.0.6
 */
export interface toCodecGoJson<S extends Constraint> extends BottomLazy<S["ast"], toCodecGoJson<S>, S["~type.parameters"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
    readonly "Type": S["Type"];
    readonly "Encoded": Json;
    readonly "DecodingServices": S["DecodingServices"];
    readonly "EncodingServices": S["EncodingServices"];
    readonly "~type.make.in": S["~type.make.in"];
    readonly "~type.make": S["~type.make"];
    readonly "Iso": S["Iso"];
    readonly schema: S;
}
/**
 * Derives a JSON codec, like {@link toCodecJson}, that also accepts the
 * `null` values Go's `encoding/json` writes for nil pointers, slices, and maps.
 *
 * **When to use**
 *
 * Use when decoding JSON produced by a Go service (for example the Docker
 * Engine or Kubernetes APIs), where any field the API document describes as
 * optional, or any slice or map, may arrive as `null`.
 *
 * **Details**
 *
 * Decoding applies these rules at every level of the schema:
 *
 * - An optional key that is `null` decodes as a missing key.
 * - A required array (`Schema.Array`) that is `null` decodes as `[]`.
 * - A required record (`Schema.Record`) that is `null` decodes as `{}`.
 *
 * Array and record rules also apply at the top level and to nested collection
 * values. Tuples, non-empty arrays, and structs are not treated as collections;
 * collection checks still apply to the empty value.
 *
 * Encoding is unchanged from {@link toCodecJson}: the added rules only decode
 * `null` and do not emit it. A missing key stays missing.
 *
 * These rules also accept `encoding/json/v2` output. By default, v2 writes
 * nil slices and maps as `[]` and `{}`, but it can be configured to emit
 * `null` instead.
 *
 * **Gotchas**
 *
 * - Normalization deliberately discards the distinction between nil and empty
 *   Go slices or maps. They are distinguishable in Go, and unmarshalling a
 *   missing key, `null`, or an empty collection can affect existing values
 *   differently. Use {@link toCodecJson} with explicit nullable schemas when
 *   that distinction matters.
 * - A key whose schema already accepts `null` (for example
 *   `Schema.NullOr(X)`, `Schema.Unknown`, or `Schema.Json`) keeps `null` as a
 *   value.
 * - A required field that is not an array or a record (a nil pointer to a Go
 *   struct, for example) still fails on `null`. Make it optional if the API
 *   can omit it.
 * - A nil `[]byte` is written as `null` by `encoding/json` (and as `""` by
 *   version 2), but its schema is a base64 string, not an array. A required
 *   `[]byte` field that is `null` fails; make it optional if the API can send
 *   `null`.
 * - Only these `null` rules are covered. Field formats such as durations,
 *   base64 bytes, and numbers encoded as strings belong in the field schemas.
 *
 * **Example** (Decoding a Go response with nil fields)
 *
 * ```ts import.meta.vitest
 * import { Schema } from "effect"
 *
 * const Container = Schema.Struct({
 *   Id: Schema.String,
 *   Names: Schema.Array(Schema.String),
 *   Labels: Schema.Record(Schema.String, Schema.String),
 *   Status: Schema.optionalKey(Schema.String)
 * })
 *
 * const decode = Schema.decodeUnknownSync(Schema.toCodecGoJson(Container))
 *
 * decode({ Id: "a", Names: null, Labels: null, Status: null }) // => { Id: "a", Names: [], Labels: {} }
 * ```
 *
 * @see {@link toCodecJson} for the canonical JSON codec
 * @stability unstable
 * @category converting
 * @since 4.0.6
 */
export declare const toCodecGoJson: {
    /**
     * Derives a JSON codec, like {@link toCodecJson}, that also accepts the
     * `null` values Go's `encoding/json` writes for nil pointers, slices, and maps.
     *
     * **When to use**
     *
     * Use when decoding JSON produced by a Go service (for example the Docker
     * Engine or Kubernetes APIs), where any field the API document describes as
     * optional, or any slice or map, may arrive as `null`.
     *
     * **Details**
     *
     * Decoding applies these rules at every level of the schema:
     *
     * - An optional key that is `null` decodes as a missing key.
     * - A required array (`Schema.Array`) that is `null` decodes as `[]`.
     * - A required record (`Schema.Record`) that is `null` decodes as `{}`.
     *
     * Array and record rules also apply at the top level and to nested collection
     * values. Tuples, non-empty arrays, and structs are not treated as collections;
     * collection checks still apply to the empty value.
     *
     * Encoding is unchanged from {@link toCodecJson}: the added rules only decode
     * `null` and do not emit it. A missing key stays missing.
     *
     * These rules also accept `encoding/json/v2` output. By default, v2 writes
     * nil slices and maps as `[]` and `{}`, but it can be configured to emit
     * `null` instead.
     *
     * **Gotchas**
     *
     * - Normalization deliberately discards the distinction between nil and empty
     *   Go slices or maps. They are distinguishable in Go, and unmarshalling a
     *   missing key, `null`, or an empty collection can affect existing values
     *   differently. Use {@link toCodecJson} with explicit nullable schemas when
     *   that distinction matters.
     * - A key whose schema already accepts `null` (for example
     *   `Schema.NullOr(X)`, `Schema.Unknown`, or `Schema.Json`) keeps `null` as a
     *   value.
     * - A required field that is not an array or a record (a nil pointer to a Go
     *   struct, for example) still fails on `null`. Make it optional if the API
     *   can omit it.
     * - A nil `[]byte` is written as `null` by `encoding/json` (and as `""` by
     *   version 2), but its schema is a base64 string, not an array. A required
     *   `[]byte` field that is `null` fails; make it optional if the API can send
     *   `null`.
     * - Only these `null` rules are covered. Field formats such as durations,
     *   base64 bytes, and numbers encoded as strings belong in the field schemas.
     *
     * **Example** (Decoding a Go response with nil fields)
     *
     * ```ts import.meta.vitest
     * import { Schema } from "effect"
     *
     * const Container = Schema.Struct({
     *   Id: Schema.String,
     *   Names: Schema.Array(Schema.String),
     *   Labels: Schema.Record(Schema.String, Schema.String),
     *   Status: Schema.optionalKey(Schema.String)
     * })
     *
     * const decode = Schema.decodeUnknownSync(Schema.toCodecGoJson(Container))
     *
     * decode({ Id: "a", Names: null, Labels: null, Status: null }) // => { Id: "a", Names: [], Labels: {} }
     * ```
     *
     * @see {@link toCodecJson} for the canonical JSON codec
     * @stability unstable
     * @category converting
     * @since 4.0.6
     */
    <S extends Constraint>(schema: S): toCodecGoJson<S>;
};
type XmlEncoderOptions = {
    /** Root element name for the returned XML string. Default: "root" */
    readonly rootName?: string | undefined;
    /** When an array doesn't have a natural item name, use this. Default: "item" */
    readonly arrayItemName?: string | undefined;
    /** Pretty-print output. Default: true */
    readonly pretty?: boolean | undefined;
    /** Indentation used when pretty-printing. Default: "  " (two spaces) */
    readonly indent?: string | undefined;
    /** Sort object keys for stable output. Default: true */
    readonly sortKeys?: boolean | undefined;
};
/**
 * Derives an XML encoder from a codec.
 *
 * **Details**
 *
 * The returned function encodes a value through `toCodecStringTree` and returns
 * an `Effect` that succeeds with the XML string or fails with a
 * {@link SchemaIssue.Issue} if codec encoding fails.
 *
 * @stability stable
 * @category encoding
 * @since 4.0.0
 */
export declare function toEncoderXml<T, RE>(codec: ConstraintCodec<T, unknown, unknown, RE>, options?: XmlEncoderOptions): (t: T) => Effect.Effect<string, SchemaIssue.Issue, RE>;
/**
 * Derives an `Iso` optic from a schema that isomorphically converts between
 * the schema's `Type` and its `Iso` (intermediate / serialized form).
 *
 * **Details**
 *
 * Reading through the `Iso` encodes the schema value, while replacing through
 * it decodes the new focus.
 *
 * **Gotchas**
 *
 * This API runs synchronously, so failing, asynchronous, or service-dependent
 * transformations can throw. Schema failures use `"Schema validation failed"`
 * with a `SchemaIssue.Issue` in `cause`; format it with
 * `SchemaIssue.makeFormatterDefault()`. Consume {@link toCodecIso} with an
 * effectful parser for asynchronous execution or explicit failure handling.
 *
 * @stability stable
 * @category converting
 * @since 4.0.0
 */
export declare function toIso<S extends Constraint>(schema: S): Optic_.Iso<S["Type"], S["Iso"]>;
/**
 * Returns an identity `Iso` over the schema's source (`Type`) side.
 *
 * @stability stable
 * @category constructors
 * @since 4.0.0
 */
export declare function toIsoSource<S extends Constraint>(schema: S): Optic_.Iso<S["Type"], S["Type"]>;
/**
 * Returns an identity `Iso` over the schema's focus (`Iso`) side.
 *
 * @stability stable
 * @category constructors
 * @since 4.0.0
 */
export declare function toIsoFocus<S extends Constraint>(schema: S): Optic_.Iso<S["Iso"], S["Iso"]>;
/**
 * Type-level representation returned by {@link overrideToCodecIso}.
 *
 * @stability stable
 * @category transforming
 * @since 4.0.0
 */
export interface overrideToCodecIso<S extends Constraint, Iso> extends BottomLazy<S["ast"], overrideToCodecIso<S, Iso>, S["~type.parameters"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
    readonly "Type": S["Type"];
    readonly "Encoded": S["Encoded"];
    readonly "DecodingServices": S["DecodingServices"];
    readonly "EncodingServices": S["EncodingServices"];
    readonly "~type.make.in": S["~type.make.in"];
    readonly "~type.make": S["~type.make"];
    readonly "Iso": Iso;
    readonly schema: S;
}
/**
 * Overrides a schema's derived ISO codec with an explicit target codec.
 *
 * **When to use**
 *
 * Use to provide a custom ISO transformation when the default derivation is not
 * appropriate.
 *
 * **Details**
 *
 * The resulting schema carries a custom `Iso` type parameter and uses the
 * provided `decode` and `encode` getters to transform between the schema type
 * and the target codec.
 *
 * @stability stable
 * @category transforming
 * @since 4.0.0
 */
export declare function overrideToCodecIso<S extends Constraint, Iso>(to: ConstraintCodec<Iso>, transformation: {
    readonly decode: SchemaGetter.Getter<S["Type"], Iso>;
    readonly encode: SchemaGetter.Getter<Iso, S["Type"]>;
}): (schema: S) => overrideToCodecIso<S, Iso>;
/**
 * Derives a JSON Patch differ from a codec. Serializes values to JSON (via
 * {@link toCodecJson}), computes RFC 6902 JSON Patch operations between old
 * and new values, and can apply patches back to the typed value.
 *
 * **Details**
 *
 * `diff` encodes both values before computing the patch. `patch` encodes the old
 * value, applies the patch to its JSON representation, and decodes the result.
 *
 * **Gotchas**
 *
 * This API runs synchronously, so failing, asynchronous, or service-dependent
 * transformations can throw. Schema failures use `"Schema validation failed"`
 * with a `SchemaIssue.Issue` in `cause`; format it with
 * `SchemaIssue.makeFormatterDefault()`. Invalid patch operations instead produce
 * {@link JsonPatch.apply} errors.
 *
 * @stability stable
 * @category converting
 * @since 4.0.0
 */
export declare function toDifferJsonPatch<T>(schema: ConstraintCodec<T, unknown>): Differ<T, JsonPatch.JsonPatch>;
/**
 * Recursive tree type whose leaves are `Node` values and whose branches are
 * readonly arrays or string-keyed records of child trees.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export type Tree<Node> = Node | TreeRecord<Node> | ReadonlyArray<Tree<Node>>;
/**
 * A record node in a {@link Tree}: an object mapping string keys to child
 * `Tree` nodes.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface TreeRecord<A> {
    readonly [x: string]: Tree<A>;
}
/**
 * Creates a recursive schema for a {@link Tree} of values described by `node`.
 * The resulting schema accepts a single node value, an array of trees, or an
 * object whose values are trees.
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare function Tree<S extends Constraint>(node: S): Union<readonly [S, $Array<suspend<Codec<Tree<S["Type"]>, Tree<S["Encoded"]>, S["DecodingServices"], S["EncodingServices"]>>>, $Record<String, suspend<Codec<Tree<S["Type"]>, Tree<S["Encoded"]>, S["DecodingServices"], S["EncodingServices"]>>>]>;
/**
 * Recursive TypeScript type for any valid immutable JSON value: `null`,
 * `number`, `boolean`, `string`, a readonly array of `Json` values, or a
 * readonly record of `string → Json`. For the corresponding schema, see the
 * {@link Json} const.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export type Json = null | number | boolean | string | JsonArray | JsonObject;
/**
 * A readonly array of {@link Json} values.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface JsonArray extends ReadonlyArray<Json> {
}
/**
 * A readonly record whose values are {@link Json} values.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface JsonObject {
    readonly [x: string]: Json;
}
/**
 * Schema that accepts and validates any immutable JSON-compatible value.
 *
 * **Example** (Validating a JSON value)
 *
 * ```ts import.meta.vitest
 * import { Option, Schema } from "effect"
 *
 * Schema.decodeUnknownOption(Schema.Json)({ key: [1, true, null] }) // => Option.some({ key: [1, true, null] })
 * ```
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare const Json: Codec<Json>;
/**
 * Schema for readonly string-keyed records whose values are JSON-compatible.
 *
 * **When to use**
 *
 * Use when you need to validate a JSON object rather than any JSON value.
 *
 * **Example** (Validating a JSON object)
 *
 * ```ts import.meta.vitest
 * import { Option, Schema } from "effect"
 *
 * Schema.decodeUnknownOption(Schema.JsonObject)({ key: [1, true, null] }) // => Option.some({ key: [1, true, null] })
 * Schema.decodeUnknownOption(Schema.JsonObject)([1, 2, 3]) // => Option.none()
 * ```
 *
 * @see {@link Json} for a schema that also accepts JSON arrays and primitive values
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare const JsonObject: $Record<String, Codec<Json, Json, never, never>>;
/**
 * Recursive TypeScript type for mutable JSON values: `null`, `number`,
 * `boolean`, `string`, mutable arrays, or mutable string-keyed records.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export type MutableJson = null | number | boolean | string | MutableJsonArray | MutableJsonObject;
/**
 * A mutable array of {@link MutableJson} values.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface MutableJsonArray extends Array<MutableJson> {
}
/**
 * A mutable record whose values are {@link MutableJson} values.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export interface MutableJsonObject {
    [x: string]: MutableJson;
}
/**
 * Schema that accepts any mutable JSON-compatible value. See {@link Json} for
 * the immutable variant.
 *
 * @stability stable
 * @category schemas
 * @since 4.0.0
 */
export declare const MutableJson: Codec<MutableJson>;
/**
 * Resolves the typed annotations from a schema. The term "resolve" (rather
 * than "get") reflects the lookup strategy: if the schema has checks, the
 * annotations are taken from the last check; otherwise they are taken from
 * the base schema instance.
 *
 * @stability stable
 * @category getters
 * @since 4.0.0
 */
export declare function resolveAnnotations<S extends Constraint>(schema: S): Annotations.Bottom<S["Type"], S["~type.parameters"]> | undefined;
/**
 * Resolves the context (key-level) annotations from a schema. Context
 * annotations are those attached via `annotateKey` and live on the AST's
 * `context` rather than on the schema node itself.
 *
 * @stability stable
 * @category getters
 * @since 4.0.0
 */
export declare function resolveAnnotationsKey<S extends Constraint>(schema: S): Annotations.Key<S["Type"]> | undefined;
/**
 * The `Annotations` namespace groups all annotation interfaces used to attach
 * metadata to schemas. Annotations control documentation, validation messages,
 * JSON Schema generation, equivalence, arbitrary generation, and more.
 *
 * **Details**
 *
 * Use {@link resolveAnnotations} to read the annotations attached to a schema at
 * runtime.
 *
 * @stability stable
 * @category models
 * @since 4.0.0
 */
export declare namespace Annotations {
    /**
     * This interface is used to define the annotations that can be attached to a
     * schema. You can extend this interface to define your own annotations.
     *
     * **Details**
     *
     * Note that both a missing key or `undefined` is used to indicate that the
     * annotation is not present.
     *
     * This means that can remove any annotation by setting it to `undefined`.
     *
     * **Example** (Defining your own annotations)
     *
     * ```ts import.meta.vitest
     * import { Schema } from "effect"
     *
     * // Extend the Annotations interface with a custom `version` annotation
     * declare module "effect/Schema" {
     *   namespace Annotations {
     *     interface Annotations {
     *       readonly version?:
     *         | readonly [major: number, minor: number, patch: number]
     *         | undefined
     *     }
     *   }
     * }
     *
     * // The `version` annotation is now recognized by the TypeScript compiler
     * const schema = Schema.String.annotate({ version: [1, 2, 0] })
     *
     * // const version: readonly [major: number, minor: number, patch: number] | undefined
     * const version = Schema.resolveAnnotations(schema)?.["version"]
     *
     * if (version) {
     *   // Access individual parts of the version
     *   version[1] // => 2
     * }
     * ```
     *
     * @category models
     * @since 4.0.0
     */
    interface Annotations {
        readonly [x: string]: unknown;
    }
    /**
     * Annotations shared by all schema nodes. These map to common JSON Schema /
     * OpenAPI fields: `title`, `description`, `format`, etc.
     *
     * @category models
     * @since 4.0.0
     */
    interface Augment extends Annotations {
        /**
         * Human-readable description of what a value is expected to satisfy.
         *
         * **Details**
         *
         * For filter and refinement failures, the default formatter uses
         * `message` first, then `expected`, and finally falls back to `<filter>`.
         *
         * Use this to name a failed filter in the default message:
         * `Expected <expected>`.
         */
        readonly expected?: string | undefined;
        readonly title?: string | undefined;
        readonly description?: string | undefined;
        readonly documentation?: string | undefined;
        readonly readOnly?: boolean | undefined;
        readonly writeOnly?: boolean | undefined;
        readonly format?: string | undefined;
        readonly contentEncoding?: string | undefined;
        readonly contentMediaType?: string | undefined;
        readonly contentSchema?: Json | undefined;
    }
    /**
     * Extends {@link Augment} with type-parametric `default` and `examples` fields.
     *
     * @category models
     * @since 4.0.0
     */
    interface Documentation<T> extends Augment {
        readonly default?: T | undefined;
        readonly examples?: ReadonlyArray<T> | undefined;
    }
    /**
     * Annotations for struct property schemas. Extends {@link Documentation}
     * with an optional `messageMissingKey` to override the error message when
     * the property key is absent during decoding.
     *
     * @category models
     * @since 4.0.0
     */
    interface Key<T> extends Documentation<T> {
        /**
         * The message to use when a key is missing.
         */
        readonly messageMissingKey?: string | undefined;
    }
    /**
     * Base annotations shared by all composite schema nodes. Extends
     * {@link Documentation} with error messages and arbitrary generation hooks.
     * {@link Declaration} and other annotation
     * interfaces build on top of this.
     *
     * @category models
     * @since 4.0.0
     */
    interface Bottom<T, TypeParameters extends ReadonlyArray<Constraint>> extends Documentation<T> {
        /**
         * Complete message to use when this schema node reports an issue.
         *
         * **Details**
         *
         * This replaces the default message for matching issue types instead of
         * only changing the expected label. For a filter or refinement failure,
         * annotate the filter with `message` to replace the whole filter failure
         * message, or `expected` to keep the default
         * `Expected <expected>` shape.
         */
        readonly message?: string | undefined;
        /**
         * The message to use when a key is unexpected.
         */
        readonly messageUnexpectedKey?: string | undefined;
        /**
         * Stable identifier for this schema node.
         *
         * **Details**
         *
         * Identifiers are used by schema tooling, including JSON Schema
         * generation, to name references. The default formatter also uses
         * `identifier` as the expected label for type-level failures, such as
         * `Expected UserId`.
         *
         * `identifier` does not name a failed filter or refinement. If the base
         * type matches and a filter fails, put `expected` or `message` on the
         * filter/refinement instead.
         */
        readonly identifier?: string | undefined;
    }
    /**
     * Helpers for projecting declaration type-parameter schemas into decoded or
     * encoded codec arrays used by annotation hooks.
     *
     * @since 4.0.0
     */
    namespace TypeParameters {
        /**
         * Maps declaration type-parameter schemas to codecs for their decoded `Type`
         * values.
         *
         * @category utility types
         * @since 4.0.0
         */
        type Type<TypeParameters extends ReadonlyArray<Constraint>> = {
            readonly [K in keyof TypeParameters]: Codec<TypeParameters[K]["Type"]>;
        };
        /**
         * Maps declaration type-parameter schemas to codecs for their `Encoded` values.
         *
         * @category utility types
         * @since 4.0.0
         */
        type Encoded<TypeParameters extends ReadonlyArray<Constraint>> = {
            readonly [K in keyof TypeParameters]: Codec<TypeParameters[K]["Encoded"]>;
        };
    }
    /**
     * Full annotation set for `Declaration` schema nodes — used when defining
     * custom, opaque schema types via `Schema.declare`. Extends {@link Bottom}
     * with optional codec, arbitrary, equivalence, and formatter hooks so that
     * derived capabilities (JSON encoding, property testing, etc.) can be
     * provided for the custom type.
     *
     * @category models
     * @since 4.0.0
     */
    interface Declaration<T, TypeParameters extends ReadonlyArray<Constraint> = readonly []> extends Bottom<T, TypeParameters> {
        readonly representation?: SchemaRepresentation.RepresentationAnnotation | undefined;
        /**
         * Returns the fallback link used by canonical codec derivations.
         *
         * **Details**
         *
         * Transformations may be asynchronous, may fail, and may use optional
         * services, but cannot require services absent from the derived codec type.
         */
        readonly toCodec?: ((typeParameters: TypeParameters.Encoded<TypeParameters>) => SchemaAST.Link) | undefined;
        /**
         * Returns the link used to derive the declaration's JSON representation, or
         * `undefined` when the declaration is already in canonical JSON form.
         *
         * **Details**
         *
         * Transformations follow the execution and service constraints of `toCodec`.
         */
        readonly toCodecJson?: ((typeParameters: TypeParameters.Encoded<TypeParameters>) => SchemaAST.Link | undefined) | undefined;
        /**
         * Returns the link used to derive the declaration's StringTree
         * representation, or `undefined` when it is already canonical.
         *
         * **Details**
         *
         * Transformations follow the execution and service constraints of `toCodec`.
         */
        readonly toCodecStringTree?: ((typeParameters: TypeParameters.Encoded<TypeParameters>) => SchemaAST.Link | undefined) | undefined;
        /**
         * Returns the link used to derive the declaration's isomorphism
         * representation.
         *
         * **Details**
         *
         * Transformations may be asynchronous, may fail, and may use optional
         * services, but cannot require services because the derived `Codec` exposes
         * none.
         */
        readonly toCodecIso?: ((typeParameters: TypeParameters.Type<TypeParameters>) => SchemaAST.Link) | undefined;
        /**
         * Provides a generatable representation for native arbitrary derivation.
         *
         * **Details**
         *
         * The callback receives decoded type-parameter schemas and normalized constraints for the declaration. The returned
         * Link is preferred over canonical codec annotations by the native arbitrary compiler. Generated representation
         * values are decoded and checked against the declaration, so the Link may be asynchronous or partial. As with the
         * other `toCodec*` hooks, the Link cannot require additional services because the derived `Arbitrary` exposes none.
         *
         * This annotation is experimental and may change while native arbitrary generation remains unstable.
         *
         * @since 4.0.0
         */
        readonly toCodecArbitrary?: ToArbitrary.Declaration<T, TypeParameters> | undefined;
        readonly toEquivalence?: ToEquivalence.Declaration<T, TypeParameters> | undefined;
        readonly toFormatter?: ToFormatter.Declaration<T, TypeParameters> | undefined;
        readonly toCode?: SchemaRepresentation.Generation.Declaration | undefined;
    }
    /**
     * Annotations for filter checks (created via `Schema.makeFilter`). Extends
     * {@link Augment} with an optional error message, identifier, and metadata.
     * Filters are intentionally non-parametric to keep them covariant.
     *
     * @category models
     * @since 4.0.0
     */
    interface Filter extends Augment {
        readonly representation?: SchemaRepresentation.CheckRepresentationAnnotation<SchemaAST.AST> | undefined;
        /**
         * Compiles this filter to a JSON Schema fragment.
         *
         * **Details**
         *
         * Return the fragment directly for an exact translation or `[fragment, true]`
         * for a safe, looser approximation. Use `[{}, true]` to omit the constraint.
         * Approximation propagates from `representation.schemas` automatically. It
         * makes enclosing `oneOf` unions export as `anyOf` and prevents approximate
         * record-key patterns from selecting `patternProperties` values.
         *
         * **Gotchas**
         *
         * The compiler trusts the declared semantics. Treat the input schemas as immutable. The returned fragment must be
         * a valid JSON Schema object graph and must not be mutated after this function returns. Return a new object graph
         * to produce different output during a later compilation.
         *
         * @see {@link SchemaRepresentation.ToJsonSchema.CheckOutput} for the result contract
         */
        readonly toJsonSchema?: SchemaRepresentation.ToJsonSchema.Check | undefined;
        readonly toCode?: SchemaRepresentation.Generation.Check | undefined;
        /**
         * Complete message to use when this filter or refinement fails.
         *
         * **Details**
         *
         * The default formatter checks filter annotations in this order:
         * `message`, then `expected`, then `<filter>`.
         */
        readonly message?: string | undefined;
        /**
         * Stable identifier for the schema after this filter is attached.
         *
         * **Details**
         *
         * This can affect schema tooling such as JSON Schema generation and
         * type-level failures before the filter runs, but it does not name the
         * failed filter itself. For filter failure messages, use `expected` or
         * `message`.
         */
        readonly identifier?: string | undefined;
        /**
         * Native arbitrary-generation hints for this filter.
         *
         * **Details**
         *
         * The value is declarative metadata merged with constraints from the other filters on the node. The filter
         * predicate remains authoritative.
         *
         * @since 4.0.0
         */
        readonly arbitraryConstraint?: ToArbitrary.FilterConstraint<any> | undefined;
        /**
         * Marks the filter as *structural*, meaning it applies to the shape or
         * structure of the container (e.g., array length, object keys) rather than
         * the contents.
         *
         * **Details**
         *
         * Reserved to internal use only.
         *
         * Example: `minLength` on an array is a structural filter.
         */
        readonly "~structural"?: boolean | undefined;
    }
    /**
     * Types used to guide native arbitrary derivation through constraints and declaration representations.
     *
     * @since 4.0.0
     */
    namespace ToArbitrary {
        /**
         * Regular-expression source and flags used for constructive string generation.
         *
         * @category models
         * @since 4.0.0
         */
        interface Pattern {
            readonly source: string;
            readonly flags: string;
        }
        /**
         * Normalized generation constraints for a declaration or schema node.
         *
         * **Details**
         *
         * Missing fields are unconstrained. These values guide construction but do not replace Schema validation.
         *
         * @category models
         * @since 4.0.0
         */
        interface GenerationConstraint<T = unknown> {
            readonly minimum?: T | undefined;
            readonly exclusiveMinimum?: true | undefined;
            readonly maximum?: T | undefined;
            readonly exclusiveMaximum?: true | undefined;
            readonly minLength?: number | undefined;
            readonly maxLength?: number | undefined;
            readonly minCodePoints?: number | undefined;
            readonly maxCodePoints?: number | undefined;
            readonly minSize?: number | undefined;
            readonly maxSize?: number | undefined;
            readonly minProperties?: number | undefined;
            readonly maxProperties?: number | undefined;
            readonly patterns?: readonly [Pattern, ...Array<Pattern>];
            readonly number?: "finite" | "integer" | undefined;
            readonly uniqueBy?: ((value: any) => unknown) | undefined;
        }
        /**
         * Raw constraint contribution attached to a Schema filter.
         *
         * **Details**
         *
         * `order` identifies the domain while the compiler merges bounds. It is removed before normalized constraints reach
         * a declaration callback.
         *
         * @category models
         * @since 4.0.0
         */
        interface FilterConstraint<T = unknown> extends GenerationConstraint<T> {
            readonly order?: Order.Order<T> | undefined;
        }
        /**
         * Input provided to a declaration's native arbitrary callback.
         *
         * @category models
         * @since 4.0.0
         */
        interface DeclarationInput<T, Parameters extends ReadonlyArray<Constraint>> {
            readonly typeParameters: TypeParameters.Type<Parameters>;
            readonly constraint: GenerationConstraint<T> | undefined;
        }
        /**
         * Selects a Schema Link whose source representation is optimized for native arbitrary generation.
         *
         * @category models
         * @since 4.0.0
         */
        interface Declaration<T, Parameters extends ReadonlyArray<Constraint>> {
            (input: DeclarationInput<T, Parameters>): SchemaAST.Link;
        }
    }
    /**
     * Types used by formatter annotations to customize formatter derivation for
     * declaration schemas.
     *
     * @since 4.0.0
     */
    namespace ToFormatter {
        /**
         * Hook signature for declaration schema formatter annotations.
         *
         * **Details**
         *
         * Given formatters for any type parameters, returns a formatter for `T`.
         *
         * @category models
         * @since 4.0.0
         */
        interface Declaration<T, TypeParameters extends ReadonlyArray<Constraint>> {
            (typeParameters: {
                readonly [K in keyof TypeParameters]: Formatter<TypeParameters[K]["Type"]>;
            }): Formatter<T>;
        }
    }
    /**
     * Types used by equivalence annotations to customize equivalence derivation for
     * declaration schemas.
     *
     * @since 4.0.0
     */
    namespace ToEquivalence {
        /**
         * Hook signature for declaration schema equivalence annotations.
         *
         * **Details**
         *
         * Given equivalences for any type parameters, returns an `Equivalence` for `T`.
         *
         * @category models
         * @since 4.0.0
         */
        interface Declaration<T, TypeParameters extends ReadonlyArray<Constraint>> {
            (typeParameters: {
                readonly [K in keyof TypeParameters]: Equivalence.Equivalence<TypeParameters[K]["Type"]>;
            }): Equivalence.Equivalence<T>;
        }
    }
    /**
     * Annotations that can be attached to schema issues.
     *
     * **Details**
     *
     * For `InvalidValue` issues, `message` overrides the complete formatted
     * message. When `message` is absent, `expected` uses the default expected
     * value policy, including reported input when available. Other issue types
     * ignore `expected`.
     *
     * @category models
     * @since 4.0.0
     */
    interface Issue extends Annotations {
        /**
         * The expected value description for an `InvalidValue` issue.
         */
        readonly expected?: string | undefined;
        /**
         * The complete formatted message for the issue.
         */
        readonly message?: string | undefined;
    }
}
//# sourceMappingURL=Schema.d.ts.map