import { StandardSchemaV1 } from "../standard-schema/types.mjs";
import { Schema } from "../types/schema-types.mjs";
import { SchemaContext } from "../types/context-types.mjs";
import { ValidationResult } from "../types/result-types.mjs";
import { Infer } from "../types/inference-types.mjs";
import { BaseValidator } from "../validators/base-validator.mjs";
import { AnyValidator } from "../validators/any-validator.mjs";
import { ArrayValidator } from "../validators/array-validator.mjs";
import { BooleanValidator } from "../validators/boolean-validator.mjs";
import { ComputedValidator } from "../validators/computed-validator.mjs";
import { DateValidator } from "../validators/date-validator.mjs";
import { ObjectValidator } from "../validators/object-validator.mjs";
import { DiscriminatedUnionValidator } from "../validators/discriminated-union-validator.mjs";
import { NumberValidator } from "../validators/number-validator.mjs";
import { FloatValidator } from "../validators/float-validator.mjs";
import { InstanceOfValidator } from "../validators/instanceof-validator.mjs";
import { IntValidator } from "../validators/int-validator.mjs";
import { LazyValidator } from "../validators/lazy-validator.mjs";
import { LiteralValidator } from "../validators/literal-validator.mjs";
import { ManagedValidator } from "../validators/managed-validator.mjs";
import { NumericValidator } from "../validators/numeric-validator.mjs";
import { RecordValidator } from "../validators/record-validator.mjs";
import { ScalarValidator } from "../validators/scalar-validator.mjs";
import { StringValidator } from "../validators/string-validator.mjs";
import { TupleValidator } from "../validators/tuple-validator.mjs";
import { UnionValidator } from "../validators/union-validator.mjs";
import { SealConfig } from "../config.mjs";

//#region ../@warlock.js/seal/src/factory/validators.d.ts
/**
 * Seal factory object - creates instances of validators
 *
 * Use 'v' to create validation schemas (seals) for your data
 */
declare const v: ValidatorV;
type ValidateOptions = {
  context?: Record<string, any>;
} & SealConfig;
interface ValidatorV {
  object: <T extends Schema>(schema: T, errorMessage?: string) => ObjectValidator<T> & StandardSchemaV1<Infer<ObjectValidator<T>>>;
  any: () => AnyValidator & StandardSchemaV1<any>;
  array: <T extends BaseValidator>(validator: T, errorMessage?: string) => ArrayValidator & {
    validator: T;
  } & StandardSchemaV1<Array<Infer<T>>>;
  record: <T extends BaseValidator>(validator?: T, errorMessage?: string) => RecordValidator & {
    valueValidator: T;
  } & StandardSchemaV1<Record<string, Infer<T>>>;
  tuple: <T extends BaseValidator[]>(validators: T, errorMessage?: string) => TupleValidator & {
    validators: T;
  } & StandardSchemaV1<{ [K in keyof T]: Infer<T[K]> }>;
  date: (errorMessage?: string) => DateValidator & StandardSchemaV1<Date>;
  literal: <T extends readonly [string | number | boolean, ...(string | number | boolean)[]]>(...values: T) => LiteralValidator<T> & StandardSchemaV1<T[number]>;
  instanceof: <T>(ctor: new (...args: any[]) => T, errorMessage?: string) => InstanceOfValidator<T> & StandardSchemaV1<T>;
  lazy: <T extends BaseValidator>(thunk: () => T) => LazyValidator<T> & StandardSchemaV1<Infer<T>>;
  string: (errorMessage?: string) => StringValidator & StandardSchemaV1<string>;
  email: (errorMessage?: string) => StringValidator & StandardSchemaV1<string>;
  enum: {
    <const T extends readonly (string | number | boolean)[]>(values: T, errorMessage?: string): ScalarValidator & StandardSchemaV1<T[number]>;
    <const T extends Record<string, string | number>>(values: T, errorMessage?: string): ScalarValidator & StandardSchemaV1<T[keyof T]>;
  };
  number: (errorMessage?: string) => NumberValidator & StandardSchemaV1<number>;
  numeric: (errorMessage?: string) => NumericValidator & StandardSchemaV1<number>;
  int: (errorMessage?: string) => IntValidator & StandardSchemaV1<number>;
  float: (errorMessage?: string) => FloatValidator & StandardSchemaV1<number>;
  boolean: (errorMessage?: string) => BooleanValidator & StandardSchemaV1<boolean>;
  scalar: (errorMessage?: string) => ScalarValidator & StandardSchemaV1<string | number | boolean>;
  union: <T extends BaseValidator[]>(validators: T, errorMessage?: string) => UnionValidator & StandardSchemaV1<Infer<T[number]>>;
  discriminatedUnion: <K extends string, Branches extends ReadonlyArray<ObjectValidator<any>>>(discriminator: K, validators: Branches) => DiscriminatedUnionValidator<K, Branches> & StandardSchemaV1<Infer<Branches[number]>>;
  computed: <TResult = any>(callback: (data: any, context: SchemaContext) => TResult | Promise<TResult>, resultValidator?: BaseValidator) => ComputedValidator<TResult> & StandardSchemaV1<TResult>;
  managed: <TResult = any>(callback?: (context: SchemaContext) => TResult | Promise<TResult>, resultValidator?: BaseValidator) => ManagedValidator<TResult> & StandardSchemaV1<TResult>;
  validate: <T extends BaseValidator>(schema: T, data: any, options?: ValidateOptions) => Promise<ValidationResult>;
}
//#endregion
export { ValidateOptions, ValidatorV, v };
//# sourceMappingURL=validators.d.mts.map