import { $ as longerThanOrEquals, A as isPositive, B as isNotNaN, C as MultiTypeInputArgs, D as toNumber, E as numberNotEquals, F as greaterThanOrEquals, G as AllOfRuleInstance, H as OneOfRuleInstance, I as NullRuleInstance, J as isEmpty, K as BooleanRuleInstance, L as NullishRuleInstance, M as isNotBetween, N as isNegative, O as lessThanOrEquals, P as isBetween, Q as longerThan, R as UndefinedRuleInstance, S as MultiTypeInput, T as ObjectRulesUnion, U as NoneOfRuleInstance, V as isNaN, W as AnyOfRuleInstance, X as lengthEquals, Y as isNotArray, Z as lengthNotEquals, _ as PickRuleInstance, a as startsWith, at as notInside, b as LooseRuleInstance, c as isString, ct as isArray, d as endsWith, dt as ExtractRuleFunctions, et as maxLength, f as doesNotStartWith, ft as RuleInstance, g as OmitRuleInstance, h as RecordRuleInstance, i as FirstParam, it as inside, j as isNumber, k as lessThan, l as isNotBlank, lt as includes, m as TupleRuleInstance, nt as shorterThan, o as notMatches, ot as equals, p as doesNotEndWith, pt as RuleRunReturn, q as equals$1, r as enforceEager, rt as shorterThanOrEquals, s as matches, st as notEquals, t as CustomMatcherArgs, tt as minLength, u as isBlankString, ut as BuildRuleInstance, v as PartialRuleInstance, w as IsArrayOfRuleInstance, x as ShapeRuleInstance, y as OptionalRuleInstance, z as AnyRuleInstance } from "./n4sTypes-BSTzXRsU.cjs";
import { Nullable } from "vest-utils";
import * as context0 from "context";

//#region src/rules/compoundRules/compoundRulesTypes.d.ts

/**
 * Type mappings for compound rule lazy API return types
 */
type CompoundRuleLazyTypes = {
  allOf: <T$1>(...rules: any[]) => AllOfRuleInstance<T$1>;
  anyOf: <Rules extends RuleInstance<any>[]>(...rules: Rules) => AnyOfRuleInstance<Rules[number]['infer']>;
  noneOf: <T$1>(...rules: any[]) => NoneOfRuleInstance<T$1>;
  oneOf: <Rules extends RuleInstance<any>[]>(...rules: Rules) => OneOfRuleInstance<Rules[number]['infer']>;
};
//#endregion
//#region src/rules/schemaRules/schemaRulesLazyTypes.d.ts
/**
 * Type mappings for schema rule lazy API return types
 */
type SchemaRuleLazyTypes = {
  isArrayOf: <Rules extends RuleInstance<any, any>[]>(...rules: Rules) => IsArrayOfRuleInstance<MultiTypeInput<Rules>, MultiTypeInputArgs<Rules>>;
  list: <Rules extends RuleInstance<any, any>[]>(...rules: Rules) => IsArrayOfRuleInstance<MultiTypeInput<Rules>, MultiTypeInputArgs<Rules>>;
  lazy: <T$1>(factory: () => RuleInstance<T$1, any>) => LazyRuleInstance<T$1>;
  loose: <S extends Record<string, RuleInstance<any>>>(schema: S) => LooseRuleInstance<S>;
  optional: <R extends RuleInstance<any>>(rule: R) => OptionalRuleInstance<R['infer']>;
  partial: <S extends Record<string, RuleInstance<any>>>(schema: S) => PartialRuleInstance<S>;
  pick: <S extends Record<string, RuleInstance<any>>>(schema: S, keys: string[] | string) => PickRuleInstance<S>;
  omit: <S extends Record<string, RuleInstance<any>>>(schema: S, keys: string[] | string) => OmitRuleInstance<S>;
  shape: <S extends Record<string, RuleInstance<any>>>(schema: S) => ShapeRuleInstance<S>;
  record: {
    <V extends RuleInstance<any, any>>(valueRule: V): RecordRuleInstance<never, V>;
    <K$1 extends RuleInstance<string, any>, V extends RuleInstance<any, any>>(keyRule: K$1, valueRule: V): RecordRuleInstance<K$1, V>;
  };
  tuple: <Rules extends RuleInstance<any, any>[]>(...rules: Rules) => TupleRuleInstance<Rules>;
};
//#endregion
//#region src/rules/schemaRules/lazy.d.ts
type LazyRuleInstance<T$1> = RuleInstance<T$1, [T$1]>;
//#endregion
//#region src/enforceContext.d.ts
/**
 * Context API for accessing validation state during rule execution.
 * Provides access to the current value being validated, metadata, and parent context.
 * Used internally by rules to track nested validation (e.g., in shape, isArrayOf).
 *
 * @example
 * ```typescript
 * // Access context in custom rules
 * enforce.extend({
 *   customRule: (value: any) => {
 *     const context = enforce.context();
 *     console.log('Current value:', context?.value);
 *     console.log('Metadata:', context?.meta);
 *     return true;
 *   }
 * });
 *
 * // Context is automatically set in nested validations
 * enforce({ user: { name: 'John' } }).shape({
 *   user: enforce.shape({
 *     name: enforce.isString()
 *   })
 * });
 * // When validating 'name', context.parent() gives access to 'user' object
 * ```
 */
declare const ctx: context0.CtxCascadeApi<CTXType>;
type CTXType = {
  meta: Record<string, any>;
  value: any;
  set?: boolean;
  parent: () => Nullable<CTXType>;
};
type EnforceContext = Nullable<{
  meta: Record<string, any>;
  value: any;
  parent: () => EnforceContext;
}>;
//#endregion
//#region src/rules/parsers/toBoolean.d.ts
declare function toBoolean(value: unknown): RuleRunReturn<boolean>;
//#endregion
//#region src/rules/parsers/generalParsers.d.ts
declare function defaultTo<TValue>(value: TValue, fallback: NonNullable<TValue>): RuleRunReturn<NonNullable<TValue>>;
//#endregion
//#region ../vest-utils/types/vest-utils.d.cts
//#region src/withResolvers.d.ts
declare global {
  interface PromiseConstructor {
    withResolvers<T$1>(): {
      promise: Promise<T$1>;
      resolve: (value: T$1 | PromiseLike<T$1>) => void;
      reject: (reason?: any) => void;
    };
  }
}
//#endregion
//#region src/greaterThan.d.ts
declare function greaterThan(value: number | string, gt: number | string): boolean;
//#endregion
//#region src/longerThan.d.ts

//#endregion
//#region src/numberEquals.d.ts
declare function numberEquals(value: string | number, eq: string | number): boolean;
//#endregion
//#region src/lazy.d.ts
/**
 * Extracts the output type from a custom matcher function.
 * If the matcher returns { type: T }, uses T (coercion rules like toNumber).
 * Otherwise falls back to the first parameter type (validation rules like isPositive).
 */
type InferMatcherOutput<K$1 extends keyof n4s.EnforceMatchers> = ReturnType<Extract<n4s.EnforceMatchers[K$1], (...args: any[]) => any>> extends {
  type: infer T;
} ? T : FirstParam<n4s.EnforceMatchers[K$1]>;
type TCustomLazyRules = { [K in keyof n4s.EnforceMatchers as K extends keyof SchemaRuleLazyTypes ? never : K extends keyof CompoundRuleLazyTypes ? never : K]: (...args: CustomMatcherArgs<K>) => RuleInstance<InferMatcherOutput<K>, [FirstParam<n4s.EnforceMatchers[K]>]> };
declare const baseEnforceLazy: {
  isArray: <T$1 = any>() => RuleInstance<T$1[], [T$1[]]> & {
    readonly defaultTo: (fallback: {}) => BuildRuleInstance<{}, [T$1[]], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly join: (value: unknown[], separator?: string) => RuleRunReturn<string>;
      readonly uniq: (value: unknown[]) => RuleRunReturn<unknown[]>;
      readonly equals: typeof equals;
      readonly includes: typeof includes;
      readonly inside: typeof inside;
      readonly isArray: typeof isArray;
      readonly isEmpty: typeof isEmpty;
      readonly isNotArray: typeof isNotArray;
      readonly isNotEmpty: (value: unknown) => boolean;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
    }>>;
    readonly parseJSON: () => BuildRuleInstance<unknown, [T$1[]], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly join: (value: unknown[], separator?: string) => RuleRunReturn<string>;
      readonly uniq: (value: unknown[]) => RuleRunReturn<unknown[]>;
      readonly equals: typeof equals;
      readonly includes: typeof includes;
      readonly inside: typeof inside;
      readonly isArray: typeof isArray;
      readonly isEmpty: typeof isEmpty;
      readonly isNotArray: typeof isNotArray;
      readonly isNotEmpty: (value: unknown) => boolean;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
    }>>;
    readonly toBoolean: () => BuildRuleInstance<boolean, [T$1[]], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly join: (value: unknown[], separator?: string) => RuleRunReturn<string>;
      readonly uniq: (value: unknown[]) => RuleRunReturn<unknown[]>;
      readonly equals: typeof equals;
      readonly includes: typeof includes;
      readonly inside: typeof inside;
      readonly isArray: typeof isArray;
      readonly isEmpty: typeof isEmpty;
      readonly isNotArray: typeof isNotArray;
      readonly isNotEmpty: (value: unknown) => boolean;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
    }>>;
    readonly join: (separator?: string | undefined) => BuildRuleInstance<string, [T$1[]], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly join: (value: unknown[], separator?: string) => RuleRunReturn<string>;
      readonly uniq: (value: unknown[]) => RuleRunReturn<unknown[]>;
      readonly equals: typeof equals;
      readonly includes: typeof includes;
      readonly inside: typeof inside;
      readonly isArray: typeof isArray;
      readonly isEmpty: typeof isEmpty;
      readonly isNotArray: typeof isNotArray;
      readonly isNotEmpty: (value: unknown) => boolean;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
    }>>;
    readonly uniq: () => BuildRuleInstance<unknown[], [T$1[]], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly join: (value: unknown[], separator?: string) => RuleRunReturn<string>;
      readonly uniq: (value: unknown[]) => RuleRunReturn<unknown[]>;
      readonly equals: typeof equals;
      readonly includes: typeof includes;
      readonly inside: typeof inside;
      readonly isArray: typeof isArray;
      readonly isEmpty: typeof isEmpty;
      readonly isNotArray: typeof isNotArray;
      readonly isNotEmpty: (value: unknown) => boolean;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
    }>>;
    readonly equals: (b: unknown) => BuildRuleInstance<T$1[], [T$1[]], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly join: (value: unknown[], separator?: string) => RuleRunReturn<string>;
      readonly uniq: (value: unknown[]) => RuleRunReturn<unknown[]>;
      readonly equals: typeof equals;
      readonly includes: typeof includes;
      readonly inside: typeof inside;
      readonly isArray: typeof isArray;
      readonly isEmpty: typeof isEmpty;
      readonly isNotArray: typeof isNotArray;
      readonly isNotEmpty: (value: unknown) => boolean;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
    }>>;
    readonly includes: (item: unknown) => BuildRuleInstance<T$1[], [T$1[]], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly join: (value: unknown[], separator?: string) => RuleRunReturn<string>;
      readonly uniq: (value: unknown[]) => RuleRunReturn<unknown[]>;
      readonly equals: typeof equals;
      readonly includes: typeof includes;
      readonly inside: typeof inside;
      readonly isArray: typeof isArray;
      readonly isEmpty: typeof isEmpty;
      readonly isNotArray: typeof isNotArray;
      readonly isNotEmpty: (value: unknown) => boolean;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
    }>>;
    readonly inside: (container: string | unknown[]) => BuildRuleInstance<T$1[], [T$1[]], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly join: (value: unknown[], separator?: string) => RuleRunReturn<string>;
      readonly uniq: (value: unknown[]) => RuleRunReturn<unknown[]>;
      readonly equals: typeof equals;
      readonly includes: typeof includes;
      readonly inside: typeof inside;
      readonly isArray: typeof isArray;
      readonly isEmpty: typeof isEmpty;
      readonly isNotArray: typeof isNotArray;
      readonly isNotEmpty: (value: unknown) => boolean;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
    }>>;
    readonly isArray: () => BuildRuleInstance<T$1[], [T$1[]], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly join: (value: unknown[], separator?: string) => RuleRunReturn<string>;
      readonly uniq: (value: unknown[]) => RuleRunReturn<unknown[]>;
      readonly equals: typeof equals;
      readonly includes: typeof includes;
      readonly inside: typeof inside;
      readonly isArray: typeof isArray;
      readonly isEmpty: typeof isEmpty;
      readonly isNotArray: typeof isNotArray;
      readonly isNotEmpty: (value: unknown) => boolean;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
    }>>;
    readonly isEmpty: () => BuildRuleInstance<T$1[], [T$1[]], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly join: (value: unknown[], separator?: string) => RuleRunReturn<string>;
      readonly uniq: (value: unknown[]) => RuleRunReturn<unknown[]>;
      readonly equals: typeof equals;
      readonly includes: typeof includes;
      readonly inside: typeof inside;
      readonly isArray: typeof isArray;
      readonly isEmpty: typeof isEmpty;
      readonly isNotArray: typeof isNotArray;
      readonly isNotEmpty: (value: unknown) => boolean;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
    }>>;
    readonly isNotArray: () => BuildRuleInstance<T$1[], [T$1[]], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly join: (value: unknown[], separator?: string) => RuleRunReturn<string>;
      readonly uniq: (value: unknown[]) => RuleRunReturn<unknown[]>;
      readonly equals: typeof equals;
      readonly includes: typeof includes;
      readonly inside: typeof inside;
      readonly isArray: typeof isArray;
      readonly isEmpty: typeof isEmpty;
      readonly isNotArray: typeof isNotArray;
      readonly isNotEmpty: (value: unknown) => boolean;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
    }>>;
    readonly isNotEmpty: () => BuildRuleInstance<T$1[], [T$1[]], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly join: (value: unknown[], separator?: string) => RuleRunReturn<string>;
      readonly uniq: (value: unknown[]) => RuleRunReturn<unknown[]>;
      readonly equals: typeof equals;
      readonly includes: typeof includes;
      readonly inside: typeof inside;
      readonly isArray: typeof isArray;
      readonly isEmpty: typeof isEmpty;
      readonly isNotArray: typeof isNotArray;
      readonly isNotEmpty: (value: unknown) => boolean;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
    }>>;
    readonly lengthEquals: (n: number) => BuildRuleInstance<T$1[], [T$1[]], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly join: (value: unknown[], separator?: string) => RuleRunReturn<string>;
      readonly uniq: (value: unknown[]) => RuleRunReturn<unknown[]>;
      readonly equals: typeof equals;
      readonly includes: typeof includes;
      readonly inside: typeof inside;
      readonly isArray: typeof isArray;
      readonly isEmpty: typeof isEmpty;
      readonly isNotArray: typeof isNotArray;
      readonly isNotEmpty: (value: unknown) => boolean;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
    }>>;
    readonly lengthNotEquals: (n: number) => BuildRuleInstance<T$1[], [T$1[]], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly join: (value: unknown[], separator?: string) => RuleRunReturn<string>;
      readonly uniq: (value: unknown[]) => RuleRunReturn<unknown[]>;
      readonly equals: typeof equals;
      readonly includes: typeof includes;
      readonly inside: typeof inside;
      readonly isArray: typeof isArray;
      readonly isEmpty: typeof isEmpty;
      readonly isNotArray: typeof isNotArray;
      readonly isNotEmpty: (value: unknown) => boolean;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
    }>>;
    readonly longerThan: (n: number) => BuildRuleInstance<T$1[], [T$1[]], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly join: (value: unknown[], separator?: string) => RuleRunReturn<string>;
      readonly uniq: (value: unknown[]) => RuleRunReturn<unknown[]>;
      readonly equals: typeof equals;
      readonly includes: typeof includes;
      readonly inside: typeof inside;
      readonly isArray: typeof isArray;
      readonly isEmpty: typeof isEmpty;
      readonly isNotArray: typeof isNotArray;
      readonly isNotEmpty: (value: unknown) => boolean;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
    }>>;
    readonly longerThanOrEquals: (n: number) => BuildRuleInstance<T$1[], [T$1[]], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly join: (value: unknown[], separator?: string) => RuleRunReturn<string>;
      readonly uniq: (value: unknown[]) => RuleRunReturn<unknown[]>;
      readonly equals: typeof equals;
      readonly includes: typeof includes;
      readonly inside: typeof inside;
      readonly isArray: typeof isArray;
      readonly isEmpty: typeof isEmpty;
      readonly isNotArray: typeof isNotArray;
      readonly isNotEmpty: (value: unknown) => boolean;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
    }>>;
    readonly maxLength: (n: number) => BuildRuleInstance<T$1[], [T$1[]], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly join: (value: unknown[], separator?: string) => RuleRunReturn<string>;
      readonly uniq: (value: unknown[]) => RuleRunReturn<unknown[]>;
      readonly equals: typeof equals;
      readonly includes: typeof includes;
      readonly inside: typeof inside;
      readonly isArray: typeof isArray;
      readonly isEmpty: typeof isEmpty;
      readonly isNotArray: typeof isNotArray;
      readonly isNotEmpty: (value: unknown) => boolean;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
    }>>;
    readonly minLength: (n: number) => BuildRuleInstance<T$1[], [T$1[]], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly join: (value: unknown[], separator?: string) => RuleRunReturn<string>;
      readonly uniq: (value: unknown[]) => RuleRunReturn<unknown[]>;
      readonly equals: typeof equals;
      readonly includes: typeof includes;
      readonly inside: typeof inside;
      readonly isArray: typeof isArray;
      readonly isEmpty: typeof isEmpty;
      readonly isNotArray: typeof isNotArray;
      readonly isNotEmpty: (value: unknown) => boolean;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
    }>>;
    readonly notEquals: (b: unknown) => BuildRuleInstance<T$1[], [T$1[]], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly join: (value: unknown[], separator?: string) => RuleRunReturn<string>;
      readonly uniq: (value: unknown[]) => RuleRunReturn<unknown[]>;
      readonly equals: typeof equals;
      readonly includes: typeof includes;
      readonly inside: typeof inside;
      readonly isArray: typeof isArray;
      readonly isEmpty: typeof isEmpty;
      readonly isNotArray: typeof isNotArray;
      readonly isNotEmpty: (value: unknown) => boolean;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
    }>>;
    readonly notInside: (container: any) => BuildRuleInstance<T$1[], [T$1[]], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly join: (value: unknown[], separator?: string) => RuleRunReturn<string>;
      readonly uniq: (value: unknown[]) => RuleRunReturn<unknown[]>;
      readonly equals: typeof equals;
      readonly includes: typeof includes;
      readonly inside: typeof inside;
      readonly isArray: typeof isArray;
      readonly isEmpty: typeof isEmpty;
      readonly isNotArray: typeof isNotArray;
      readonly isNotEmpty: (value: unknown) => boolean;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
    }>>;
    readonly shorterThan: (n: number) => BuildRuleInstance<T$1[], [T$1[]], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly join: (value: unknown[], separator?: string) => RuleRunReturn<string>;
      readonly uniq: (value: unknown[]) => RuleRunReturn<unknown[]>;
      readonly equals: typeof equals;
      readonly includes: typeof includes;
      readonly inside: typeof inside;
      readonly isArray: typeof isArray;
      readonly isEmpty: typeof isEmpty;
      readonly isNotArray: typeof isNotArray;
      readonly isNotEmpty: (value: unknown) => boolean;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
    }>>;
    readonly shorterThanOrEquals: (n: number) => BuildRuleInstance<T$1[], [T$1[]], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly join: (value: unknown[], separator?: string) => RuleRunReturn<string>;
      readonly uniq: (value: unknown[]) => RuleRunReturn<unknown[]>;
      readonly equals: typeof equals;
      readonly includes: typeof includes;
      readonly inside: typeof inside;
      readonly isArray: typeof isArray;
      readonly isEmpty: typeof isEmpty;
      readonly isNotArray: typeof isNotArray;
      readonly isNotEmpty: (value: unknown) => boolean;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
    }>>;
  };
  isBoolean: () => BooleanRuleInstance;
  isNull: () => NullRuleInstance;
  isNullish: () => NullishRuleInstance;
  isNumber: () => RuleInstance<number, [number]> & {
    readonly defaultTo: (fallback: {}) => BuildRuleInstance<{}, [number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly parseJSON: () => BuildRuleInstance<unknown, [number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly toBoolean: () => BuildRuleInstance<boolean, [number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly ceil: () => BuildRuleInstance<number, [number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly clamp: (min: number, max: number) => BuildRuleInstance<number, [number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly floor: () => BuildRuleInstance<number, [number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly round: () => BuildRuleInstance<number, [number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly toAbsolute: () => BuildRuleInstance<number, [number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly toDate: () => BuildRuleInstance<Date, [number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly toFloat: () => BuildRuleInstance<number, [number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly toInteger: (radix?: number | undefined) => BuildRuleInstance<number, [number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly gt: (gt: string | number) => BuildRuleInstance<number, [number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly gte: (gte: string | number) => BuildRuleInstance<number, [number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly lt: (lt: string | number) => BuildRuleInstance<number, [number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly lte: (lte: string | number) => BuildRuleInstance<number, [number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly eq: (v: unknown) => BuildRuleInstance<number, [number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly neq: (n: string | number) => BuildRuleInstance<number, [number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly equals: (v: unknown) => BuildRuleInstance<number, [number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly greaterThan: (gt: string | number) => BuildRuleInstance<number, [number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly greaterThanOrEquals: (gte: string | number) => BuildRuleInstance<number, [number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly isBetween: (min: string | number, max: string | number) => BuildRuleInstance<number, [number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly isEven: () => BuildRuleInstance<number, [number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly isNaN: () => BuildRuleInstance<number, [number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly isNegative: () => BuildRuleInstance<number, [number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly isNotBetween: (min: number, max: number) => BuildRuleInstance<number, [number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly isNotNaN: () => BuildRuleInstance<number, [number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly isNumber: () => BuildRuleInstance<number, [number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly isOdd: () => BuildRuleInstance<number, [number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly isPositive: () => BuildRuleInstance<number, [number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly lessThan: (lt: string | number) => BuildRuleInstance<number, [number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly lessThanOrEquals: (lte: string | number) => BuildRuleInstance<number, [number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly numberEquals: (eq: string | number) => BuildRuleInstance<number, [number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly numberNotEquals: (n: string | number) => BuildRuleInstance<number, [number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly toNumber: () => BuildRuleInstance<number, [number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
  };
  isNumeric: () => RuleInstance<string | number, [string | number]> & {
    readonly defaultTo: (fallback: {}) => BuildRuleInstance<{}, [string | number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly parseJSON: () => BuildRuleInstance<unknown, [string | number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly toBoolean: () => BuildRuleInstance<boolean, [string | number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly ceil: () => BuildRuleInstance<number, [string | number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly clamp: (min: number, max: number) => BuildRuleInstance<number, [string | number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly floor: () => BuildRuleInstance<number, [string | number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly round: () => BuildRuleInstance<number, [string | number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly toAbsolute: () => BuildRuleInstance<number, [string | number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly toDate: () => BuildRuleInstance<Date, [string | number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly toFloat: () => BuildRuleInstance<number, [string | number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly toInteger: (radix?: number | undefined) => BuildRuleInstance<number, [string | number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly gt: (gt: string | number) => BuildRuleInstance<string | number, [string | number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly gte: (gte: string | number) => BuildRuleInstance<string | number, [string | number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly lt: (lt: string | number) => BuildRuleInstance<string | number, [string | number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly lte: (lte: string | number) => BuildRuleInstance<string | number, [string | number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly eq: (v: unknown) => BuildRuleInstance<string | number, [string | number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly neq: (n: string | number) => BuildRuleInstance<string | number, [string | number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly equals: (v: unknown) => BuildRuleInstance<string | number, [string | number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly greaterThan: (gt: string | number) => BuildRuleInstance<string | number, [string | number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly greaterThanOrEquals: (gte: string | number) => BuildRuleInstance<string | number, [string | number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly isBetween: (min: string | number, max: string | number) => BuildRuleInstance<string | number, [string | number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly isEven: () => BuildRuleInstance<string | number, [string | number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly isNaN: () => BuildRuleInstance<string | number, [string | number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly isNegative: () => BuildRuleInstance<string | number, [string | number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly isNotBetween: (min: number, max: number) => BuildRuleInstance<string | number, [string | number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly isNotNaN: () => BuildRuleInstance<string | number, [string | number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly isNumber: () => BuildRuleInstance<string | number, [string | number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly isOdd: () => BuildRuleInstance<string | number, [string | number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly isPositive: () => BuildRuleInstance<string | number, [string | number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly lessThan: (lt: string | number) => BuildRuleInstance<string | number, [string | number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly lessThanOrEquals: (lte: string | number) => BuildRuleInstance<string | number, [string | number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly numberEquals: (eq: string | number) => BuildRuleInstance<string | number, [string | number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly numberNotEquals: (n: string | number) => BuildRuleInstance<string | number, [string | number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
    readonly toNumber: () => BuildRuleInstance<number, [string | number], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly ceil: (value: number) => RuleRunReturn<number>;
      readonly clamp: (value: number, min: number, max: number) => RuleRunReturn<number>;
      readonly floor: (value: number) => RuleRunReturn<number>;
      readonly round: (value: number) => RuleRunReturn<number>;
      readonly toAbsolute: (value: number) => RuleRunReturn<number>;
      readonly toDate: (value: unknown) => RuleRunReturn<Date>;
      readonly toFloat: (value: unknown) => RuleRunReturn<number>;
      readonly toInteger: (value: unknown, radix?: number) => RuleRunReturn<number>;
      readonly gt: typeof greaterThan;
      readonly gte: typeof greaterThanOrEquals;
      readonly lt: typeof lessThan;
      readonly lte: typeof lessThanOrEquals;
      readonly eq: typeof equals$1;
      readonly neq: typeof numberNotEquals;
      readonly equals: typeof equals$1;
      readonly greaterThan: typeof greaterThan;
      readonly greaterThanOrEquals: typeof greaterThanOrEquals;
      readonly isBetween: typeof isBetween;
      readonly isEven: (value: string | number) => boolean;
      readonly isNaN: typeof isNaN;
      readonly isNegative: typeof isNegative;
      readonly isNotBetween: typeof isNotBetween;
      readonly isNotNaN: typeof isNotNaN;
      readonly isNumber: typeof isNumber;
      readonly isOdd: (value: string | number) => boolean;
      readonly isPositive: typeof isPositive;
      readonly lessThan: typeof lessThan;
      readonly lessThanOrEquals: typeof lessThanOrEquals;
      readonly numberEquals: typeof numberEquals;
      readonly numberNotEquals: typeof numberNotEquals;
      readonly toNumber: typeof toNumber;
    }>>;
  };
  isString: () => RuleInstance<string, [string]> & {
    readonly defaultTo: (fallback: {}) => BuildRuleInstance<{}, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly parseJSON: () => BuildRuleInstance<unknown, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly toBoolean: () => BuildRuleInstance<boolean, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly append: (suffix: string) => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly normalizeWhitespace: () => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly prepend: (prefix: string) => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly removeNonAlphanumeric: () => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly removeNonDigits: () => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly removeNonLetters: () => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly replace: (searchValue: string | RegExp, replaceValue: string) => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly replaceAll: (searchValue: string | RegExp, replaceValue: string) => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly split: (separator: string | RegExp, limit?: number | undefined) => BuildRuleInstance<string[], [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly stripWhitespace: () => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly toCamel: () => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly toCapitalized: () => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly toKebab: () => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly toLower: () => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly toPascal: () => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly toSnake: () => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly toTitle: () => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly toUpper: () => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly trim: () => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly trimEnd: () => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly trimStart: () => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly doesNotEndWith: (ending: string) => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly doesNotStartWith: (start: string) => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly endsWith: (ending: string) => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly equals: (b: unknown) => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly inside: (container: string | unknown[]) => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly isBlank: () => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly isNotBlank: () => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly isString: () => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly lengthEquals: (n: number) => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly lengthNotEquals: (n: number) => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly longerThan: (n: number) => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly longerThanOrEquals: (n: number) => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly matches: (regex: string | RegExp) => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly maxLength: (n: number) => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly minLength: (n: number) => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly notEquals: (b: unknown) => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly notInside: (container: any) => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly notMatches: (regex: string | RegExp) => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly shorterThan: (n: number) => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly shorterThanOrEquals: (n: number) => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
    readonly startsWith: (start: string) => BuildRuleInstance<string, [string], ExtractRuleFunctions<{
      readonly defaultTo: typeof defaultTo;
      readonly parseJSON: (value: string) => RuleRunReturn<unknown>;
      readonly toBoolean: typeof toBoolean;
      readonly append: (value: string, suffix: string) => RuleRunReturn<string>;
      readonly normalizeWhitespace: (value: string) => RuleRunReturn<string>;
      readonly prepend: (value: string, prefix: string) => RuleRunReturn<string>;
      readonly removeNonAlphanumeric: (value: string) => RuleRunReturn<string>;
      readonly removeNonDigits: (value: string) => RuleRunReturn<string>;
      readonly removeNonLetters: (value: string) => RuleRunReturn<string>;
      readonly replace: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly replaceAll: (value: string, searchValue: string | RegExp, replaceValue: string) => RuleRunReturn<string>;
      readonly split: (value: string, separator: string | RegExp, limit?: number) => RuleRunReturn<string[]>;
      readonly stripWhitespace: (value: string) => RuleRunReturn<string>;
      readonly toCamel: (value: string) => RuleRunReturn<string>;
      readonly toCapitalized: (value: string) => RuleRunReturn<string>;
      readonly toKebab: (value: string) => RuleRunReturn<string>;
      readonly toLower: (value: string) => RuleRunReturn<string>;
      readonly toPascal: (value: string) => RuleRunReturn<string>;
      readonly toSnake: (value: string) => RuleRunReturn<string>;
      readonly toTitle: (value: string) => RuleRunReturn<string>;
      readonly toUpper: (value: string) => RuleRunReturn<string>;
      readonly trim: (value: string) => RuleRunReturn<string>;
      readonly trimEnd: (value: string) => RuleRunReturn<string>;
      readonly trimStart: (value: string) => RuleRunReturn<string>;
      readonly doesNotEndWith: typeof doesNotEndWith;
      readonly doesNotStartWith: typeof doesNotStartWith;
      readonly endsWith: typeof endsWith;
      readonly equals: typeof equals;
      readonly inside: typeof inside;
      readonly isBlank: typeof isBlankString;
      readonly isNotBlank: typeof isNotBlank;
      readonly isString: typeof isString;
      readonly lengthEquals: typeof lengthEquals;
      readonly lengthNotEquals: typeof lengthNotEquals;
      readonly longerThan: typeof longerThan;
      readonly longerThanOrEquals: typeof longerThanOrEquals;
      readonly matches: typeof matches;
      readonly maxLength: typeof maxLength;
      readonly minLength: typeof minLength;
      readonly notEquals: typeof notEquals;
      readonly notInside: typeof notInside;
      readonly notMatches: typeof notMatches;
      readonly shorterThan: typeof shorterThan;
      readonly shorterThanOrEquals: typeof shorterThanOrEquals;
      readonly startsWith: typeof startsWith;
    }>>;
  };
  isUndefined: () => UndefinedRuleInstance;
  isKeyOf: (...args: any[]) => ObjectRulesUnion;
  isNotKeyOf: (...args: any[]) => ObjectRulesUnion;
  isValueOf: (...args: any[]) => ObjectRulesUnion;
  isNotValueOf: (...args: any[]) => ObjectRulesUnion;
  condition: (...args: any[]) => AnyRuleInstance;
  equals: (...args: any[]) => AnyRuleInstance;
  notEquals: (...args: any[]) => AnyRuleInstance;
  isEmpty: (...args: any[]) => AnyRuleInstance;
  isFalsy: (...args: any[]) => AnyRuleInstance;
  isNaN: (...args: any[]) => AnyRuleInstance;
  isNotArray: (...args: any[]) => AnyRuleInstance;
  isNotBoolean: (...args: any[]) => AnyRuleInstance;
  isNotEmpty: (...args: any[]) => AnyRuleInstance;
  isNotNaN: (...args: any[]) => AnyRuleInstance;
  isNotNumber: (...args: any[]) => AnyRuleInstance;
  isNotNumeric: (...args: any[]) => AnyRuleInstance;
  isNotString: (...args: any[]) => AnyRuleInstance;
  isTruthy: (...args: any[]) => AnyRuleInstance;
  isNotNull: (...args: any[]) => AnyRuleInstance;
  isNotUndefined: (...args: any[]) => AnyRuleInstance;
  isNotNullish: (...args: any[]) => AnyRuleInstance;
  isBlank: (...args: any[]) => AnyRuleInstance;
  isNotBlank: (...args: any[]) => AnyRuleInstance;
  isArrayOf: <Rules extends RuleInstance<any, any>[]>(...rules: Rules) => IsArrayOfRuleInstance<MultiTypeInput<Rules>, MultiTypeInputArgs<Rules>>;
  list: <Rules extends RuleInstance<any, any>[]>(...rules: Rules) => IsArrayOfRuleInstance<MultiTypeInput<Rules>, MultiTypeInputArgs<Rules>>;
  lazy: <T$1>(factory: () => RuleInstance<T$1, any>) => LazyRuleInstance<T$1>;
  loose: <S extends Record<string, RuleInstance<any>>>(schema: S) => LooseRuleInstance<S>;
  optional: <R extends RuleInstance<any>>(rule: R) => OptionalRuleInstance<R["infer"]>;
  partial: <S extends Record<string, RuleInstance<any>>>(schema: S) => PartialRuleInstance<S>;
  pick: <S extends Record<string, RuleInstance<any>>>(schema: S, keys: string[] | string) => PickRuleInstance<S>;
  omit: <S extends Record<string, RuleInstance<any>>>(schema: S, keys: string[] | string) => OmitRuleInstance<S>;
  shape: <S extends Record<string, RuleInstance<any>>>(schema: S) => ShapeRuleInstance<S>;
  record: {
    <V extends RuleInstance<any, any>>(valueRule: V): RecordRuleInstance<never, V>;
    <K$1 extends RuleInstance<string, any>, V extends RuleInstance<any, any>>(keyRule: K$1, valueRule: V): RecordRuleInstance<K$1, V>;
  };
  tuple: <Rules extends RuleInstance<any, any>[]>(...rules: Rules) => TupleRuleInstance<Rules>;
  allOf: <T$1>(...rules: any[]) => AllOfRuleInstance<T$1>;
  anyOf: <Rules extends RuleInstance<any>[]>(...rules: Rules) => AnyOfRuleInstance<Rules[number]["infer"]>;
  noneOf: <T$1>(...rules: any[]) => NoneOfRuleInstance<T$1>;
  oneOf: <Rules extends RuleInstance<any>[]>(...rules: Rules) => OneOfRuleInstance<Rules[number]["infer"]>;
};
/**
 * Lazy (builder) API for creating reusable validation rules.
 * Rules are created without a value and can be executed later with `run()` or `test()`.
 *
 * This is the builder pattern side of the enforce API - rules are chainable and reusable.
 *
 * @example
 * ```typescript
 * // Create reusable rules
 * const stringRule = enforce.isString();
 * const emailRule = enforce.isString().matches(/@/);
 *
 * // Test with values
 * stringRule.test('hello'); // true
 * stringRule.test(123); // false
 *
 * // Run for detailed results
 * const result = emailRule.run('user@example.com');
 * console.log(result.pass); // true
 *
 * // Chain type-specific rules
 * const ageRule = enforce.isNumber()
 *   .greaterThanOrEquals(18)
 *   .lessThan(150);
 *
 * // Schema validation
 * const userSchema = enforce.shape({
 *   name: enforce.isString(),
 *   email: enforce.isString().matches(/@/),
 *   age: ageRule
 * });
 *
 * userSchema.test({ name: 'John', email: 'john@example.com', age: 25 }); // true
 * ```
 */
declare const enforceLazy: TCustomLazyRules & typeof baseEnforceLazy;
//#endregion
//#region src/compose.d.ts
type ComposeResult<T$1 = any> = RuleInstance<T$1, [T$1]> & {
  (value: T$1): void;
};
/**
 * Composes multiple validation rules into a single reusable rule.
 * The composed rule executes rules in order and fails on the first failing rule.
 * Returns a RuleInstance that can be used with both eager and lazy APIs.
 *
 * @template T - The type of value to validate
 * @param composites - Validation rules to compose
 * @returns A composed rule that can be run with values or called directly
 *
 * @example
 * ```typescript
 * // Create a reusable adult age validation
 * const isAdult = compose(
 *   enforce.isNumber(),
 *   enforce.greaterThanOrEquals(18),
 *   enforce.lessThan(150)
 * );
 *
 * // Use with lazy API
 * isAdult.test(25); // true
 * isAdult.test(16); // false
 *
 * // Use with eager API
 * enforce(30).run(isAdult); // passes
 *
 * // Call directly (throws on failure)
 * isAdult(25); // ok
 * isAdult(16); // throws
 *
 * // Compose with other rules
 * const userSchema = enforce.shape({
 *   age: isAdult,
 *   name: enforce.isString()
 * });
 * ```
 */
declare function compose<T$1 = any>(...composites: RuleInstance<any, [any]>[]): ComposeResult<T$1>;
//#endregion
//#region src/n4s.d.ts
type ExtendFn = (rules: Record<string, (...args: any[]) => any>) => void;
type ContextFn = () => EnforceContext;
type Enforce = typeof enforceEager & typeof enforceLazy & {
  extend: ExtendFn;
  context: ContextFn;
};
declare namespace enforce {
  type infer<R extends RuleInstance<any, any>> = R['infer'];
}
/**
 * Main validation function supporting both eager (imperative) and lazy (builder) APIs.
 *
 * **Eager API (Imperative):**
 * Immediately validates a value with chainable assertions that execute on call.
 *
 * **Lazy API (Builder Pattern):**
 * Builds a reusable validation rule without a value, returns a RuleInstance.
 *
 * @example
 * ```typescript
 * // Eager API - validates immediately
 * enforce('hello').isString().longerThan(3);
 *
 * // Lazy API - builds a reusable rule
 * const stringRule = enforce.isString();
 * stringRule.test('hello'); // true
 * stringRule.run('hello'); // RuleRunReturn { pass: true, type: 'hello' }
 *
 * // Custom messages
 * enforce('').message('Field is required').isNotEmpty();
 *
 * // Schema validation
 * enforce({ name: 'John', age: 30 }).shape({
 *   name: enforce.isString(),
 *   age: enforce.isNumber()
 * });
 * ```
 */
declare const enforce: Enforce;
//#endregion
export { compose, ctx, enforce };
//# sourceMappingURL=n4s.d.cts.map