import { AnySchema, InferObject, InferSchema, SchemaDefinition, SchemaType } from "./core/types.mjs";
import { ArraySchema, InstanceOfSchema, LiteralSchema, NullSchemaType, OptionalSchema, UnionSchema } from "./core/base.mjs";
import { AnySchemaType, NeverSchemaType, UnknownSchemaType } from "./schemas/any.mjs";
import { BigIntSchemaType } from "./schemas/bigint.mjs";
import { BooleanSchemaType } from "./schemas/boolean.mjs";
import { DefaultSchema } from "./schemas/default.mjs";
import { ObjectSchemaType } from "./schemas/object.mjs";
import { DiscriminatedUnionSchema } from "./schemas/discriminated-union.mjs";
import { IntersectionSchema } from "./schemas/intersection.mjs";
import { LazySchema } from "./schemas/lazy.mjs";
import { MapSchema } from "./schemas/map.mjs";
import { NumberSchemaType } from "./schemas/number.mjs";
import { RecordSchema } from "./schemas/record.mjs";
import { RefineCheck, RefineSchema } from "./schemas/refine.mjs";
import { SetSchema } from "./schemas/set.mjs";
import { StringSchemaType } from "./schemas/string.mjs";
import { PipeSchema, TransformSchema } from "./schemas/transform.mjs";
import { TupleSchema } from "./schemas/tuple.mjs";
import { UndefinedSchemaType, VoidSchemaType } from "./schemas/undefined.mjs";
import { getJsonSchema, toStandard } from "./to-standard.mjs";
//#region src/h.d.ts
/**
 * The `h` builder: factory functions for constructing validation schemas.
 *
 * @example
 * const user = h.object({ id: h.uuid(), name: h.string().minLength(1) });
 */
declare const h: {
  /** Create a string schema. */
  string: () => StringSchemaType;
  /** Create a number schema. */
  number: () => NumberSchemaType;
  /** Create a boolean schema. */
  boolean: () => BooleanSchemaType;
  /** Create a bigint schema. */
  bigint: () => BigIntSchemaType;
  /** Create a null schema. */
  null: () => NullSchemaType;
  /** Alias of {@link h.null}. */
  nullable: () => NullSchemaType;
  /** Create an undefined schema. */
  undefined: () => UndefinedSchemaType;
  /** Create a void schema. */
  void: () => VoidSchemaType;
  /** Create an `any` schema. */
  any: () => AnySchemaType;
  /** Create an `unknown` schema. */
  unknown: () => UnknownSchemaType;
  /** Create a `never` schema (always fails). */
  never: () => NeverSchemaType;
  /**
   * Literal value schema.
   * @param value Literal value to match.
   */
  literal: <T extends string | number | boolean>(value: T) => LiteralSchema<unknown, T>;
  /**
   * Object schema.
   * @param schemaDef Field definitions.
   */
  object: <S extends SchemaDefinition>(schemaDef?: S) => ObjectSchemaType<InferObject<S>>;
  /**
   * Record schema (object with dynamic keys).
   * @param keyOrValue Key schema (when 2 args) or value schema (when 1 arg).
   * @param maybeValue Value schema if a key schema was provided.
   */
  record: {
    <V extends AnySchema>(value: V): RecordSchema<string, SchemaType<V>>;
    <K extends AnySchema, V extends AnySchema>(key: K, value: V): RecordSchema<SchemaType<K> & (string | number), SchemaType<V>>;
  };
  /**
   * Tuple schema (fixed-length, positional).
   * @param schemas Item schemas.
   */
  tuple: <S extends AnySchema[]>(...schemas: S) => TupleSchema<unknown, { [K in keyof S]: SchemaType<S[K]>; }>;
  /**
   * Map schema.
   * @param key Key schema.
   * @param value Value schema.
   */
  map: <K extends AnySchema, V extends AnySchema>(key: K, value: V) => MapSchema<SchemaType<K>, SchemaType<V>>;
  /**
   * Set schema.
   * @param value Value schema.
   */
  set: <V extends AnySchema>(value: V) => SetSchema<SchemaType<V>>;
  /**
   * Intersection schema (combines all schemas).
   * @param schemas Schemas to intersect.
   */
  intersection: <S extends AnySchema[]>(...schemas: S) => IntersectionSchema<unknown, InferSchema<S[number]>>;
  /**
   * Discriminated union: faster than `options` for tagged unions.
   * @param discriminator Field name acting as the tag.
   * @param options Object schemas, each with the discriminator as a literal.
   */
  discriminatedUnion: <D extends string>(discriminator: D, options: ObjectSchemaType<any>[]) => DiscriminatedUnionSchema<D, any>;
  /**
   * Lazy schema for recursive types.
   * @param getter Function returning the inner schema.
   */
  lazy: <S extends AnySchema>(getter: () => S) => LazySchema<unknown, InferSchema<S>>;
  /**
   * Default value when the input is undefined or null.
   * @param schema Inner schema.
   * @param defaultValue Value or factory.
   */
  default: <S extends AnySchema>(schema: S, defaultValue: InferSchema<S> | (() => InferSchema<S>)) => DefaultSchema<unknown, InferSchema<S>>;
  /**
   * Apply a transformation to the validated value.
   * @param schema Inner schema.
   * @param fn Transform function.
   */
  transform: <S extends AnySchema, Out>(schema: S, fn: (value: InferSchema<S>) => Out) => TransformSchema<unknown, InferSchema<S>, Out>;
  /**
   * Apply a custom validation predicate.
   * @param schema Inner schema.
   * @param check Predicate returning true / false / message / issues.
   * @param message Default message when predicate returns false.
   */
  refine: <S extends AnySchema>(schema: S, check: RefineCheck<InferSchema<S>>, message?: string) => RefineSchema<unknown, InferSchema<S>>;
  /**
   * Pipe one schema's output into another schema's input.
   * @param a First schema.
   * @param b Second schema receiving `a`'s output.
   */
  pipe: <A extends AnySchema, B extends AnySchema>(a: A, b: B) => PipeSchema<unknown, InferSchema<A>, InferSchema<B>>;
  /**
   * Array schema.
   * @param schema Item schema.
   */
  array: <S extends AnySchema>(schema: S) => ArraySchema<unknown, SchemaType<S>[]>;
  /**
   * Enum schema from a list of literal values.
   * @param values Allowed literals.
   */
  enum: <T extends string | number | boolean, Values extends readonly [T, ...T[]]>(values: Values) => UnionSchema<unknown, Values[number]>;
  /**
   * Optional schema (allows undefined).
   * @param schema Inner schema.
   */
  optional: <S extends AnySchema>(schema: S) => OptionalSchema<unknown, InferSchema<S> | undefined>;
  /**
   * Union schema (succeeds if any branch succeeds).
   * @param schemas Branch schemas.
   */
  options: <S extends AnySchema[]>(...schemas: S) => UnionSchema<unknown, InferSchema<S[number]>>;
  /**
   * Alias of {@link h.options}.
   */
  union: <S extends AnySchema[]>(...schemas: S) => UnionSchema<unknown, InferSchema<S[number]>>;
  /**
   * Restrict to instances of a constructor.
   * @param constructor Class constructor.
   */
  instanceOf: <C extends new (...args: any[]) => any>(constructor: C) => InstanceOfSchema<unknown, InstanceType<C>>;
  /** Date string schema. */
  date: () => StringSchemaType;
  /** UUID string schema. */
  uuid: () => StringSchemaType;
  /** Regex string schema. */
  regex: (regex: RegExp) => StringSchemaType;
  /** Email string schema. */
  email: () => StringSchemaType;
  /** Phone string schema. */
  phone: () => StringSchemaType;
  /** Domain string schema. */
  domain: (requireHttpOrHttps?: boolean) => StringSchemaType;
  /**
   * Coerce-then-validate factories. Equivalent to `h.X().coerce()`.
   */
  coerce: {
    /** Coerce input to string. */
    string: () => StringSchemaType;
    /** Coerce input to number. */
    number: () => NumberSchemaType;
    /** Coerce input to boolean. */
    boolean: () => BooleanSchemaType;
    /** Coerce input to bigint. */
    bigint: () => BigIntSchemaType;
  };
  /** Re-export of {@link toStandard}. */
  toStandard: typeof toStandard;
  /**
   * Get JSON Schema from a validation schema.
   * @param schema Schema to convert.
   * @param options Conversion options.
   */
  getJsonSchema: typeof getJsonSchema;
};
//#endregion
export { h };
//# sourceMappingURL=h.d.mts.map