@whatsaaaa/form-builder-schema 0.2.0 → 0.4.0

package/dist/index.d.ts

@@ -63,7 +63,16 @@ export declare class DefinitionError extends Error {
   constructor(issues: readonly DefinitionIssue[]);
 }
 interface FieldTypeDef<TProps extends AnyObjectSchema = AnyObjectSchema> {
-  kind: ValueKind;
+  /**
+   * The kind of the field's value. A function gets the field with its props parsed, for types
+   * whose value depends on them: a select with number options has kind `'number'`.
+   */
+  kind: ValueKind | KindOf<TProps>;
+  /**
+   * The kind of each item when the field's kind is `'array'`. A rule that supports this kind but
+   * not `'array'` then runs once per item, so `maxSize` works on a multi-file field.
+   */
+  itemKind?: ValueKind | KindOf<TProps>;
   /** Extra keys this type accepts on a field, e.g. `options` on a select. */
   props?: TProps;
   /**
@@ -73,7 +82,20 @@ interface FieldTypeDef<TProps extends AnyObjectSchema = AnyObjectSchema> {
   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[];
+  /**
+   * Replaces the kind's required check. A required yes/no radio has kind `'boolean'`, but must
+   * accept `false`, so its type returns null here.
+   */
+  required?(message: string): AnyAction | null;
+  /** Runs last, after every rule, e.g. to turn an ISO string into a `Date`. */
+  finalize?(field: FieldWithProps<TProps>): AnyAction | undefined;
 }
+/**
+ * Picks the kind from the field. Declared as a method so it stays bivariant, like `schema()`.
+ */
+type KindOf<TProps extends AnyObjectSchema = AnyObjectSchema> = {
+  bivariant(field: FieldWithProps<TProps>): ValueKind;
+}['bivariant'];
 /** A field with its type's props parsed and typed. */
 type FieldWithProps<TProps extends AnyObjectSchema = AnyObjectSchema> = JsonField & v.InferOutput<TProps>;
 interface BuildContext {
@@ -85,13 +107,26 @@ interface BuildContext {
  * 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. */
-  params?: TParams;
-  /** Method syntax keeps `create` bivariant, so specific rules fit in a `Record<string, RuleDef`>. */
+  /**
+   * 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 {
@@ -103,6 +138,7 @@ interface SchemaBuilderOptions {
   kinds?: Record<string, KindDef>;
   fieldTypes?: Record<string, FieldTypeDef>;
   rules?: Record<string, RuleDef>;
+  includeDefaultRules?: boolean;
   messages?: {
     required?: string;
   };
@@ -115,29 +151,120 @@ interface SchemaBuilderOptions {
 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>>>;
 };
+/** Every built-in field type. */
 export declare const defaultFieldTypes: {
+  heading: FieldTypeDef<import("valibot").ObjectSchema<{
+    readonly text: import("valibot").StringSchema<undefined>;
+    readonly level: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 1, undefined>, import("valibot").MaxValueAction<number, 6, undefined>]>, undefined>;
+  }, undefined>>;
+  paragraph: FieldTypeDef<import("valibot").ObjectSchema<{
+    readonly text: import("valibot").StringSchema<undefined>;
+  }, undefined>>;
+  divider: {
+    kind: "none";
+  };
+  file: FieldTypeDef<import("valibot").ObjectSchema<{
+    readonly multiple: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    readonly accept: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").CheckAction<string, "Use MIME types separated by commas, such as image/png,image/jpeg">]>, undefined>;
+  }, undefined>>;
+  select: FieldTypeDef<import("valibot").ObjectSchema<{
+    readonly options: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+      readonly value: import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>], undefined>;
+      readonly label: import("valibot").StringSchema<undefined>;
+    }, undefined>, undefined>, import("valibot").MinLengthAction<{
+      value: string | number;
+      label: string;
+    }[], 1, "Give at least one option">, import("valibot").CheckAction<{
+      value: string | number;
+      label: string;
+    }[], "Give every option a value of the same type">, import("valibot").CheckAction<{
+      value: string | number;
+      label: string;
+    }[], "Give every option a different value">]>, undefined>;
+    readonly valueType: import("valibot").OptionalSchema<import("valibot").PicklistSchema<["string", "number"], undefined>, undefined>;
+  }, undefined>>;
+  radio: FieldTypeDef<import("valibot").ObjectSchema<{
+    readonly options: import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+      readonly value: import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>, import("valibot").BooleanSchema<undefined>], undefined>;
+      readonly label: import("valibot").StringSchema<undefined>;
+    }, undefined>, undefined>, import("valibot").MinLengthAction<{
+      value: string | number | boolean;
+      label: string;
+    }[], 1, "Give at least one option">, import("valibot").CheckAction<{
+      value: string | number | boolean;
+      label: string;
+    }[], "Give every option a value of the same type">, import("valibot").CheckAction<{
+      value: string | number | boolean;
+      label: string;
+    }[], "Give every option a different value">]>;
+  }, undefined>>;
+  multiselect: FieldTypeDef<import("valibot").ObjectSchema<{
+    readonly options: import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+      readonly value: import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").NumberSchema<undefined>], undefined>;
+      readonly label: import("valibot").StringSchema<undefined>;
+    }, undefined>, undefined>, import("valibot").MinLengthAction<{
+      value: string | number;
+      label: string;
+    }[], 1, "Give at least one option">, import("valibot").CheckAction<{
+      value: string | number;
+      label: string;
+    }[], "Give every option a value of the same type">, import("valibot").CheckAction<{
+      value: string | number;
+      label: string;
+    }[], "Give every option a different value">]>;
+  }, undefined>>;
+  date: FieldTypeDef<import("valibot").ObjectSchema<{
+    readonly output: import("valibot").OptionalSchema<import("valibot").PicklistSchema<["string", "date"], undefined>, undefined>;
+  }, undefined>>;
+  time: {
+    kind: "date";
+    schema: () => import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").IsoTimeAction<string, undefined>]>;
+  };
+  datetime: FieldTypeDef<import("valibot").ObjectSchema<{
+    readonly output: import("valibot").OptionalSchema<import("valibot").PicklistSchema<["string", "date"], undefined>, undefined>;
+  }, undefined>>;
   text: {
     kind: "string";
-    schema: () => v.StringSchema<undefined>;
+    schema: () => import("valibot").StringSchema<undefined>;
   };
-  password: {
+  textarea: {
     kind: "string";
-    schema: () => v.StringSchema<undefined>;
+    schema: () => import("valibot").StringSchema<undefined>;
   };
   email: {
     kind: "string";
-    schema: () => v.StringSchema<undefined>;
+    schema: () => import("valibot").StringSchema<undefined>;
     defaultRules: {
       rule: string;
     }[];
   };
+  password: {
+    kind: "string";
+    schema: () => import("valibot").StringSchema<undefined>;
+  };
+  url: {
+    kind: "string";
+    schema: () => import("valibot").StringSchema<undefined>;
+    defaultRules: {
+      rule: string;
+    }[];
+  };
+  tel: {
+    kind: "string";
+    schema: () => import("valibot").StringSchema<undefined>;
+  };
   number: {
     kind: "number";
-    schema: () => v.NumberSchema<undefined>;
+    schema: () => import("valibot").NumberSchema<undefined>;
+  };
+  checkbox: {
+    kind: "boolean";
+    schema: () => import("valibot").BooleanSchema<undefined>;
   };
 };
 export declare const defineFieldType: <T extends AnyObjectSchema>(def: FieldTypeDef<T>) => FieldTypeDef<T>;
@@ -171,29 +298,381 @@ export declare const defaultKinds: {
     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.BooleanSchema<undefined> | v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Use an ISO date, date-time or time, such as 2026-01-01">]>;
+  }, undefined>>;
+  maxValue: RuleDef<v.ObjectSchema<{
+    readonly value: v.StringSchema<undefined> | v.NumberSchema<undefined> | v.BooleanSchema<undefined> | v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Use an ISO date, date-time or time, such as 2026-01-01">]>;
+  }, undefined>>;
+  gtValue: RuleDef<v.ObjectSchema<{
+    readonly value: v.StringSchema<undefined> | v.NumberSchema<undefined> | v.BooleanSchema<undefined> | v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Use an ISO date, date-time or time, such as 2026-01-01">]>;
+  }, undefined>>;
+  ltValue: RuleDef<v.ObjectSchema<{
+    readonly value: v.StringSchema<undefined> | v.NumberSchema<undefined> | v.BooleanSchema<undefined> | v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Use an ISO date, date-time or time, such as 2026-01-01">]>;
+  }, undefined>>;
+  value: RuleDef<v.ObjectSchema<{
+    readonly value: v.StringSchema<undefined> | v.NumberSchema<undefined> | v.BooleanSchema<undefined> | v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Use an ISO date, date-time or time, such as 2026-01-01">]>;
+  }, undefined>>;
+  notValue: RuleDef<v.ObjectSchema<{
+    readonly value: v.StringSchema<undefined> | v.NumberSchema<undefined> | v.BooleanSchema<undefined> | v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Use an ISO date, date-time or time, such as 2026-01-01">]>;
+  }, undefined>>;
+  values: RuleDef<v.ObjectSchema<{
+    readonly values: v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined> | v.NumberSchema<undefined> | v.BooleanSchema<undefined> | v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Use an ISO date, date-time or time, such as 2026-01-01">]>, 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.BooleanSchema<undefined> | v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "Use an ISO date, date-time or time, such as 2026-01-01">]>, 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>;
-  minLength: RuleDef<v.ObjectSchema<{
+  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").BooleanSchema<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">]>;
+  }, undefined>>;
+  maxValue: RuleDef<import("valibot").ObjectSchema<{
+    readonly value: import("valibot").StringSchema<undefined> | import("valibot").NumberSchema<undefined> | import("valibot").BooleanSchema<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">]>;
+  }, undefined>>;
+  gtValue: RuleDef<import("valibot").ObjectSchema<{
+    readonly value: import("valibot").StringSchema<undefined> | import("valibot").NumberSchema<undefined> | import("valibot").BooleanSchema<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">]>;
+  }, undefined>>;
+  ltValue: RuleDef<import("valibot").ObjectSchema<{
+    readonly value: import("valibot").StringSchema<undefined> | import("valibot").NumberSchema<undefined> | import("valibot").BooleanSchema<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">]>;
+  }, undefined>>;
+  value: RuleDef<import("valibot").ObjectSchema<{
+    readonly value: import("valibot").StringSchema<undefined> | import("valibot").NumberSchema<undefined> | import("valibot").BooleanSchema<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">]>;
+  }, undefined>>;
+  notValue: RuleDef<import("valibot").ObjectSchema<{
+    readonly value: import("valibot").StringSchema<undefined> | import("valibot").NumberSchema<undefined> | import("valibot").BooleanSchema<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">]>;
+  }, 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").BooleanSchema<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">]>, 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").BooleanSchema<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">]>, 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>>;
-  maxLength: RuleDef<v.ObjectSchema<{
+  maxSize: 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>;
+  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>;
-  minValue: RuleDef<v.ObjectSchema<{
+  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>>;
+  notLength: RuleDef<v.ObjectSchema<{
+    readonly value: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+  }, undefined>>;
+};
+/**
+ * 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>>;
+};
+/** 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>>;
 };
-export declare const defineRule: <T extends AnyObjectSchema>(def: RuleDef<T>) => RuleDef<T>;
 /**
  * Field keys this package owns. A field type's props can't use them.
  */
@@ -202,5 +681,5 @@ export declare const RESERVED_FIELD_KEYS: readonly ["name", "type", "label", "de
  * 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, RuleDef, RuleStage, SchemaBuilderOptions, ValidateResult, ValueKind };
+export type { AnyAction, AnyObjectSchema, AnySchema, BuildContext, DefinitionIssue, DefinitionIssueCode, DefinitionPath, FieldTypeDef, FieldWithProps, JsonField, JsonForm, JsonRule, KindDef, KindOf, MessageContext, RuleCategory, RuleDef, RuleMeta, RuleStage, SchemaBuilderOptions, ValidateResult, ValueKind };
 //# sourceMappingURL=index.d.ts.map