@regle/rules 1.2.3 → 1.3.0

package/dist/regle-rules.d.ts

@@ -1,6 +1,24 @@
-import { RegleRuleMetadataDefinition, RegleRuleWithParamsDefinition, RegleRuleDefinitionWithMetadataProcessor, RegleRuleMetadataConsumer, RegleRuleDefinition, InlineRuleDeclaration, UnwrapRegleUniversalParams, Maybe, FormRuleDeclaration, CommonAlphaOptions, MaybeInput, CommonComparisonOptions, MaybeReadonly } from '@regle/core';
-import { Ref, MaybeRefOrGetter, MaybeRef } from 'vue';
-
+import { CommonAlphaOptions, CommonComparisonOptions, FormRuleDeclaration, InlineRuleDeclaration, Maybe, MaybeInput, MaybeReadonly, RegleRuleDefinition, RegleRuleDefinitionWithMetadataProcessor, RegleRuleMetadataConsumer, RegleRuleMetadataDefinition, RegleRuleWithParamsDefinition, UnwrapRegleUniversalParams } from "@regle/core";
+import { MaybeRef, MaybeRefOrGetter, Ref } from "vue";
+
+//#region src/helpers/withMessage.d.ts
+/**
+* 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.
+*
+* ```ts
+* const { r$ } = useRegle({ name: '' }, {
+name: {
+customRule1: withMessage((value) => !!value, "Custom Error"),
+customRule2: withMessage(customRuleInlineWithMetaData, "Custom Error"),
+customRule3: withMessage(
+customRuleInlineWithMetaData,
+({ $value, foo }) => `Custom Error: ${$value} ${foo}`
+),
+}
+})
+* ```
+* Docs: {@link https://reglejs.dev/core-concepts/rules/rule-wrappers#withmessage}
+*/
 /**
  * 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.
  *
@@ -18,17 +36,21 @@ import { Ref, MaybeRefOrGetter, MaybeRef } from 'vue';
  * ```
  * Docs: {@link https://reglejs.dev/core-concepts/rules/rule-wrappers#withmessage}
  */
-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: RegleRuleWithParamsDefinition<TValue, TParams, TAsync, TMetadata>, newMessage: RegleRuleDefinitionWithMetadataProcessor<TValue, RegleRuleMetadataConsumer<TValue, TParams, TMetadata>, string | string[]>): RegleRuleWithParamsDefinition<TValue, TParams, TAsync, TMetadata>;
-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: RegleRuleWithParamsDefinition<TValue, TParams, TAsync, TMetadata>, newMessage: RegleRuleDefinitionWithMetadataProcessor<TValue, RegleRuleMetadataConsumer<TValue, TParams, TMetadata>, string | string[]>): RegleRuleWithParamsDefinition<TValue, TParams, TAsync, TMetadata>;
+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>;
 
+//#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>;
+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.
  *
@@ -47,9 +69,11 @@ declare function withTooltip<TValue extends any, TParams extends any[], TReturn
  * ```
  * Docs: {@link https://reglejs.dev/core-concepts/rules/rule-wrappers#withasync}
  */
-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, 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.
  *
@@ -70,14 +94,18 @@ declare function withAsync<TValue extends any, TParams extends any[], TMetadata
  * ```
  * Docs: {@link https://reglejs.dev/core-concepts/rules/rule-wrappers#withparams}
  */
-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>;
+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.
  */
-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>;
+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.
  *
@@ -88,21 +116,29 @@ declare function applyIf<TValue extends any, TParams extends any[], TReturn exte
  */
 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.
  *
@@ -110,13 +146,27 @@ declare function getSize(value: MaybeRef<string | any[] | Record<string, any> |
  */
 declare function toNumber<T extends number | string | undefined>(argument: T): number;
 
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@4.40.1/node_modules/type-fest/source/observable-like.d.ts
 declare global {
-	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
-	interface SymbolConstructor {
-		readonly observable: symbol;
-	}
+  // eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+  interface SymbolConstructor {
+    readonly observable: symbol;
+  }
 }
 
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@4.40.1/node_modules/type-fest/source/empty-object.d.ts
+/**
+@remarks
+The TC39 observable proposal defines a `closed` property, but some implementations (such as xstream) do not as of 10/08/2021.
+As well, some guidance on making an `Observable` to not include `closed` property.
+@see https://github.com/tc39/proposal-observable/blob/master/src/Observable.js#L129-L130
+@see https://github.com/staltz/xstream/blob/6c22580c1d84d69773ee4b0905df44ad464955b3/src/index.ts#L79-L85
+@see https://github.com/benlesh/symbol-observable#making-an-object-observable
+
+@category Observable
+*/
 declare const emptyObjectSymbol: unique symbol;
 
 /**
@@ -145,8 +195,27 @@ Unfortunately, `Record<string, never>`, `Record<keyof any, never>` and `Record<n
 
 @category Object
 */
-type EmptyObject = {[emptyObjectSymbol]?: never};
+type EmptyObject = {
+  [emptyObjectSymbol]?: never;
+};
+
+//#endregion
+//#region ../shared/utils/isEmpty.d.ts
+/**
+Returns a `boolean` for whether the type is strictly equal to an empty plain object, the `{}` value.
+
+@example
+```
+import type {IsEmptyObject} from 'type-fest';
 
+type Pass = IsEmptyObject<{}>; //=> true
+type Fail = IsEmptyObject<[]>; //=> false
+type Fail = IsEmptyObject<null>; //=> false
+```
+
+@see EmptyObject
+@category Object
+*/
 /**
  * This is the inverse of isFilled. It will check if the value is in any way empty (including arrays and objects)
  *
@@ -157,24 +226,30 @@ type EmptyObject = {[emptyObjectSymbol]?: never};
  */
 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;
 
+//#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;
 type GuessAsyncFromRules<T extends any[]> = ExtractAsync<ExtractAsyncStatesFromRules<T>>;
 type ExtractParamsFromRules<T extends any[]> = T extends [infer F, ...infer R] ? F extends RegleRuleDefinition<any, infer P, any, any> ? [P, ...ExtractParamsFromRules<R>] : [F, ...ExtractParamsFromRules<R>] : [];
 type MetadataBase = {
-    $valid: boolean;
-    [x: string]: any;
+  $valid: boolean;
+  [x: string]: any;
 };
 type ExtractMetaDataFromRules<T extends any[]> = T extends [infer F, ...infer R] ? F extends RegleRuleDefinition<any, any, any, infer M extends MetadataBase> ? [M, ...ExtractMetaDataFromRules<R>] : F extends InlineRuleDeclaration<any, any[], infer M extends MetadataBase | Promise<MetadataBase>> ? [M, ...ExtractMetaDataFromRules<R>] : [...ExtractMetaDataFromRules<R>] : [];
 type ExtractMetadata<T extends [...any[]]> = T extends [infer F, ...infer R] ? F & ExtractMetadata<R> : {};
@@ -182,51 +257,57 @@ type GuessMetadataFromRules<T extends any[], TMeta = ExtractMetadata<ExtractMeta
 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>;
+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/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>;
+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>>;
+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.
  *
  * @param min - the minimum limit
  * @param max - the maximum limit
  */
-declare const between: RegleRuleWithParamsDefinition<number, [
-    min: number,
-    max: number,
-    options?: CommonComparisonOptions
-], false, boolean, MaybeInput<number>>;
+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
  *
@@ -234,20 +315,24 @@ declare const between: RegleRuleWithParamsDefinition<number, [
  */
 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>>;
+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
  *
@@ -255,40 +340,40 @@ declare const contains: RegleRuleWithParamsDefinition<string, [
  */
 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.
  *
  * @param after - the date to compare to
  * @param options - comparison options
  */
-declare const dateAfter: RegleRuleWithParamsDefinition<string | Date, [
-    after: MaybeInput<string | Date>,
-    options?: CommonComparisonOptions
-], false, true | {
-    $valid: false;
-    error: 'date-not-after';
+declare const dateAfter: RegleRuleWithParamsDefinition<string | Date, [after: MaybeInput<string | Date>, options?: CommonComparisonOptions], false, true | {
+  $valid: false;
+  error: 'date-not-after';
 } | {
-    $valid: false;
-    error: 'value-or-parameter-not-a-date';
+  $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.
  *
  * @param before - the date to compare to
  * @param options - comparison options
  */
-declare const dateBefore: RegleRuleWithParamsDefinition<string | Date, [
-    before: MaybeInput<string | Date>,
-    options?: CommonComparisonOptions
-], false, true | {
-    $valid: false;
-    error: 'date-not-before';
+declare const dateBefore: RegleRuleWithParamsDefinition<string | Date, [before: MaybeInput<string | Date>, options?: CommonComparisonOptions], false, true | {
+  $valid: false;
+  error: 'date-not-before';
 } | {
-    $valid: false;
-    error: 'value-or-parameter-not-a-date';
+  $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.
  *
@@ -296,130 +381,137 @@ declare const dateBefore: RegleRuleWithParamsDefinition<string | Date, [
  * @param after - the maximum limit
  * @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>>;
+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>>;
+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>>;
+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>;
+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>>;
+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>>;
+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.
  *
  * @param max - the maximum length
  * @param options - comparison options
  */
-declare const maxLength: RegleRuleWithParamsDefinition<string | any[] | Record<PropertyKey, any>, [
-    count: number,
-    options?: CommonComparisonOptions
-], false, boolean>;
+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.
  *
  * @param max - the maximum value
  * @param options - comparison options
  */
-declare const maxValue: RegleRuleWithParamsDefinition<number, [
-    count: number,
-    options?: CommonComparisonOptions
-], false, boolean, MaybeInput<number>>;
+declare const maxValue: RegleRuleWithParamsDefinition<number, [count: number, options?: CommonComparisonOptions], false, boolean, MaybeInput<number>>;
 
+//#endregion
+//#region src/rules/minLength.d.ts
 /**
  * Requires the input value to have a minimum specified length, inclusive. Works with arrays, objects and strings.
  *
  * @param min - the minimum value
  * @param options - comparison options
  */
-declare const minLength: RegleRuleWithParamsDefinition<string | any[] | Record<PropertyKey, any>, [
-    count: number,
-    options?: CommonComparisonOptions
-], false, boolean>;
+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.
  *
  * @param count - the minimum count
  * @param options - comparison options
  */
-declare const minValue: RegleRuleWithParamsDefinition<number, [
-    count: number,
-    options?: CommonComparisonOptions
-], false, boolean, MaybeInput<number>>;
+declare const minValue: RegleRuleWithParamsDefinition<number, [count: number, options?: CommonComparisonOptions], false, boolean, MaybeInput<number>>;
 
+//#endregion
+//#region src/rules/nativeEnum.d.ts
 type EnumLike = {
-    [k: string]: string | number;
-    [nu: number]: string;
+  [k: string]: string | number;
+  [nu: number]: string;
 };
 /**
  * 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
  *
@@ -427,31 +519,36 @@ declare function nativeEnum<T extends EnumLike>(enumLike: T): RegleRuleDefinitio
  */
 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>>;
+declare const numeric: RegleRuleDefinition<string | number, [], false, boolean, MaybeInput<string | number>>;
 
+//#endregion
+//#region src/rules/oneOf.d.ts
 /**
  * Allow only one of the values from a fixed Array of possible entries.
  */
-declare function oneOf<const TValues extends readonly [string | number, ...(string | number)[]]>(options: MaybeReadonly<MaybeRefOrGetter<[...TValues]>>): RegleRuleDefinition<TValues[number], [
-    options: TValues
-], false, boolean, MaybeInput<TValues[number]>, string | number>;
+declare function oneOf<const TValues extends readonly [string | number, ...(string | number)[]]>(options: MaybeReadonly<MaybeRefOrGetter<[...TValues]>>): RegleRuleDefinition<TValues[number], [options: TValues], false, boolean, MaybeInput<TValues[number]>, string | number>;
 
+//#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>>;
+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.
  *
@@ -459,6 +556,8 @@ declare const required: RegleRuleDefinition<unknown, [], false, boolean, unknown
  */
 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.
  *
@@ -466,23 +565,24 @@ declare const requiredIf: RegleRuleWithParamsDefinition<unknown, [condition: boo
  */
 declare const requiredUnless: RegleRuleWithParamsDefinition<unknown, [condition: boolean], false, boolean>;
 
+//#endregion
+//#region src/rules/sameAs.d.ts
 /**
  * Checks if the value matches the specified property or ref.
  */
-declare const sameAs: <const TTarget extends unknown>(target: MaybeRefOrGetter<TTarget>, otherName?: MaybeRefOrGetter<string>) => RegleRuleDefinition<unknown, [
-    target: TTarget,
-    otherName?: string
-], false, boolean, TTarget extends MaybeInput<infer M> ? M : MaybeInput<TTarget>>;
+declare const sameAs: <const TTarget extends unknown>(target: MaybeRefOrGetter<TTarget>, otherName?: MaybeRefOrGetter<string>) => RegleRuleDefinition<unknown, [target: TTarget, otherName?: string], false, boolean, TTarget extends MaybeInput<infer M> ? M : MaybeInput<TTarget>>;
 
+//#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>>;
+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
  *
@@ -490,6 +590,8 @@ declare const startsWith: RegleRuleWithParamsDefinition<string, [
  */
 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.
  *
@@ -497,9 +599,12 @@ declare const string: RegleRuleDefinition<unknown, [], false, boolean, MaybeInpu
  */
 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>>;
 
-export { type EnumLike, alpha, alphaNum, and, applyIf, 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 };
+//#endregion
+export { EnumLike, alpha, alphaNum, and, applyIf, 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 };