@regle/rules 1.10.1 → 1.11.0-beta.2

package/dist/regle-rules.d.ts

@@ -1,8 +1,6 @@
 import { AllRulesDeclarations, CommonAlphaOptions, CommonComparisonOptions, FormRuleDeclaration, InlineRuleDeclaration, Maybe, MaybeInput, MaybeReadonly, NonEmptyTuple, RegleRuleDecl, RegleRuleDefinition, RegleRuleDefinitionWithMetadataProcessor, RegleRuleMetadataConsumer, RegleRuleMetadataDefinition, RegleRuleWithParamsDefinition, UnwrapRegleUniversalParams } from "@regle/core";
 import { ComputedRef, MaybeRef, MaybeRefOrGetter, Ref } from "vue";
-
-//#region src/helpers/withMessage.d.ts
-
+import { EmptyObject } from "type-fest";
 /**
  * The withMessage wrapper lets you associate an error message with a rule. Pass your rule as the first argument and the error message as the second.
  *
@@ -24,16 +22,12 @@ declare function withMessage<TValue extends any, TParams extends any[], TReturn
 declare function withMessage<TValue extends any, TParams extends unknown[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>, TMetadata extends RegleRuleMetadataDefinition = (TReturn extends Promise<infer M> ? M : TReturn), TAsync extends boolean = (TReturn extends Promise<any> ? true : false)>(rule: RegleRuleDefinition<TValue, TParams, TAsync, TMetadata>, newMessage: RegleRuleDefinitionWithMetadataProcessor<TValue, RegleRuleMetadataConsumer<TValue, TParams, TMetadata>, string | string[]>): RegleRuleDefinition<TValue, TParams, TAsync, TMetadata>;
 declare function withMessage<TValue extends any, TParams extends any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>, TAsync extends boolean = (TReturn extends Promise<any> ? true : false)>(rule: InlineRuleDeclaration<TValue, TParams, TReturn>, newMessage: RegleRuleDefinitionWithMetadataProcessor<TValue, RegleRuleMetadataConsumer<TValue, TParams, TReturn extends Promise<infer M> ? M : TReturn>, string | string[]>): RegleRuleDefinition<TValue, TParams, TAsync, TReturn extends Promise<infer M> ? M : TReturn>;
 declare function withMessage<TValue extends any, TParams extends any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>, TMetadata extends RegleRuleMetadataDefinition = (TReturn extends Promise<infer M> ? M : TReturn), TAsync extends boolean = (TReturn extends Promise<any> ? true : false)>(rule: (...args: any[]) => RegleRuleDefinition<TValue, TParams, TAsync, TMetadata>, newMessage: RegleRuleDefinitionWithMetadataProcessor<TValue, RegleRuleMetadataConsumer<TValue, TParams, TMetadata>, string | string[]>): RegleRuleWithParamsDefinition<TValue, TParams, TAsync, TMetadata>;
-//#endregion
-//#region src/helpers/withTooltip.d.ts
 /**
  * The withTooltip wrapper allows you to display additional messages for your field that aren’t necessarily errors. Tooltips are aggregated and accessible via $fields.xxx.$tooltips .
  */
 declare function withTooltip<TValue extends any, TParams extends any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>, TMetadata extends RegleRuleMetadataDefinition = (TReturn extends Promise<infer M> ? M : TReturn), TAsync extends boolean = (TReturn extends Promise<any> ? true : false)>(rule: RegleRuleWithParamsDefinition<TValue, TParams, TAsync, TMetadata>, newTooltip: RegleRuleDefinitionWithMetadataProcessor<TValue, RegleRuleMetadataConsumer<TValue, TParams, TMetadata>, string | string[]>): RegleRuleWithParamsDefinition<TValue, TParams, TAsync, TMetadata>;
 declare function withTooltip<TValue extends any, TParams extends any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>, TMetadata extends RegleRuleMetadataDefinition = (TReturn extends Promise<infer M> ? M : TReturn), TAsync extends boolean = (TReturn extends Promise<any> ? true : false)>(rule: RegleRuleDefinition<TValue, TParams, TAsync, TMetadata>, newTooltip: RegleRuleDefinitionWithMetadataProcessor<TValue, RegleRuleMetadataConsumer<TValue, TParams, TMetadata>, string | string[]>): RegleRuleDefinition<TValue, TParams, TAsync, TMetadata>;
 declare function withTooltip<TValue extends any, TParams extends any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>, TAsync extends boolean = (TReturn extends Promise<any> ? true : false)>(rule: InlineRuleDeclaration<TValue, TParams, TReturn>, newTooltip: RegleRuleDefinitionWithMetadataProcessor<TValue, RegleRuleMetadataConsumer<TValue, TParams, TReturn extends Promise<infer M> ? M : TReturn>, string | string[]>): RegleRuleDefinition<TValue, TParams, TAsync, TReturn extends Promise<infer M> ? M : TReturn>;
-//#endregion
-//#region src/helpers/withAsync.d.ts
 /**
  * withAsync works like withParams, but is specifically designed for async rules that depend on external values.
  *
@@ -54,8 +48,6 @@ declare function withTooltip<TValue extends any, TParams extends any[], TReturn
  */
 declare function withAsync<TValue, TParams extends (Ref<unknown> | (() => unknown))[] = [], TReturn extends Promise<RegleRuleMetadataDefinition> = Promise<RegleRuleMetadataDefinition>, TMetadata extends RegleRuleMetadataDefinition = (TReturn extends Promise<infer M> ? M : TReturn)>(rule: InlineRuleDeclaration<TValue, TParams, TReturn>, depsArray?: [...TParams]): RegleRuleDefinition<TValue, UnwrapRegleUniversalParams<TParams>, true, TMetadata>;
 declare function withAsync<TValue extends any, TParams extends any[], TMetadata extends RegleRuleMetadataDefinition>(rule: RegleRuleWithParamsDefinition<TValue, TParams, true, TMetadata>, depsArray?: [...TParams]): RegleRuleWithParamsDefinition<TValue, TParams, true, TMetadata>;
-//#endregion
-//#region src/helpers/withParams.d.ts
 /**
  * The withParams wrapper allows your rule to depend on external parameters, such as a reactive property in your component or store.
  *
@@ -78,8 +70,6 @@ declare function withAsync<TValue extends any, TParams extends any[], TMetadata
  */
 declare function withParams<TValue, TParams extends (Ref<unknown> | (() => unknown))[] = [], TReturn extends RegleRuleMetadataDefinition = RegleRuleMetadataDefinition, TMetadata extends RegleRuleMetadataDefinition = (TReturn extends Promise<infer M> ? M : TReturn), TAsync extends boolean = (TReturn extends Promise<any> ? true : false)>(rule: InlineRuleDeclaration<TValue, TParams, TReturn> | RegleRuleDefinition<TValue, any[], TAsync, TMetadata>, depsArray: [...TParams]): RegleRuleDefinition<TValue, UnwrapRegleUniversalParams<TParams>, TAsync, TMetadata>;
 declare function withParams<TValue extends any, TParams extends any[], TReturn extends RegleRuleMetadataDefinition = RegleRuleMetadataDefinition, TMetadata extends RegleRuleMetadataDefinition = (TReturn extends Promise<infer M> ? M : TReturn), TAsync extends boolean = (TReturn extends Promise<any> ? true : false)>(rule: RegleRuleWithParamsDefinition<TValue, TParams, TAsync, TMetadata>, depsArray: [...TParams]): RegleRuleWithParamsDefinition<TValue, TParams, TAsync, TMetadata>;
-//#endregion
-//#region src/helpers/applyIf.d.ts
 /**
  * The applyIf operator is similar to requiredIf, but it can be used with any rule.
  * It simplifies conditional rule declarations.
@@ -96,8 +86,6 @@ declare function withParams<TValue extends any, TParams extends any[], TReturn e
  * ```
  */
 declare function applyIf<TValue extends any, TParams extends any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition> = RegleRuleMetadataDefinition, TMetadata extends RegleRuleMetadataDefinition = (TReturn extends Promise<infer M> ? M : TReturn), TAsync extends boolean = (TReturn extends Promise<any> ? true : false)>(_condition: MaybeRefOrGetter<Maybe<boolean>>, rule: InlineRuleDeclaration<TValue, TParams, TReturn> | RegleRuleDefinition<TValue, TParams, TAsync, TMetadata>): RegleRuleDefinition<TValue, [...TParams, condition: boolean], TAsync, TMetadata>;
-//#endregion
-//#region src/helpers/ruleHelpers/isFilled.d.ts
 /**
  * This is almost a must have for optional fields. It checks if any value you provided is defined (including arrays and objects). You can base your validator result on this.
  *
@@ -107,67 +95,24 @@ declare function applyIf<TValue extends any, TParams extends any[], TReturn exte
  * @param [considerEmptyArrayInvalid=true] - will return true if set to `false`. (default: `true`)
  */
 declare function isFilled<T extends unknown>(value: T, considerEmptyArrayInvalid?: boolean): value is NonNullable<T>;
-//#endregion
-//#region src/helpers/ruleHelpers/isNumber.d.ts
 /**
  * This is a type guard that will check if the passed value is a real Number. This also returns false for NaN, so this is better than typeof value === "number".
  */
 declare function isNumber(value: unknown): value is number;
-//#endregion
-//#region src/helpers/ruleHelpers/matchRegex.d.ts
 /**
  * This utility can take multiple regular expressions as arguments. It checks the input's validity and tests it against the provided regex patterns.
  */
 declare function matchRegex(_value: string | number | null | undefined, ...expr: RegExp[]): boolean;
-//#endregion
-//#region src/helpers/ruleHelpers/getSize.d.ts
 /**
  * This helper will return the length of any data type you pass. It works with strings, arrays, objects and numbers.
  */
 declare function getSize(value: MaybeRef<string | any[] | Record<string, any> | number>): number;
-//#endregion
-//#region src/helpers/ruleHelpers/toNumber.d.ts
 /**
  * This utility converts any string (or number) into a number using the Number constructor.
  *
  * @returns ⚠️ Warning, returned value can be NaN
  */
 declare function toNumber<T extends number | string | undefined>(argument: T): number;
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.2.0/node_modules/type-fest/source/empty-object.d.ts
-declare const emptyObjectSymbol: unique symbol;
-
-/**
-Represents a strictly empty plain object, the `{}` value.
-
-When you annotate something as the type `{}`, it can be anything except `null` and `undefined`. This means that you cannot use `{}` to represent an empty plain object ([read more](https://stackoverflow.com/questions/47339869/typescript-empty-object-and-any-difference/52193484#52193484)).
-
-@example
-```
-import type {EmptyObject} from 'type-fest';
-
-// The following illustrates the problem with `{}`.
-const foo1: {} = {}; // Pass
-const foo2: {} = []; // Pass
-const foo3: {} = 42; // Pass
-const foo4: {} = {a: 1}; // Pass
-
-// With `EmptyObject` only the first case is valid.
-const bar1: EmptyObject = {}; // Pass
-const bar2: EmptyObject = 42; // Fail
-const bar3: EmptyObject = []; // Fail
-const bar4: EmptyObject = {a: 1}; // Fail
-```
-
-Unfortunately, `Record<string, never>`, `Record<keyof any, never>` and `Record<never, never>` do not work. See {@link https://github.com/sindresorhus/type-fest/issues/395 #395}.
-
-@category Object
-*/
-type EmptyObject = {
-  [emptyObjectSymbol]?: never;
-};
-//#endregion
-//#region ../shared/utils/isEmpty.d.ts
 /**
  * This is the inverse of isFilled. It will check if the value is in any way empty (including arrays and objects)
  *
@@ -177,20 +122,14 @@ type EmptyObject = {
  * @param [considerEmptyArrayInvalid=true] - will return false if set to `false`. (default: `true`)
  */
 declare function isEmpty(value: unknown, considerEmptyArrayInvalid?: boolean): value is null | undefined | [] | EmptyObject;
-//#endregion
-//#region ../shared/utils/isDate.d.ts
 /**
  * This is a useful helper that can check if the provided value is a Date, it is used internally for date rules. This can also check strings.
  */
 declare function isDate(value: unknown): value is Date | string;
-//#endregion
-//#region ../shared/utils/toDate.d.ts
 /**
  * This utility will coerce any string, number or Date value into a Date using the Date constructor.
  */
 declare function toDate(argument: Maybe<Date | number | string>): Date;
-//#endregion
-//#region src/types/utils/params.utils.d.ts
 type ExtractValueFromRules<T extends any[]> = T extends [infer F, ...infer R] ? F extends RegleRuleDefinition<infer V, any, any, any> ? [V, ...ExtractValueFromRules<R>] : F extends InlineRuleDeclaration<infer V, any> ? [V, ...ExtractValueFromRules<R>] : [F, ...ExtractValueFromRules<R>] : [];
 type ExtractAsyncStatesFromRules<T extends any[]> = T extends [infer F, ...infer R] ? F extends RegleRuleDefinition<any, any, infer A, any> ? [A, ...ExtractValueFromRules<R>] : F extends InlineRuleDeclaration<any, any> ? [ReturnType<F> extends Promise<any> ? true : false, ...ExtractValueFromRules<R>] : [F, ...ExtractValueFromRules<R>] : [];
 type ExtractAsync<T extends [...any[]]> = T extends [infer F, ...infer R] ? F extends true ? true : F extends false ? ExtractAsync<R> : false : false;
@@ -205,26 +144,18 @@ type ExtractMetadata<T extends [...any[]]> = T extends [infer F, ...infer R] ? F
 type GuessMetadataFromRules<T extends any[], TMeta = ExtractMetadata<ExtractMetaDataFromRules<T>>> = TMeta extends EmptyObject ? boolean : TMeta;
 type FilterTuple<T extends any[]> = T extends [infer F, ...infer R] ? [F] extends [[]] ? [...FilterTuple<R>] : [F, ...FilterTuple<R>] : [];
 type UnwrapTuples<T extends any[]> = FilterTuple<T> extends [infer U extends any[]] ? U : FilterTuple<T>;
-//#endregion
-//#region src/helpers/and.d.ts
 /**
  * The and operator combines multiple rules and validates successfully only if all provided rules are valid.
  */
 declare function and<const TRules extends [FormRuleDeclaration<any, any>, ...FormRuleDeclaration<any, any>[]]>(...rules: [...TRules]): RegleRuleDefinition<ExtractValueFromRules<TRules>[number], UnwrapTuples<ExtractParamsFromRules<TRules>>, GuessAsyncFromRules<TRules>, GuessMetadataFromRules<TRules>>;
-//#endregion
-//#region src/helpers/or.d.ts
 /**
  * The or operator validates successfully if at least one of the provided rules is valid.
  */
 declare function or<TRules extends [FormRuleDeclaration<any, any>, ...FormRuleDeclaration<any, any>[]]>(...rules: [...TRules]): RegleRuleDefinition<ExtractValueFromRules<TRules>[number], UnwrapTuples<ExtractParamsFromRules<TRules>>, GuessAsyncFromRules<TRules>, GuessMetadataFromRules<TRules>>;
-//#endregion
-//#region src/helpers/not.d.ts
 /**
  * The not operator passes when the provided rule fails and fails when the rule passes. It can be combined with other rules.
  */
 declare function not<TValue, TParams extends any[] = [], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition> = RegleRuleMetadataDefinition, TMetadata extends RegleRuleMetadataDefinition = (TReturn extends Promise<infer M> ? M : TReturn), TAsync extends boolean = (TReturn extends Promise<any> ? true : false)>(rule: RegleRuleDefinition<TValue, TParams, TAsync, TMetadata> | InlineRuleDeclaration<TValue, TParams, TReturn>, message?: RegleRuleDefinitionWithMetadataProcessor<TValue, RegleRuleMetadataConsumer<TValue, TParams, TMetadata>, string | string[]>): RegleRuleDefinition<TValue, TParams, TAsync, TMetadata>;
-//#endregion
-//#region src/helpers/assignIf.d.ts
 /**
  * The assignIf is a shorthand for conditional destructuring assignment.
  * It allows to apply multiple rules to a field conditionally.
@@ -240,24 +171,18 @@ declare function not<TValue, TParams extends any[] = [], TReturn extends RegleRu
  * ```
  */
 declare function assignIf<TValue extends unknown = any, TCustomRules extends Partial<AllRulesDeclarations> = Partial<AllRulesDeclarations>, TRulesDelc extends RegleRuleDecl<TValue, TCustomRules> = RegleRuleDecl<TValue, TCustomRules>>(_condition: MaybeRefOrGetter<Maybe<boolean>>, rules: TRulesDelc): ComputedRef<TRulesDelc>;
-//#endregion
-//#region src/rules/alpha.d.ts
 /**
  * Allows only alphabetic characters.
  *
  * @param [options] - Alpha rules options
  * */
 declare const alpha: RegleRuleWithParamsDefinition<string, [options?: CommonAlphaOptions | undefined], false, boolean, MaybeInput<string>, string>;
-//#endregion
-//#region src/rules/alphaNum.d.ts
 /**
  * Allows only alphanumeric characters.
  *
  * @param [options] - Alpha rules options
  */
 declare const alphaNum: RegleRuleWithParamsDefinition<string | number, [options?: CommonAlphaOptions | undefined], false, boolean, MaybeInput<string>>;
-//#endregion
-//#region src/rules/between.d.ts
 /**
  * Checks if a number is in specified bounds. min and max are both inclusive.
  *
@@ -265,38 +190,28 @@ declare const alphaNum: RegleRuleWithParamsDefinition<string | number, [options?
  * @param max - the maximum limit
  */
 declare const between: RegleRuleWithParamsDefinition<number, [min: number, max: number, options?: CommonComparisonOptions], false, boolean, MaybeInput<number>>;
-//#endregion
-//#region src/rules/boolean.d.ts
 /**
  * Requires a value to be a native boolean type
  *
  * Mainly used for typing
  */
 declare const boolean: RegleRuleDefinition<unknown, [], false, boolean, MaybeInput<boolean>, unknown>;
-//#endregion
-//#region src/rules/checked.d.ts
 /**
  * Requires a boolean value to be true. This is useful for checkbox inputs.
  */
 declare const checked: RegleRuleDefinition<boolean, [], false, boolean, MaybeInput<boolean>>;
-//#endregion
-//#region src/rules/contains.d.ts
 /**
  * Checks if the string contains the specified substring.
  *
  * @param part - the part the value needs to contain
  */
 declare const contains: RegleRuleWithParamsDefinition<string, [part: MaybeInput<string>], false, boolean, MaybeInput<string>>;
-//#endregion
-//#region src/rules/date.d.ts
 /**
  * Requires a value to be a native Date constructor
  *
  * Mainly used for typing
  */
 declare const date: RegleRuleDefinition<unknown, [], false, boolean, MaybeInput<Date>, unknown>;
-//#endregion
-//#region src/rules/dateAfter.d.ts
 /**
  * Checks if the date is after the given parameter.
  *
@@ -310,8 +225,6 @@ declare const dateAfter: RegleRuleWithParamsDefinition<string | Date, [after: Ma
   $valid: false;
   error: 'value-or-parameter-not-a-date';
 }, MaybeInput<string | Date>>;
-//#endregion
-//#region src/rules/dateBefore.d.ts
 /**
  * Checks if the date is before the given parameter.
  *
@@ -325,8 +238,6 @@ declare const dateBefore: RegleRuleWithParamsDefinition<string | Date, [before:
   $valid: false;
   error: 'value-or-parameter-not-a-date';
 }, MaybeInput<string | Date>>;
-//#endregion
-//#region src/rules/dateBetween.d.ts
 /**
  * Checks if the date falls between the specified bounds.
  *
@@ -335,74 +246,52 @@ declare const dateBefore: RegleRuleWithParamsDefinition<string | Date, [before:
  * @param options - comparison options
  */
 declare const dateBetween: RegleRuleWithParamsDefinition<string | Date, [before: MaybeInput<string | Date>, after: MaybeInput<string | Date>, options?: CommonComparisonOptions], false, boolean, MaybeInput<string | Date>>;
-//#endregion
-//#region src/rules/decimal.d.ts
 /**
  * Allows positive and negative decimal numbers.
  */
 declare const decimal: RegleRuleDefinition<string | number, [], false, boolean, MaybeInput<number | undefined>>;
-//#endregion
-//#region src/rules/email.d.ts
 /**
  * Validates email addresses. Always verify on the server to ensure the address is real and not already in use.
  */
 declare const email: RegleRuleDefinition<string, [], false, boolean, MaybeInput<string>>;
-//#endregion
-//#region src/rules/endsWith.d.ts
 /**
  * Checks if the string ends with the specified substring.
  *
  * @param part - the value the field must end with
  */
 declare const endsWith: RegleRuleWithParamsDefinition<string, [part: MaybeInput<string>], false, boolean, MaybeInput<string>>;
-//#endregion
-//#region src/rules/exactLength.d.ts
 /**
  * Requires the input value to have a strict specified length, inclusive. Works with arrays, objects and strings.
  *
  * @param count - the required length
  */
 declare const exactLength: RegleRuleWithParamsDefinition<string | any[] | Record<PropertyKey, any>, [count: number], false, boolean>;
-//#endregion
-//#region src/rules/exactValue.d.ts
 /**
  * Requires a field to have a strict numeric value.
  */
 declare const exactValue: RegleRuleWithParamsDefinition<number, [count: number], false, boolean, MaybeInput<number>>;
-//#endregion
-//#region src/rules/hexadecimal.d.ts
 /**
  * Allows only hexadecimal values.
  */
 declare const hexadecimal: RegleRuleDefinition<string, [], false, boolean, MaybeInput<string>>;
-//#endregion
-//#region src/rules/integer.d.ts
 /**
  * Allows only integers (positive and negative).
  */
 declare const integer: RegleRuleDefinition<string | number, [], false, boolean, MaybeInput<number>>;
-//#endregion
-//#region src/rules/ipv4Address.d.ts
 /**
  * Validates IPv4 addresses in dotted decimal notation 127.0.0.1.
  */
 declare const ipv4Address: RegleRuleDefinition<string, [], false, boolean, MaybeInput<string>>;
-//#endregion
-//#region src/rules/literal.d.ts
 /**
  * Allow only one possible literal value
  */
 declare function literal<const TValue extends string | number>(literal: MaybeRefOrGetter<TValue>): RegleRuleDefinition<TValue, [literal: TValue], false, boolean, MaybeInput<TValue>, string | number>;
-//#endregion
-//#region src/rules/macAddress.d.ts
 /**
  * Validates MAC addresses. Call as a function to specify a custom separator (e.g., ':' or an empty string for 00ff1122334455).
  *
  * @param separator - the custom separator
  */
 declare const macAddress: RegleRuleWithParamsDefinition<string, [separator?: string | undefined], false, boolean, MaybeInput<string>>;
-//#endregion
-//#region src/rules/maxLength.d.ts
 /**
  * Requires the input value to have a maximum specified length, inclusive. Works with arrays, objects and strings.
  *
@@ -410,8 +299,6 @@ declare const macAddress: RegleRuleWithParamsDefinition<string, [separator?: str
  * @param options - comparison options
  */
 declare const maxLength: RegleRuleWithParamsDefinition<string | any[] | Record<PropertyKey, any>, [count: number, options?: CommonComparisonOptions], false, boolean>;
-//#endregion
-//#region src/rules/maxValue.d.ts
 /**
  * Requires a field to have a specified maximum numeric value.
  *
@@ -419,8 +306,6 @@ declare const maxLength: RegleRuleWithParamsDefinition<string | any[] | Record<P
  * @param options - comparison options
  */
 declare const maxValue: RegleRuleWithParamsDefinition<number | string, [count: number | string, options?: CommonComparisonOptions], false, boolean, MaybeInput<number | string>>;
-//#endregion
-//#region src/rules/minLength.d.ts
 /**
  * Requires the input value to have a minimum specified length, inclusive. Works with arrays, objects and strings.
  *
@@ -428,8 +313,6 @@ declare const maxValue: RegleRuleWithParamsDefinition<number | string, [count: n
  * @param options - comparison options
  */
 declare const minLength: RegleRuleWithParamsDefinition<string | any[] | Record<PropertyKey, any>, [count: number, options?: CommonComparisonOptions], false, boolean>;
-//#endregion
-//#region src/rules/minValue.d.ts
 /**
  * Requires a field to have a specified minimum numeric value.
  *
@@ -437,8 +320,6 @@ declare const minLength: RegleRuleWithParamsDefinition<string | any[] | Record<P
  * @param options - comparison options
  */
 declare const minValue: RegleRuleWithParamsDefinition<number | string, [count: number | string, options?: CommonComparisonOptions], false, boolean, MaybeInput<number | string>>;
-//#endregion
-//#region src/rules/nativeEnum.d.ts
 type EnumLike = {
   [k: string]: string | number;
   [nu: number]: string;
@@ -447,22 +328,16 @@ type EnumLike = {
  * Validate against a native Typescript enum value.
  */
 declare function nativeEnum<T extends EnumLike>(enumLike: T): RegleRuleDefinition<MaybeInput<T[keyof T]>, [enumLike: T], false, boolean, MaybeInput<T[keyof T]>, string | number>;
-//#endregion
-//#region src/rules/number.d.ts
 /**
  * Requires a value to be a native number type
  *
  * Mainly used for typing
  */
 declare const number: RegleRuleDefinition<unknown, [], false, boolean, MaybeInput<number>, unknown>;
-//#endregion
-//#region src/rules/numeric.d.ts
 /**
  * Allows only numeric values (including numeric strings).
  */
 declare const numeric: RegleRuleDefinition<string | number, [], false, boolean, MaybeInput<string | number>>;
-//#endregion
-//#region src/rules/oneOf.d.ts
 interface OneOfFn {
   <const TValues extends NonEmptyTuple<string | number> | NonEmptyTuple<string> | NonEmptyTuple<number>>(options: MaybeReadonly<MaybeRefOrGetter<[...TValues]>>): RegleRuleDefinition<TValues[number], [options: TValues], false, boolean, MaybeInput<TValues[number]>, string | number>;
   /** Keep this definition without generics for inference */
@@ -472,36 +347,26 @@ interface OneOfFn {
  * Allow only one of the values from a fixed Array of possible entries.
  */
 declare const oneOf: OneOfFn;
-//#endregion
-//#region src/rules/regex.d.ts
 /**
  * Checks if the value matches one or more regular expressions.
  */
 declare const regex: RegleRuleWithParamsDefinition<string | number, [regexp: RegExp | RegExp[]], false, boolean, MaybeInput<string | number>>;
-//#endregion
-//#region src/rules/required.d.ts
 /**
  * Requires non-empty data. Checks for empty arrays and strings containing only whitespaces.
  */
 declare const required: RegleRuleDefinition<unknown, [], false, boolean, unknown>;
-//#endregion
-//#region src/rules/requiredIf.d.ts
 /**
  * Requires non-empty data, only if provided data property, ref, or a function resolves to true.
  *
  * @param condition - the condition to enable the required rule
  */
 declare const requiredIf: RegleRuleWithParamsDefinition<unknown, [condition: boolean], false, boolean>;
-//#endregion
-//#region src/rules/requiredUnless.d.ts
 /**
  * Requires non-empty data, only if provided data property, ref, or a function resolves to false.
  *
  * @param condition - the condition to disable the required rule
  */
 declare const requiredUnless: RegleRuleWithParamsDefinition<unknown, [condition: boolean], false, boolean>;
-//#endregion
-//#region src/rules/sameAs.d.ts
 interface SameAsFn {
   <TTarget extends unknown = unknown>(target: MaybeRefOrGetter<TTarget>, otherName?: MaybeRefOrGetter<string>): RegleRuleDefinition<TTarget, [target: TTarget, otherName?: string], false, boolean, TTarget extends MaybeInput<infer M> ? M : MaybeInput<TTarget>>;
   /** Keep this definition without generics for inference */
@@ -511,35 +376,26 @@ interface SameAsFn {
  * Checks if the value matches the specified property or ref.
  */
 declare const sameAs: SameAsFn;
-//#endregion
-//#region src/rules/startsWith.d.ts
 /**
  * Checks if the string starts with the specified substring.
  *
  * @private part - the value the field must start with
  */
 declare const startsWith: RegleRuleWithParamsDefinition<string, [part: MaybeInput<string>], false, boolean, MaybeInput<string>>;
-//#endregion
-//#region src/rules/string.d.ts
 /**
  * Requires a value to be a native string type
  *
  * Mainly used for typing
  */
 declare const string: RegleRuleDefinition<unknown, [], false, boolean, MaybeInput<string>, unknown>;
-//#endregion
-//#region src/rules/type.d.ts
 /**
  * Define the input type of a rule. No runtime validation.
  *
  * Override any input type set by other rules.
  */
 declare function type<T>(): RegleRuleDefinition<unknown, [], false, boolean, MaybeInput<T>>;
-//#endregion
-//#region src/rules/url.d.ts
 /**
  * Validates URLs.
  */
 declare const url: RegleRuleDefinition<string, [], false, boolean, MaybeInput<string>>;
-//#endregion
 export { EnumLike, alpha, alphaNum, and, applyIf, assignIf, between, boolean, checked, contains, date, dateAfter, dateBefore, dateBetween, decimal, email, endsWith, exactLength, exactValue, getSize, hexadecimal, integer, ipv4Address, isDate, isEmpty, isFilled, isNumber, literal, macAddress, matchRegex, maxLength, maxValue, minLength, minValue, nativeEnum, not, number, numeric, oneOf, or, regex, required, requiredIf, requiredUnless, sameAs, startsWith, string, toDate, toNumber, type, url, withAsync, withMessage, withParams, withTooltip };

package/dist/regle-rules.js

@@ -1,7 +1,6 @@
 import { InternalRuleType, createRule, unwrapRuleParameters } from "@regle/core";
 import { computed, toValue, unref } from "vue";
 
-//#region src/helpers/withMessage.ts
 function withMessage(rule, newMessage) {
 	let _type;
 	let validator;
@@ -30,8 +29,6 @@ function withMessage(rule, newMessage) {
 	} else return newRule;
 }
 
-//#endregion
-//#region src/helpers/withTooltip.ts
 function withTooltip(rule, newTooltip) {
 	let _type;
 	let validator;
@@ -59,8 +56,6 @@ function withTooltip(rule, newTooltip) {
 	} else return newRule;
 }
 
-//#endregion
-//#region src/helpers/withAsync.ts
 function withAsync(rule, depsArray) {
 	let _type;
 	let validator;
@@ -86,8 +81,6 @@ function withAsync(rule, depsArray) {
 	return newRule(...depsArray ?? []);
 }
 
-//#endregion
-//#region src/helpers/withParams.ts
 function withParams(rule, depsArray) {
 	let _type;
 	let validator;
@@ -112,8 +105,6 @@ function withParams(rule, depsArray) {
 	return newRule(...depsArray);
 }
 
-//#endregion
-//#region src/helpers/applyIf.ts
 /**
 * The applyIf operator is similar to requiredIf, but it can be used with any rule.
 * It simplifies conditional rule declarations.
@@ -163,8 +154,6 @@ function applyIf(_condition, rule) {
 	else return newRule;
 }
 
-//#endregion
-//#region ../shared/utils/isFile.ts
 /**
 * Server side friendly way of checking for a File
 */
@@ -172,8 +161,6 @@ function isFile(value) {
 	return value?.constructor?.name == "File" || value?.constructor?.name == "FileList";
 }
 
-//#endregion
-//#region ../shared/utils/isEmpty.ts
 /**
 * This is the inverse of isFilled. It will check if the value is in any way empty (including arrays and objects)
 *
@@ -193,12 +180,8 @@ function isEmpty(value, considerEmptyArrayInvalid = true) {
 	return !String(value).length;
 }
 
-//#endregion
-//#region ../shared/utils/symbol.ts
 const RegleRuleSymbol = Symbol("regle-rule");
 
-//#endregion
-//#region ../shared/utils/isDate.ts
 /**
 * This is a useful helper that can check if the provided value is a Date, it is used internally for date rules. This can also check strings.
 */
@@ -218,8 +201,6 @@ function isDate(value) {
 	}
 }
 
-//#endregion
-//#region ../shared/utils/toDate.ts
 /**
 * This utility will coerce any string, number or Date value into a Date using the Date constructor.
 */
@@ -232,8 +213,6 @@ function toDate(argument) {
 	else return /* @__PURE__ */ new Date(NaN);
 }
 
-//#endregion
-//#region src/helpers/ruleHelpers/isFilled.ts
 /**
 * This is almost a must have for optional fields. It checks if any value you provided is defined (including arrays and objects). You can base your validator result on this.
 *
@@ -246,8 +225,6 @@ function isFilled(value, considerEmptyArrayInvalid = true) {
 	return !isEmpty(typeof value === "string" ? value.trim() : value, considerEmptyArrayInvalid);
 }
 
-//#endregion
-//#region src/helpers/ruleHelpers/isNumber.ts
 /**
 * This is a type guard that will check if the passed value is a real Number. This also returns false for NaN, so this is better than typeof value === "number".
 */
@@ -258,8 +235,6 @@ function isNumber(value) {
 	else return true;
 }
 
-//#endregion
-//#region src/helpers/ruleHelpers/matchRegex.ts
 /**
 * This utility can take multiple regular expressions as arguments. It checks the input's validity and tests it against the provided regex patterns.
 */
@@ -272,8 +247,6 @@ function matchRegex(_value, ...expr) {
 	});
 }
 
-//#endregion
-//#region src/helpers/ruleHelpers/getSize.ts
 /**
 * This helper will return the length of any data type you pass. It works with strings, arrays, objects and numbers.
 */
@@ -288,8 +261,6 @@ function getSize(value) {
 	return String(_value).length;
 }
 
-//#endregion
-//#region src/helpers/ruleHelpers/toNumber.ts
 /**
 * This utility converts any string (or number) into a number using the Number constructor.
 *
@@ -307,8 +278,6 @@ function toNumber(argument) {
 	return NaN;
 }
 
-//#endregion
-//#region src/helpers/and.ts
 /**
 * The and operator combines multiple rules and validates successfully only if all provided rules are valid.
 */
@@ -375,8 +344,6 @@ function and(...rules) {
 	else return newRule;
 }
 
-//#endregion
-//#region src/helpers/or.ts
 /**
 * The or operator validates successfully if at least one of the provided rules is valid.
 */
@@ -434,8 +401,6 @@ function or(...rules) {
 	else return newRule;
 }
 
-//#endregion
-//#region src/helpers/not.ts
 /**
 * The not operator passes when the provided rule fails and fails when the rule passes. It can be combined with other rules.
 */
@@ -471,8 +436,6 @@ function not(rule, message) {
 	else return newRule;
 }
 
-//#endregion
-//#region src/helpers/assignIf.ts
 /**
 * The assignIf is a shorthand for conditional destructuring assignment.
 * It allows to apply multiple rules to a field conditionally.
@@ -494,8 +457,6 @@ function assignIf(_condition, rules) {
 	});
 }
 
-//#endregion
-//#region src/rules/alpha.ts
 const alphaRegex = /^[a-zA-Z]*$/;
 const alphaSymbolRegex = /^[\w.]+$/;
 /**
@@ -513,8 +474,6 @@ const alpha = createRule({
 	message: "The value is not alphabetical"
 });
 
-//#endregion
-//#region src/rules/alphaNum.ts
 const alphaNumRegex = /^[a-zA-Z0-9]*$/;
 const alphaNumSymbolRegex = /^[a-zA-Z0-9_]*$/;
 /**
@@ -532,8 +491,6 @@ const alphaNum = createRule({
 	message: "The value must be alpha-numeric"
 });
 
-//#endregion
-//#region src/rules/between.ts
 /**
 * Checks if a number is in specified bounds. min and max are both inclusive.
 *
@@ -560,8 +517,6 @@ const between = createRule({
 	}
 });
 
-//#endregion
-//#region src/rules/boolean.ts
 /**
 * Requires a value to be a native boolean type
 *
@@ -576,8 +531,6 @@ const boolean = createRule({
 	message: "The value must be a native boolean"
 });
 
-//#endregion
-//#region src/rules/checked.ts
 /**
 * Requires a boolean value to be true. This is useful for checkbox inputs.
 */
@@ -590,8 +543,6 @@ const checked = createRule({
 	message: "The field must be checked"
 });
 
-//#endregion
-//#region src/rules/contains.ts
 /**
 * Checks if the string contains the specified substring.
 *
@@ -608,8 +559,6 @@ const contains = createRule({
 	}
 });
 
-//#endregion
-//#region src/rules/date.ts
 /**
 * Requires a value to be a native Date constructor
 *
@@ -624,8 +573,6 @@ const date = createRule({
 	message: "The value must be a native Date constructor"
 });
 
-//#endregion
-//#region src/utils/getLocale.util.ts
 function getUserLocale() {
 	if (navigator.languages != void 0) return navigator.languages[0];
 	return navigator.language;
@@ -635,8 +582,6 @@ function formatLocaleDate(date$1) {
 	return "?";
 }
 
-//#endregion
-//#region src/rules/dateAfter.ts
 /**
 * Checks if the date is after the given parameter.
 *
@@ -668,8 +613,6 @@ const dateAfter = createRule({
 	}
 });
 
-//#endregion
-//#region src/rules/dateBefore.ts
 /**
 * Checks if the date is before the given parameter.
 *
@@ -701,8 +644,6 @@ const dateBefore = createRule({
 	}
 });
 
-//#endregion
-//#region src/rules/dateBetween.ts
 /**
 * Checks if the date falls between the specified bounds.
 *
@@ -723,8 +664,6 @@ const dateBetween = createRule({
 	}
 });
 
-//#endregion
-//#region src/rules/decimal.ts
 const decimalRegex = /^[-]?\d*(\.\d+)?$/;
 /**
 * Allows positive and negative decimal numbers.
@@ -738,8 +677,6 @@ const decimal = createRule({
 	message: "The value must be decimal"
 });
 
-//#endregion
-//#region src/rules/email.ts
 const emailRegex = /^(?:[A-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[A-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9]{2,}(?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])$/i;
 /**
 * Validates email addresses. Always verify on the server to ensure the address is real and not already in use.
@@ -753,8 +690,6 @@ const email = createRule({
 	message: "The value must be an valid email address"
 });
 
-//#endregion
-//#region src/rules/endsWith.ts
 /**
 * Checks if the string ends with the specified substring.
 *
@@ -771,8 +706,6 @@ const endsWith = createRule({
 	}
 });
 
-//#endregion
-//#region src/rules/exactLength.ts
 /**
 * Requires the input value to have a strict specified length, inclusive. Works with arrays, objects and strings.
 *
@@ -793,8 +726,6 @@ const exactLength = createRule({
 	}
 });
 
-//#endregion
-//#region src/rules/exactValue.ts
 /**
 * Requires a field to have a strict numeric value.
 */
@@ -813,8 +744,6 @@ const exactValue = createRule({
 	}
 });
 
-//#endregion
-//#region src/rules/hexadecimal.ts
 const hexadecimalRegex = /^[a-fA-F0-9]*$/;
 /**
 * Allows only hexadecimal values.
@@ -828,8 +757,6 @@ const hexadecimal = createRule({
 	message: "The value must be hexadecimal"
 });
 
-//#endregion
-//#region src/rules/integer.ts
 const integerRegex = /(^[0-9]*$)|(^-[0-9]+$)/;
 /**
 * Allows only integers (positive and negative).
@@ -843,8 +770,6 @@ const integer = createRule({
 	message: "The value must be an integer"
 });
 
-//#endregion
-//#region src/rules/ipv4Address.ts
 function nibbleValid(nibble) {
 	if (nibble.length > 3 || nibble.length === 0) return false;
 	if (nibble[0] === "0" && nibble !== "0") return false;
@@ -866,8 +791,6 @@ const ipv4Address = createRule({
 	message: "The value is not a valid IPv4 address"
 });
 
-//#endregion
-//#region src/rules/literal.ts
 /**
 * Allow only one possible literal value
 */
@@ -878,8 +801,6 @@ function literal(literal$1) {
 	}, [computed(() => toValue(literal$1))]), ({ $params: [literal$2] }) => `Value should be ${literal$2}.`);
 }
 
-//#endregion
-//#region src/rules/macAddress.ts
 /**
 * Validates MAC addresses. Call as a function to specify a custom separator (e.g., ':' or an empty string for 00ff1122334455).
 *
@@ -897,8 +818,6 @@ const macAddress = createRule({
 });
 const hexValid = (hex) => hex.toLowerCase().match(/^[0-9a-f]{2}$/);
 
-//#endregion
-//#region src/rules/maxLength.ts
 /**
 * Requires the input value to have a maximum specified length, inclusive. Works with arrays, objects and strings.
 *
@@ -923,8 +842,6 @@ const maxLength = createRule({
 	}
 });
 
-//#endregion
-//#region src/rules/maxValue.ts
 /**
 * Requires a field to have a specified maximum numeric value.
 *
@@ -950,8 +867,6 @@ const maxValue = createRule({
 	}
 });
 
-//#endregion
-//#region src/rules/minLength.ts
 /**
 * Requires the input value to have a minimum specified length, inclusive. Works with arrays, objects and strings.
 *
@@ -976,8 +891,6 @@ const minLength = createRule({
 	}
 });
 
-//#endregion
-//#region src/rules/minValue.ts
 /**
 * Requires a field to have a specified minimum numeric value.
 *
@@ -1003,8 +916,6 @@ const minValue = createRule({
 	}
 });
 
-//#endregion
-//#region src/rules/nativeEnum.ts
 function getValidEnumValues(obj) {
 	const validKeys = Object.keys(obj).filter((k) => typeof obj[obj[k]] !== "number");
 	const filtered = {};
@@ -1021,8 +932,6 @@ function nativeEnum(enumLike) {
 	}, [computed(() => toValue(enumLike))]), ({ $params: [enumLike$1] }) => `The value should be one of those options: ${Object.values(enumLike$1).join(", ")}.`);
 }
 
-//#endregion
-//#region src/rules/number.ts
 /**
 * Requires a value to be a native number type
 *
@@ -1037,8 +946,6 @@ const number = createRule({
 	message: "The value must be a native number"
 });
 
-//#endregion
-//#region src/rules/numeric.ts
 const numericRegex = /^\d*(\.\d+)?$/;
 /**
 * Allows only numeric values (including numeric strings).
@@ -1052,8 +959,6 @@ const numeric = createRule({
 	message: "The value must be numeric"
 });
 
-//#endregion
-//#region src/rules/oneOf.ts
 /**
 * Allow only one of the values from a fixed Array of possible entries.
 */
@@ -1066,8 +971,6 @@ const oneOf = createRule({
 	message: ({ $params: [options] }) => `The value should be one of those options: ${options.join(", ")}.`
 });
 
-//#endregion
-//#region src/rules/regex.ts
 /**
 * Checks if the value matches one or more regular expressions.
 */
@@ -1080,8 +983,6 @@ const regex = createRule({
 	message: "The value does not match the required pattern"
 });
 
-//#endregion
-//#region src/rules/required.ts
 /**
 * Requires non-empty data. Checks for empty arrays and strings containing only whitespaces.
 */
@@ -1093,8 +994,6 @@ const required = createRule({
 	message: "This field is required"
 });
 
-//#endregion
-//#region src/rules/requiredIf.ts
 /**
 * Requires non-empty data, only if provided data property, ref, or a function resolves to true.
 *
@@ -1112,8 +1011,6 @@ const requiredIf = createRule({
 	}
 });
 
-//#endregion
-//#region src/rules/requiredUnless.ts
 /**
 * Requires non-empty data, only if provided data property, ref, or a function resolves to false.
 *
@@ -1131,8 +1028,6 @@ const requiredUnless = createRule({
 	}
 });
 
-//#endregion
-//#region src/rules/sameAs.ts
 /**
 * Checks if the value matches the specified property or ref.
 */
@@ -1147,8 +1042,6 @@ const sameAs = createRule({
 	}
 });
 
-//#endregion
-//#region src/rules/startsWith.ts
 /**
 * Checks if the string starts with the specified substring.
 *
@@ -1165,8 +1058,6 @@ const startsWith = createRule({
 	}
 });
 
-//#endregion
-//#region src/rules/string.ts
 /**
 * Requires a value to be a native string type
 *
@@ -1181,8 +1072,6 @@ const string = createRule({
 	message: "The value must be a string"
 });
 
-//#endregion
-//#region src/rules/type.ts
 /**
 * Define the input type of a rule. No runtime validation.
 *
@@ -1192,8 +1081,6 @@ function type() {
 	return (() => true);
 }
 
-//#endregion
-//#region src/rules/url.ts
 /**
 * Regex taken from {@link https://gist.github.com/dperini/729294}
 */
@@ -1210,5 +1097,4 @@ const url = createRule({
 	message: "The value is not a valid URL address"
 });
 
-//#endregion
 export { alpha, alphaNum, and, applyIf, assignIf, between, boolean, checked, contains, date, dateAfter, dateBefore, dateBetween, decimal, email, endsWith, exactLength, exactValue, getSize, hexadecimal, integer, ipv4Address, isDate, isEmpty, isFilled, isNumber, literal, macAddress, matchRegex, maxLength, maxValue, minLength, minValue, nativeEnum, not, number, numeric, oneOf, or, regex, required, requiredIf, requiredUnless, sameAs, startsWith, string, toDate, toNumber, type, url, withAsync, withMessage, withParams, withTooltip };

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@regle/rules",
-  "version": "1.10.1",
+  "version": "1.11.0-beta.2",
   "description": "Collection of rules and helpers for Regle",
   "dependencies": {
-    "@regle/core": "1.10.1"
+    "@regle/core": "1.11.0-beta.2"
   },
   "devDependencies": {
     "@types/node": "22.19.0",
@@ -13,7 +13,7 @@
     "tsdown": "0.16.1",
     "type-fest": "5.2.0",
     "typescript": "5.9.3",
-    "vitest": "4.0.6",
+    "vitest": "4.0.13",
     "vue": "3.5.22",
     "vue-tsc": "3.1.3"
   },
@@ -21,14 +21,9 @@
   "exports": {
     ".": {
       "types": "./dist/regle-rules.d.ts",
-      "node": {
-        "import": {
-          "production": "./dist/regle-rules.min.js",
-          "development": "./dist/regle-rules.js",
-          "default": "./dist/regle-rules.js"
-        }
-      },
-      "import": "./dist/regle-rules.js"
+      "production": "./dist/regle-rules.min.js",
+      "development": "./dist/regle-rules.js",
+      "default": "./dist/regle-rules.js"
     },
     "./package.json": "./package.json",
     "./dist/*": "./dist/*"