@whatsaaaa/form-builder-schema 0.1.0 → 0.3.0

package/dist/index.d.ts

@@ -1,83 +1,573 @@
 import * as v from "valibot";
 type AnySchema = v.GenericSchema;
 type AnyAction = v.GenericPipeAction;
-type ValueKind = 'string' | 'number';
-type FieldType = 'text' | 'email' | 'password' | 'number';
+/**
+ * A `v.object()` schema. The builder reads its `entries` to find unknown keys.
+ */
+type AnyObjectSchema = v.ObjectSchema<v.ObjectEntries, v.ErrorMessage<v.ObjectIssue> | undefined>;
+interface KindDef {
+  /** True when the input means "no value". */
+  isEmpty(input: unknown): boolean;
+  /** Extra check for required fieldsd after normalize rules ran. Omit it when isEmpty is enough. */
+  required?(message: string): AnyAction | null;
+}
+/**
+ * The built-in kinds, plus any string so consumers can register their own.
+ */
+type ValueKind = 'string' | 'number' | 'boolean' | 'date' | 'array' | 'file' | 'object' | 'none' | (string & {});
+interface JsonForm {
+  version: '1';
+  fields: readonly JsonField[];
+}
 interface JsonField {
-  name: string;
-  type: FieldType;
+  name?: string;
+  type: string;
+  label?: string;
+  description?: string;
+  placeholder?: string;
+  default?: unknown;
   required?: boolean | {
     message?: string;
   };
   rules?: readonly JsonRule[];
+  /** For renderers. This package never reads or checks it. */
+  ui?: Record<string, unknown>;
+  /** Validated by the field type's props schema, */
+  [prop: string]: unknown;
 }
 interface JsonRule {
   rule: string;
   message?: string;
   [param: string]: unknown;
 }
-interface JsonFormSchema {
-  version: '1';
-  fields: readonly JsonField[];
+/** Where something is in a definition, e.g. `['fields', 0, 'rules', 1]`. */
+type DefinitionPath = readonly (string | number)[];
+/** Public API: adding a code is a minor change, renaming one is breaking, */
+type DefinitionIssueCode = 'invalid_shape' | 'unsupported_version' | 'unknown_key' | 'unknown_type' | 'missing_name' | 'duplicate_name' | 'invalid_props' | 'unknown_rule' | 'unknown_param' | 'invalid_params' | 'kind_mismatch';
+interface DefinitionIssue {
+  code: DefinitionIssueCode;
+  path: DefinitionPath;
+  message: string;
 }
-interface RuleDef<TParams extends AnySchema = AnySchema> {
-  kinds: readonly ValueKind[];
-  params: TParams;
-  create(params: v.InferOutput<TParams>, message?: string): AnyAction;
+type ValidateResult = {
+  success: true;
+  issues: [];
+} | {
+  success: false;
+  issues: DefinitionIssue[];
+};
+export declare function formatPath(path: DefinitionPath): string;
+/** Thrown by `build()` when the definition has issues. Lists all of them. */
+export declare class DefinitionError extends Error {
+  readonly issues: readonly DefinitionIssue[];
+  constructor(issues: readonly DefinitionIssue[]);
 }
-interface FieldTypeDef {
+interface FieldTypeDef<TProps extends AnyObjectSchema = AnyObjectSchema> {
   kind: ValueKind;
-  base: (message?: string) => AnySchema;
+  /** Extra keys this type accepts on a field, e.g. `options` on a select. */
+  props?: TProps;
+  /**
+   * The base schema for the field's value. Required unless `kind` is `'none'`.
+   * Method syntax keeps it bivariant, so typed field types fit in a `Record<string, FieldTypeDef>`.
+   */
+  schema?(field: FieldWithProps<TProps>, ctx: BuildContext): AnySchema;
+  /** Rules every field of this type gets. A field rule with the same name replaces one. */
   defaultRules?: readonly JsonRule[];
 }
+/** A field with its type's props parsed and typed. */
+type FieldWithProps<TProps extends AnyObjectSchema = AnyObjectSchema> = JsonField & v.InferOutput<TProps>;
+interface BuildContext {
+  /** Where the field is in the definition, e.g. `['fields', 2]`. */
+  readonly path: DefinitionPath;
+}
+/**
+ * `normalize` rules (trim, change case) run before the required check, so `'    '` with `trim` counts
+ * as empty. `validate` rules run after it.
+ */
+type RuleStage = 'normalize' | 'validate';
+/** Groups rules in the builder app. One per rule family. */
+type RuleCategory = 'length' | 'text' | 'content' | 'format' | 'date' | 'comparison' | 'number' | 'file' | 'normalize';
+/** Describes a rule to people, e.g. in the builder app's rule picker. */
+interface RuleMeta {
+  label: string;
+  description?: string;
+  category: RuleCategory;
+}
+interface RuleDef<TParams extends AnyObjectSchema = AnyObjectSchema> {
+  kinds: readonly ValueKind[];
+  /** Defaults to `'validate'`. */
+  stage?: RuleStage;
+  /**
+   * The params the rule takes. Omit it for rules without params. Unknown params are rejected.
+   * A function gets the field's kind, for params that depend on it (`minValue` takes a number
+   * on a number field, and an ISO string on a date field). It is called once per kind.
+   */
+  params?: TParams | ((kind: ValueKind) => TParams);
+  meta?: RuleMeta;
+  /** Method syntax keeps `create` bivariant, so specific rules fit in a `Record<string, RuleDef>`. */
+  create(params: v.InferOutput<TParams>, message?: string): AnyAction;
+}
+interface MessageContext {
+  field: JsonField;
+  rule?: string;
+  path: DefinitionPath;
+}
 interface SchemaBuilderOptions {
+  kinds?: Record<string, KindDef>;
   fieldTypes?: Record<string, FieldTypeDef>;
   rules?: Record<string, RuleDef>;
+  includeDefaultRules?: boolean;
+  messages?: {
+    required?: string;
+  };
+  /**
+   * Called with every message from the definition and with `messages.required`, e.g. to treat
+   * them as i18n keys. Return undefined  to use the text as written.
+   */
+  resolveMessage?(key: string, ctx: MessageContext): string | undefined;
 }
-export declare function createSchemaBuilder(opts?: SchemaBuilderOptions): (json: JsonFormSchema) => v.ObjectSchema<v.ObjectEntries, undefined>;
+export declare function createSchemaBuilder(options?: SchemaBuilderOptions): {
+  build: (json: JsonForm) => v.ObjectSchema<v.ObjectEntries, undefined>;
+  validate: (json: unknown) => ValidateResult;
+  rulesForKind: (kind: ValueKind) => [name: string, def: RuleDef][];
+  kinds: Readonly<Record<string, KindDef>>;
+  fieldTypes: Readonly<Record<string, FieldTypeDef<AnyObjectSchema>>>;
+  rules: Readonly<Record<string, RuleDef<AnyObjectSchema>>>;
+};
 export declare const defaultFieldTypes: {
   text: {
     kind: "string";
-    base: (m: string | undefined) => v.StringSchema<string | undefined>;
+    schema: () => v.StringSchema<undefined>;
   };
   password: {
     kind: "string";
-    base: (m: string | undefined) => v.StringSchema<string | undefined>;
+    schema: () => v.StringSchema<undefined>;
   };
   email: {
     kind: "string";
-    base: (m: string | undefined) => v.StringSchema<string | undefined>;
+    schema: () => v.StringSchema<undefined>;
     defaultRules: {
       rule: string;
-      message: string;
     }[];
   };
   number: {
     kind: "number";
-    base: (m: string | undefined) => v.NumberSchema<string | undefined>;
+    schema: () => v.NumberSchema<undefined>;
   };
 };
-export declare const defineRule: <T extends AnySchema>(def: RuleDef<T>) => RuleDef<T>;
+export declare const defineFieldType: <T extends AnyObjectSchema>(def: FieldTypeDef<T>) => FieldTypeDef<T>;
+export declare const defaultKinds: {
+  string: {
+    isEmpty: (input: unknown) => input is "" | null | undefined;
+    required: (message: string) => v.NonEmptyAction<any, string>;
+  };
+  number: {
+    isEmpty: (input: unknown) => boolean;
+  };
+  boolean: {
+    isEmpty: (input: unknown) => input is null | undefined;
+    required: (message: string) => v.ValueAction<any, true, string>;
+  };
+  date: {
+    isEmpty: (input: unknown) => input is "" | null | undefined;
+    required: (message: string) => v.NonEmptyAction<any, string>;
+  };
+  array: {
+    isEmpty: (input: unknown) => boolean;
+    required: (message: string) => v.MinLengthAction<any, 1, string>;
+  };
+  file: {
+    isEmpty: (input: unknown) => input is null | undefined;
+  };
+  object: {
+    isEmpty: (input: unknown) => input is null | undefined;
+  };
+  none: {
+    isEmpty: () => true;
+  };
+};
+/** Compares the value with a param of the same type. */
+export declare const comparisonRules: {
+  minValue: RuleDef<v.ObjectSchema<{
+    readonly value: v.StringSchema<undefined> | v.NumberSchema<undefined> | v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Use an ISO date, date-time or time, such as 2026-01-01">]> | v.BooleanSchema<undefined>;
+  }, undefined>>;
+  maxValue: RuleDef<v.ObjectSchema<{
+    readonly value: v.StringSchema<undefined> | v.NumberSchema<undefined> | v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Use an ISO date, date-time or time, such as 2026-01-01">]> | v.BooleanSchema<undefined>;
+  }, undefined>>;
+  gtValue: RuleDef<v.ObjectSchema<{
+    readonly value: v.StringSchema<undefined> | v.NumberSchema<undefined> | v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Use an ISO date, date-time or time, such as 2026-01-01">]> | v.BooleanSchema<undefined>;
+  }, undefined>>;
+  ltValue: RuleDef<v.ObjectSchema<{
+    readonly value: v.StringSchema<undefined> | v.NumberSchema<undefined> | v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Use an ISO date, date-time or time, such as 2026-01-01">]> | v.BooleanSchema<undefined>;
+  }, undefined>>;
+  value: RuleDef<v.ObjectSchema<{
+    readonly value: v.StringSchema<undefined> | v.NumberSchema<undefined> | v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Use an ISO date, date-time or time, such as 2026-01-01">]> | v.BooleanSchema<undefined>;
+  }, undefined>>;
+  notValue: RuleDef<v.ObjectSchema<{
+    readonly value: v.StringSchema<undefined> | v.NumberSchema<undefined> | v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Use an ISO date, date-time or time, such as 2026-01-01">]> | v.BooleanSchema<undefined>;
+  }, undefined>>;
+  values: RuleDef<v.ObjectSchema<{
+    readonly values: v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined> | v.NumberSchema<undefined> | v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Use an ISO date, date-time or time, such as 2026-01-01">]> | v.BooleanSchema<undefined>, undefined>, v.MinLengthAction<(string | number | boolean)[], 1, "Give at least one value">]>;
+  }, undefined>>;
+  notValues: RuleDef<v.ObjectSchema<{
+    readonly values: v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined> | v.NumberSchema<undefined> | v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Use an ISO date, date-time or time, such as 2026-01-01">]> | v.BooleanSchema<undefined>, undefined>, v.MinLengthAction<(string | number | boolean)[], 1, "Give at least one value">]>;
+  }, undefined>>;
+};
+export declare const contentRules: {
+  regex: RuleDef<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly pattern: v.StringSchema<undefined>;
+    readonly flags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Flags can be d, g, i, m, s, u, v and y">]>, undefined>;
+  }, undefined>, v.BaseValidation<{
+    pattern: string;
+    flags?: string | undefined;
+  }, {
+    pattern: string;
+    flags?: string | undefined;
+  }, v.CheckIssue<{
+    pattern: string;
+    flags?: string | undefined;
+  }>>]>>;
+  startsWith: RuleDef<v.ObjectSchema<{
+    readonly value: v.StringSchema<undefined>;
+  }, undefined>>;
+  endsWith: RuleDef<v.ObjectSchema<{
+    readonly value: v.StringSchema<undefined>;
+  }, undefined>>;
+  includes: RuleDef<v.ObjectSchema<{
+    readonly value: v.StringSchema<undefined> | v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>], undefined>;
+  }, undefined>>;
+  excludes: RuleDef<v.ObjectSchema<{
+    readonly value: v.StringSchema<undefined> | v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>], undefined>;
+  }, undefined>>;
+};
+export declare const dateRules: {
+  isoDate: RuleDef<AnyObjectSchema>;
+  isoDateTime: RuleDef<AnyObjectSchema>;
+  isoTime: RuleDef<AnyObjectSchema>;
+  isoTimeSecond: RuleDef<AnyObjectSchema>;
+  isoTimestamp: RuleDef<AnyObjectSchema>;
+  isoWeek: RuleDef<AnyObjectSchema>;
+};
+/** Every built-in rule. Register single families with `includeDefaultRules: false`. */
 export declare const defaultRules: {
+  trim: RuleDef<AnyObjectSchema>;
+  trimStart: RuleDef<AnyObjectSchema>;
+  trimEnd: RuleDef<AnyObjectSchema>;
+  toLowerCase: RuleDef<AnyObjectSchema>;
+  toUpperCase: RuleDef<AnyObjectSchema>;
+  normalize: RuleDef<import("valibot").ObjectSchema<{
+    readonly form: import("valibot").OptionalSchema<import("valibot").PicklistSchema<["NFC", "NFD", "NFKC", "NFKD"], undefined>, undefined>;
+  }, undefined>>;
+  toMinValue: RuleDef<import("valibot").ObjectSchema<{
+    readonly value: import("valibot").NumberSchema<undefined>;
+  }, undefined>>;
+  toMaxValue: RuleDef<import("valibot").ObjectSchema<{
+    readonly value: import("valibot").NumberSchema<undefined>;
+  }, undefined>>;
+  minSize: RuleDef<import("valibot").ObjectSchema<{
+    readonly value: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+  maxSize: RuleDef<import("valibot").ObjectSchema<{
+    readonly value: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+  size: RuleDef<import("valibot").ObjectSchema<{
+    readonly value: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+  notSize: RuleDef<import("valibot").ObjectSchema<{
+    readonly value: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+  mimeType: RuleDef<import("valibot").ObjectSchema<{
+    readonly types: import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RegexAction<string, "Use a MIME type, such as image/png">]>, undefined>, import("valibot").MinLengthAction<string[], 1, "Give at least one MIME type">]>;
+  }, undefined>>;
+  integer: RuleDef<AnyObjectSchema>;
+  safeInteger: RuleDef<AnyObjectSchema>;
+  finite: RuleDef<AnyObjectSchema>;
+  multipleOf: RuleDef<import("valibot").ObjectSchema<{
+    readonly value: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").FiniteAction<number, undefined>, import("valibot").NotValueAction<number, 0, "Can't be 0">]>;
+  }, undefined>>;
+  minValue: RuleDef<import("valibot").ObjectSchema<{
+    readonly value: import("valibot").StringSchema<undefined> | import("valibot").NumberSchema<undefined> | import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string, "Use an ISO date, date-time or time, such as 2026-01-01">]> | import("valibot").BooleanSchema<undefined>;
+  }, undefined>>;
+  maxValue: RuleDef<import("valibot").ObjectSchema<{
+    readonly value: import("valibot").StringSchema<undefined> | import("valibot").NumberSchema<undefined> | import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string, "Use an ISO date, date-time or time, such as 2026-01-01">]> | import("valibot").BooleanSchema<undefined>;
+  }, undefined>>;
+  gtValue: RuleDef<import("valibot").ObjectSchema<{
+    readonly value: import("valibot").StringSchema<undefined> | import("valibot").NumberSchema<undefined> | import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string, "Use an ISO date, date-time or time, such as 2026-01-01">]> | import("valibot").BooleanSchema<undefined>;
+  }, undefined>>;
+  ltValue: RuleDef<import("valibot").ObjectSchema<{
+    readonly value: import("valibot").StringSchema<undefined> | import("valibot").NumberSchema<undefined> | import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string, "Use an ISO date, date-time or time, such as 2026-01-01">]> | import("valibot").BooleanSchema<undefined>;
+  }, undefined>>;
+  value: RuleDef<import("valibot").ObjectSchema<{
+    readonly value: import("valibot").StringSchema<undefined> | import("valibot").NumberSchema<undefined> | import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string, "Use an ISO date, date-time or time, such as 2026-01-01">]> | import("valibot").BooleanSchema<undefined>;
+  }, undefined>>;
+  notValue: RuleDef<import("valibot").ObjectSchema<{
+    readonly value: import("valibot").StringSchema<undefined> | import("valibot").NumberSchema<undefined> | import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string, "Use an ISO date, date-time or time, such as 2026-01-01">]> | import("valibot").BooleanSchema<undefined>;
+  }, undefined>>;
+  values: RuleDef<import("valibot").ObjectSchema<{
+    readonly values: import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").StringSchema<undefined> | import("valibot").NumberSchema<undefined> | import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string, "Use an ISO date, date-time or time, such as 2026-01-01">]> | import("valibot").BooleanSchema<undefined>, undefined>, import("valibot").MinLengthAction<(string | number | boolean)[], 1, "Give at least one value">]>;
+  }, undefined>>;
+  notValues: RuleDef<import("valibot").ObjectSchema<{
+    readonly values: import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").StringSchema<undefined> | import("valibot").NumberSchema<undefined> | import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string, "Use an ISO date, date-time or time, such as 2026-01-01">]> | import("valibot").BooleanSchema<undefined>, undefined>, import("valibot").MinLengthAction<(string | number | boolean)[], 1, "Give at least one value">]>;
+  }, undefined>>;
+  isoDate: RuleDef<AnyObjectSchema>;
+  isoDateTime: RuleDef<AnyObjectSchema>;
+  isoTime: RuleDef<AnyObjectSchema>;
+  isoTimeSecond: RuleDef<AnyObjectSchema>;
+  isoTimestamp: RuleDef<AnyObjectSchema>;
+  isoWeek: RuleDef<AnyObjectSchema>;
+  email: RuleDef<AnyObjectSchema>;
+  rfcEmail: RuleDef<AnyObjectSchema>;
+  url: RuleDef<AnyObjectSchema>;
+  domain: RuleDef<AnyObjectSchema>;
+  slug: RuleDef<AnyObjectSchema>;
+  uuid: RuleDef<AnyObjectSchema>;
+  ulid: RuleDef<AnyObjectSchema>;
+  cuid2: RuleDef<AnyObjectSchema>;
+  nanoid: RuleDef<AnyObjectSchema>;
+  ip: RuleDef<AnyObjectSchema>;
+  ipv4: RuleDef<AnyObjectSchema>;
+  ipv6: RuleDef<AnyObjectSchema>;
+  mac: RuleDef<AnyObjectSchema>;
+  mac48: RuleDef<AnyObjectSchema>;
+  mac64: RuleDef<AnyObjectSchema>;
+  hexColor: RuleDef<AnyObjectSchema>;
+  hexadecimal: RuleDef<AnyObjectSchema>;
+  octal: RuleDef<AnyObjectSchema>;
+  decimal: RuleDef<AnyObjectSchema>;
+  digits: RuleDef<AnyObjectSchema>;
+  base64: RuleDef<AnyObjectSchema>;
+  bic: RuleDef<AnyObjectSchema>;
+  creditCard: RuleDef<AnyObjectSchema>;
+  imei: RuleDef<AnyObjectSchema>;
+  isbn: RuleDef<AnyObjectSchema>;
+  isrc: RuleDef<AnyObjectSchema>;
+  emoji: RuleDef<AnyObjectSchema>;
+  hash: RuleDef<import("valibot").ObjectSchema<{
+    readonly types: import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").PicklistSchema<readonly ["md4", "md5", "sha1", "sha256", "sha384", "sha512", "ripemd128", "ripemd160", "tiger128", "tiger160", "tiger192", "crc32", "crc32b", "adler32"], undefined>, undefined>, import("valibot").MinLengthAction<("md4" | "md5" | "sha1" | "sha256" | "sha384" | "sha512" | "ripemd128" | "ripemd160" | "tiger128" | "tiger160" | "tiger192" | "crc32" | "crc32b" | "adler32")[], 1, "Pick at least one hash type">]>;
+  }, undefined>>;
+  regex: RuleDef<import("valibot").SchemaWithPipe<readonly [import("valibot").ObjectSchema<{
+    readonly pattern: import("valibot").StringSchema<undefined>;
+    readonly flags: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RegexAction<string, "Flags can be d, g, i, m, s, u, v and y">]>, undefined>;
+  }, undefined>, import("valibot").BaseValidation<{
+    pattern: string;
+    flags?: string | undefined;
+  }, {
+    pattern: string;
+    flags?: string | undefined;
+  }, import("valibot").CheckIssue<{
+    pattern: string;
+    flags?: string | undefined;
+  }>>]>>;
+  startsWith: RuleDef<import("valibot").ObjectSchema<{
+    readonly value: import("valibot").StringSchema<undefined>;
+  }, undefined>>;
+  endsWith: RuleDef<import("valibot").ObjectSchema<{
+    readonly value: import("valibot").StringSchema<undefined>;
+  }, undefined>>;
+  includes: RuleDef<import("valibot").ObjectSchema<{
+    readonly value: import("valibot").StringSchema<undefined> | import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>, import("valibot").BooleanSchema<undefined>], undefined>;
+  }, undefined>>;
+  excludes: RuleDef<import("valibot").ObjectSchema<{
+    readonly value: import("valibot").StringSchema<undefined> | import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>, import("valibot").BooleanSchema<undefined>], undefined>;
+  }, undefined>>;
+  graphemes: RuleDef<import("valibot").ObjectSchema<{
+    readonly value: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+  minGraphemes: RuleDef<import("valibot").ObjectSchema<{
+    readonly value: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+  maxGraphemes: RuleDef<import("valibot").ObjectSchema<{
+    readonly value: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+  notGraphemes: RuleDef<import("valibot").ObjectSchema<{
+    readonly value: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+  words: RuleDef<import("valibot").ObjectSchema<{
+    readonly locale: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string, "Use a language tag, such as en or sr-Latn">]>, undefined>;
+    readonly value: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+  minWords: RuleDef<import("valibot").ObjectSchema<{
+    readonly locale: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string, "Use a language tag, such as en or sr-Latn">]>, undefined>;
+    readonly value: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+  maxWords: RuleDef<import("valibot").ObjectSchema<{
+    readonly locale: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string, "Use a language tag, such as en or sr-Latn">]>, undefined>;
+    readonly value: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+  notWords: RuleDef<import("valibot").ObjectSchema<{
+    readonly locale: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string, "Use a language tag, such as en or sr-Latn">]>, undefined>;
+    readonly value: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+  bytes: RuleDef<import("valibot").ObjectSchema<{
+    readonly value: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+  minBytes: RuleDef<import("valibot").ObjectSchema<{
+    readonly value: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+  maxBytes: RuleDef<import("valibot").ObjectSchema<{
+    readonly value: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+  notBytes: RuleDef<import("valibot").ObjectSchema<{
+    readonly value: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+  length: RuleDef<import("valibot").ObjectSchema<{
+    readonly value: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+  minLength: RuleDef<import("valibot").ObjectSchema<{
+    readonly value: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+  maxLength: RuleDef<import("valibot").ObjectSchema<{
+    readonly value: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+  notLength: RuleDef<import("valibot").ObjectSchema<{
+    readonly value: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+};
+export declare const defineRule: <T extends AnyObjectSchema>(def: RuleDef<T>) => RuleDef<T>;
+/** Size and type of a File or Blob. */
+export declare const fileRules: {
+  minSize: RuleDef<v.ObjectSchema<{
+    readonly value: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+  maxSize: RuleDef<v.ObjectSchema<{
+    readonly value: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+  size: RuleDef<v.ObjectSchema<{
+    readonly value: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+  notSize: RuleDef<v.ObjectSchema<{
+    readonly value: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+  mimeType: RuleDef<v.ObjectSchema<{
+    readonly types: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Use a MIME type, such as image/png">]>, undefined>, v.MinLengthAction<string[], 1, "Give at least one MIME type">]>;
+  }, undefined>>;
+};
+/** Formats Valibot can check on a string. */
+export declare const formatRules: {
+  email: RuleDef<AnyObjectSchema>;
+  rfcEmail: RuleDef<AnyObjectSchema>;
+  url: RuleDef<AnyObjectSchema>;
+  domain: RuleDef<AnyObjectSchema>;
+  slug: RuleDef<AnyObjectSchema>;
+  uuid: RuleDef<AnyObjectSchema>;
+  ulid: RuleDef<AnyObjectSchema>;
+  cuid2: RuleDef<AnyObjectSchema>;
+  nanoid: RuleDef<AnyObjectSchema>;
+  ip: RuleDef<AnyObjectSchema>;
+  ipv4: RuleDef<AnyObjectSchema>;
+  ipv6: RuleDef<AnyObjectSchema>;
+  mac: RuleDef<AnyObjectSchema>;
+  mac48: RuleDef<AnyObjectSchema>;
+  mac64: RuleDef<AnyObjectSchema>;
+  hexColor: RuleDef<AnyObjectSchema>;
+  hexadecimal: RuleDef<AnyObjectSchema>;
+  octal: RuleDef<AnyObjectSchema>;
+  decimal: RuleDef<AnyObjectSchema>;
+  digits: RuleDef<AnyObjectSchema>;
+  base64: RuleDef<AnyObjectSchema>;
+  bic: RuleDef<AnyObjectSchema>;
+  creditCard: RuleDef<AnyObjectSchema>;
+  imei: RuleDef<AnyObjectSchema>;
+  isbn: RuleDef<AnyObjectSchema>;
+  isrc: RuleDef<AnyObjectSchema>;
+  emoji: RuleDef<AnyObjectSchema>;
+  hash: RuleDef<v.ObjectSchema<{
+    readonly types: v.SchemaWithPipe<readonly [v.ArraySchema<v.PicklistSchema<readonly ["md4", "md5", "sha1", "sha256", "sha384", "sha512", "ripemd128", "ripemd160", "tiger128", "tiger160", "tiger192", "crc32", "crc32b", "adler32"], undefined>, undefined>, v.MinLengthAction<("md4" | "md5" | "sha1" | "sha256" | "sha384" | "sha512" | "ripemd128" | "ripemd160" | "tiger128" | "tiger160" | "tiger192" | "crc32" | "crc32b" | "adler32")[], 1, "Pick at least one hash type">]>;
+  }, undefined>>;
+};
+/** Characters of a string, or items of an array */
+export declare const lengthRules: {
+  length: RuleDef<v.ObjectSchema<{
+    readonly value: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
   minLength: RuleDef<v.ObjectSchema<{
     readonly value: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
   }, undefined>>;
   maxLength: RuleDef<v.ObjectSchema<{
     readonly value: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
   }, undefined>>;
-  regex: RuleDef<v.ObjectSchema<{
-    readonly pattern: v.StringSchema<undefined>;
-    readonly flags: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  notLength: RuleDef<v.ObjectSchema<{
+    readonly value: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
   }, undefined>>;
-  email: RuleDef<v.ObjectSchema<{}, undefined>>;
-  url: RuleDef<v.ObjectSchema<{}, undefined>>;
-  minValue: RuleDef<v.ObjectSchema<{
+};
+/**
+ * Rules that change the value instead of checking it. They run before the required check, so
+ * `'   '` with `trim` is empty. Their `message` is never shown.
+ */
+export declare const normalizeRules: {
+  trim: RuleDef<AnyObjectSchema>;
+  trimStart: RuleDef<AnyObjectSchema>;
+  trimEnd: RuleDef<AnyObjectSchema>;
+  toLowerCase: RuleDef<AnyObjectSchema>;
+  toUpperCase: RuleDef<AnyObjectSchema>;
+  normalize: RuleDef<v.ObjectSchema<{
+    readonly form: v.OptionalSchema<v.PicklistSchema<["NFC", "NFD", "NFKC", "NFKD"], undefined>, undefined>;
+  }, undefined>>;
+  toMinValue: RuleDef<v.ObjectSchema<{
     readonly value: v.NumberSchema<undefined>;
   }, undefined>>;
-  maxValue: RuleDef<v.ObjectSchema<{
+  toMaxValue: RuleDef<v.ObjectSchema<{
     readonly value: v.NumberSchema<undefined>;
   }, undefined>>;
-  integer: RuleDef<v.ObjectSchema<{}, undefined>>;
 };
-export type { AnyAction, AnySchema, FieldType, FieldTypeDef, JsonField, JsonFormSchema, JsonRule, RuleDef, SchemaBuilderOptions, ValueKind };
+/** Checks only numbers have. */
+export declare const numberRules: {
+  integer: RuleDef<AnyObjectSchema>;
+  safeInteger: RuleDef<AnyObjectSchema>;
+  finite: RuleDef<AnyObjectSchema>;
+  multipleOf: RuleDef<v.ObjectSchema<{
+    readonly value: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>, v.NotValueAction<number, 0, "Can't be 0">]>;
+  }, undefined>>;
+};
+export declare const textUnitRules: {
+  graphemes: RuleDef<v.ObjectSchema<{
+    readonly value: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+  minGraphemes: RuleDef<v.ObjectSchema<{
+    readonly value: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+  maxGraphemes: RuleDef<v.ObjectSchema<{
+    readonly value: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+  notGraphemes: RuleDef<v.ObjectSchema<{
+    readonly value: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+  words: RuleDef<v.ObjectSchema<{
+    readonly locale: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Use a language tag, such as en or sr-Latn">]>, undefined>;
+    readonly value: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+  minWords: RuleDef<v.ObjectSchema<{
+    readonly locale: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Use a language tag, such as en or sr-Latn">]>, undefined>;
+    readonly value: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+  maxWords: RuleDef<v.ObjectSchema<{
+    readonly locale: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Use a language tag, such as en or sr-Latn">]>, undefined>;
+    readonly value: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+  notWords: RuleDef<v.ObjectSchema<{
+    readonly locale: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Use a language tag, such as en or sr-Latn">]>, undefined>;
+    readonly value: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+  bytes: RuleDef<v.ObjectSchema<{
+    readonly value: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+  minBytes: RuleDef<v.ObjectSchema<{
+    readonly value: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+  maxBytes: RuleDef<v.ObjectSchema<{
+    readonly value: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+  notBytes: RuleDef<v.ObjectSchema<{
+    readonly value: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+};
+/**
+ * Field keys this package owns. A field type's props can't use them.
+ */
+export declare const RESERVED_FIELD_KEYS: readonly ["name", "type", "label", "description", "placeholder", "default", "required", "rules", "ui"];
+/**
+ * Rule keys this package own. A rule's params can't use them.
+ */
+export declare const RESERVED_RULE_KEYS: readonly ["rule", "message"];
+export type { AnyAction, AnyObjectSchema, AnySchema, BuildContext, DefinitionIssue, DefinitionIssueCode, DefinitionPath, FieldTypeDef, FieldWithProps, JsonField, JsonForm, JsonRule, KindDef, MessageContext, RuleCategory, RuleDef, RuleMeta, RuleStage, SchemaBuilderOptions, ValidateResult, ValueKind };
 //# sourceMappingURL=index.d.ts.map