@regle/core 1.0.8 → 1.1.0-beta.1

package/dist/regle-core.cjs

@@ -1899,7 +1899,7 @@ function createReactiveNestedStatus({
           $unwatch();
           createReactiveFieldsStatus();
         },
-        { deep: true, flush: "post" }
+        { deep: true, flush: "pre" }
       );
       define$WatchExternalErrors();
     }
@@ -2656,13 +2656,52 @@ function createScopedUseRegle(options) {
   };
 }
 var { useCollectScope, useScopedRegle } = createScopedUseRegle();
+function createVariant(root, disciminantKey, variants) {
+  const watchableRoot = vue.computed(() => vue.toValue(root)[disciminantKey]);
+  const computedRules = vue.computed(() => {
+    const selectedVariant = variants.find((variant) => {
+      if (variant[disciminantKey] && "literal" in variant[disciminantKey]) {
+        const literalRule = variant[disciminantKey]["literal"];
+        if (isRuleDef(literalRule)) {
+          return vue.unref(literalRule._params?.[0]) === watchableRoot.value;
+        }
+      }
+    });
+    if (selectedVariant) {
+      return selectedVariant;
+    } else {
+      const anyDiscriminantRules = variants.find(
+        (variant) => isObject(variant[disciminantKey]) && !Object.keys(variant[disciminantKey]).some((key) => key === "literal")
+      );
+      if (anyDiscriminantRules) {
+        return anyDiscriminantRules;
+      } else {
+        return {};
+      }
+    }
+  });
+  return computedRules;
+}
+function discriminateVariant(root, discriminantKey, discriminantValue) {
+  return isObject(root[discriminantKey]) && "$value" in root[discriminantKey] && root[discriminantKey]?.$value === discriminantValue;
+}
+function inferVariantRef(root, discriminantKey, discriminantValue) {
+  let returnedRef;
+  if (discriminateVariant(root, discriminantKey, discriminantValue)) {
+    returnedRef = vue.toRef(root, discriminantKey);
+  }
+  return returnedRef;
+}
 
 exports.InternalRuleType = InternalRuleType;
 exports.createRule = createRule;
 exports.createScopedUseRegle = createScopedUseRegle;
+exports.createVariant = createVariant;
 exports.defineRegleConfig = defineRegleConfig;
+exports.discriminateVariant = discriminateVariant;
 exports.flatErrors = flatErrors;
 exports.inferRules = inferRules;
+exports.inferVariantRef = inferVariantRef;
 exports.mergeRegles = mergeRegles;
 exports.unwrapRuleParameters = unwrapRuleParameters;
 exports.useCollectScope = useCollectScope;

package/dist/regle-core.d.cts

@@ -139,6 +139,23 @@ Unfortunately, `Record<string, never>`, `Record<keyof any, never>` and `Record<n
 */
 type EmptyObject = {[emptyObjectSymbol]?: never};
 
+/**
+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
+*/
+type IsEmptyObject<T> = T extends EmptyObject ? true : false;
+
 /**
 Extract all required keys from the given type.
 
@@ -1104,13 +1121,9 @@ type RegleSingleField<TState extends Maybe<PrimitiveTypes> = any, TRules extends
      */
     r$: Raw<RegleFieldStatus<TState, TRules, TShortcuts>>;
 } & TAdditionalReturnProperties;
-type isDeepExact<T, U> = {
-    [K in keyof T]-?: CheckDeepExact<NonNullable<T[K]>, K extends keyof U ? NonNullable<U[K]> : never>;
-}[keyof T] extends true ? true : false;
-type CheckDeepExact<T, U> = [U] extends [never] ? false : T extends RegleCollectionRuleDecl ? U extends RegleCollectionRuleDecl ? isDeepExact<NonNullable<T['$each']>, UnionToIntersection$1<NonNullable<U['$each']>>> : T extends RegleRuleDecl ? true : T extends ReglePartialRuleTree<any> ? isDeepExact<T, U> : false : T extends RegleRuleDecl ? true : T extends ReglePartialRuleTree<any> ? isDeepExact<T, U> : false;
-type DeepReactiveState<T extends Record<string, any> | undefined> = {
+type DeepReactiveState<T extends Record<string, any> | unknown | undefined> = ExtendOnlyRealRecord<T> extends true ? {
     [K in keyof T]: InferDeepReactiveState<T[K]>;
-};
+} : never;
 type InferDeepReactiveState<TState> = NonNullable<TState> extends Array<infer U extends Record<string, any>> ? DeepReactiveState<U[]> : NonNullable<TState> extends Date | File ? MaybeRef<TState> : TState extends Record<string, any> | undefined ? DeepReactiveState<TState> : MaybeRef<TState>;
 type DeepSafeFormState<TState extends Record<string, any>, TRules extends ReglePartialRuleTree<TState, CustomRulesDeclarationTree> | undefined> = [unknown] extends [TState] ? {} : TRules extends undefined ? TState : TRules extends ReglePartialRuleTree<TState, CustomRulesDeclarationTree> ? Prettify<{
     [K in keyof TState as IsPropertyOutputRequired<TState[K], TRules[K]> extends false ? K : never]?: SafeProperty<TState[K], TRules[K]>;
@@ -1146,89 +1159,6 @@ type ResetOptions<TState extends unknown> = RequireOneOrNone<{
     clearExternalErrors?: boolean;
 }, 'toInitialState' | 'toState'>;
 
-interface useRegleFn<TCustomRules extends Partial<AllRulesDeclarations>, TShortcuts extends RegleShortcutDefinition<any> = never, TAdditionalReturnProperties extends Record<string, any> = {}, TAdditionalOptions extends Record<string, any> = {}> {
-    /**
-     * Primitive parameter
-     * */
-    <TState extends Maybe<PrimitiveTypes>, TRules extends RegleRuleDecl<NonNullable<TState>, TCustomRules>>(state: MaybeRef<TState>, rulesFactory: MaybeRefOrGetter<TRules>, options?: Partial<DeepMaybeRef<RegleBehaviourOptions>> & TAdditionalOptions): RegleSingleField<TState, TRules, TShortcuts, TAdditionalReturnProperties>;
-    /**
-     * Object parameter
-     * */
-    <TState extends Record<string, any>, TRules extends ReglePartialRuleTree<Unwrap<TState>, Partial<AllRulesDeclarations> & TCustomRules> & TValid, TValidationGroups extends Record<string, RegleValidationGroupEntry[]>, TValid = isDeepExact<NoInferLegacy<TRules>, ReglePartialRuleTree<Unwrap<TState>, Partial<AllRulesDeclarations> & TCustomRules>> extends true ? {} : MismatchInfo<NoInferLegacy<TRules>, ReglePartialRuleTree<Unwrap<TState>, Partial<AllRulesDeclarations> & TCustomRules>>>(state: MaybeRef<TState> | DeepReactiveState<TState>, rulesFactory: MaybeRefOrGetter<TRules>, options?: Partial<DeepMaybeRef<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<Unwrap<TState>, TRules, TValidationGroups> & TAdditionalOptions): Regle<Unwrap<TState>, TRules, TValidationGroups, TShortcuts, TAdditionalReturnProperties>;
-}
-/**
- * useRegle serves as the foundation for validation logic.
- *
- * It accepts the following inputs:
- *
- * @param state - This can be a plain object, a ref, a reactive object, or a structure containing nested refs.
- * @param rules - These should align with the structure of your state.
- * @param modifiers - Customize regle behaviour
- *
- * ```ts
- * import { useRegle } from '@regle/core';
-   import { required } from '@regle/rules';
-
-   const { r$ } = useRegle({ email: '' }, {
-     email: { required }
-   })
- * ```
- * Docs: {@link https://reglejs.dev/core-concepts/}
- */
-declare const useRegle: useRegleFn<Partial<AllRulesDeclarations>, RegleShortcutDefinition<any>, {}, {}>;
-
-interface inferRulesFn<TCustomRules extends Partial<AllRulesDeclarations>> {
-    <TState extends Record<string, any>, TRules extends ReglePartialRuleTree<Unwrap<TState>, Partial<AllRulesDeclarations> & TCustomRules> & TValid, TValid = isDeepExact<NoInferLegacy<TRules>, ReglePartialRuleTree<Unwrap<TState>, Partial<AllRulesDeclarations> & TCustomRules>> extends true ? {} : MismatchInfo<NoInferLegacy<TRules>, ReglePartialRuleTree<Unwrap<TState>, Partial<AllRulesDeclarations> & TCustomRules>>>(state: MaybeRef<TState> | DeepReactiveState<TState> | undefined, rulesFactory: TRules): NoInferLegacy<TRules>;
-    <TState extends PrimitiveTypes, TRules extends RegleRuleDecl>(state: MaybeRef<TState>, rulesFactory: TRules): NoInferLegacy<TRules>;
-}
-/**
- * Rule type helper to provide autocomplete and typecheck to your form rules or part of your form rules
- * It will just return the rules without any processing.
- *
- * @param state - The state reference
- * @param rules - Your rule tree
- */
-declare const inferRules: inferRulesFn<Partial<AllRulesDeclarations>>;
-
-declare function useRootStorage({ initialState, options, scopeRules, state, customRules, shortcuts, schemaErrors, schemaMode, onValidate, }: {
-    scopeRules: Ref<$InternalReglePartialRuleTree>;
-    state: Ref<Record<string, any> | PrimitiveTypes>;
-    options: ResolvedRegleBehaviourOptions;
-    initialState: Ref<Record<string, any> | PrimitiveTypes>;
-    customRules?: () => CustomRulesDeclarationTree;
-    shortcuts: RegleShortcutDefinition | undefined;
-    schemaErrors?: Ref<any | undefined>;
-    schemaMode?: boolean;
-    onValidate?: () => Promise<$InternalRegleResult>;
-}): {
-    regle: $InternalRegleStatusType | undefined;
-};
-
-/**
- * Converts an nested $errors object to a flat array of string errors
- *
- * Can also flatten to an array containing the path of each error with the options.includePath
- */
-declare function flatErrors(errors: $InternalRegleErrors, options: {
-    includePath: true;
-}): {
-    error: string;
-    path: string;
-}[];
-declare function flatErrors(errors: $InternalRegleErrors, options?: {
-    includePath?: false;
-}): string[];
-
-type InferRegleRoot<T extends (...args: any[]) => Regle<any, any, any, any>> = T extends (...args: any[]) => infer U ? U extends Regle<any, any, any, any> ? Prettify<U['r$']> : never : never;
-type InferRegleRules<T extends useRegleFn<any, any>> = T extends useRegleFn<infer U, any> ? UnwrapRuleTree<Partial<U> & Partial<DefaultValidators>> : {};
-type InferRegleShortcuts<T extends useRegleFn<any, any>> = T extends useRegleFn<any, infer U> ? U : {};
-type RegleEnforceRequiredRules<TRules extends keyof DefaultValidators> = {
-    [K in TRules]-?: UnwrapRuleWithParams<DefaultValidators[K]>;
-};
-type RegleEnforceCustomRequiredRules<T extends Partial<AllRulesDeclarations> | useRegleFn<any>, TRules extends T extends useRegleFn<any> ? keyof InferRegleRules<T> : keyof T> = {
-    [K in TRules]-?: T extends useRegleFn<any> ? K extends keyof InferRegleRules<T> ? UnwrapRuleWithParams<InferRegleRules<T>[K]> : never : K extends keyof T ? NonNullable<T[K]> : never;
-};
-
 /**
  * Negates a boolean type.
  */
@@ -1340,6 +1270,7 @@ type TuplifyUnion<Union, LastElement = LastOf<Union>> = IsNever<Union> extends t
  * Convert a union like `1 | 2 | 3` to a tuple like `[1, 2, 3]`.
  */
 type UnionToTuple<Union> = TuplifyUnion<Union>;
+type IsUnion<T> = Not<Extends<UnionToTuple<T>['length'], 1>>;
 
 /**
  * The simple(ish) way to get overload info from a function
@@ -1663,6 +1594,91 @@ type DeepBrand<T> = IsNever<T> extends true ? {
  */
 type StrictEqualUsingBranding<Left, Right> = MutuallyExtends<DeepBrand<Left>, DeepBrand<Right>>;
 
+type MaybeVariantStatus<TState extends Record<string, any> | undefined = Record<string, any>, TRules extends ReglePartialRuleTree<NonNullable<TState>> = Record<string, any>, TShortcuts extends RegleShortcutDefinition = {}> = IsUnion<NonNullable<TState>> extends true ? Omit<RegleStatus<TState, TRules, TShortcuts>, '$fields'> & {
+    $fields: {
+        [TIndex in keyof TupleToPlainObj<UnionToTuple$1<TState>>]: TIndex extends `${infer TIndexInt extends number}` ? {
+            [TKey in keyof UnionToTuple$1<TState>[TIndexInt] as TKey extends keyof JoinDiscriminatedUnions<TRules> ? TKey : never]-?: InferRegleStatusType<NonNullable<TKey extends keyof JoinDiscriminatedUnions<TRules> ? JoinDiscriminatedUnions<TRules>[TKey] : {}>, NonNullable<UnionToTuple$1<TState>[TIndexInt]>, TKey, TShortcuts>;
+        } & {
+            [TKey in keyof UnionToTuple$1<TState>[TIndexInt] as TKey extends keyof JoinDiscriminatedUnions<TRules> ? never : TKey]: InferRegleStatusType<{}, NonNullable<UnionToTuple$1<TState>[TIndexInt]>, TKey, TShortcuts>;
+        } : {};
+    }[keyof TupleToPlainObj<UnionToTuple$1<TState>>];
+} : RegleStatus<TState, TRules, TShortcuts>;
+
+interface useRegleFn<TCustomRules extends Partial<AllRulesDeclarations>, TShortcuts extends RegleShortcutDefinition<any> = never, TAdditionalReturnProperties extends Record<string, any> = {}, TAdditionalOptions extends Record<string, any> = {}> {
+    <TState extends Record<string, any> | MaybeInput<PrimitiveTypes>, TRules extends ReglePartialRuleTree<Unwrap<TState extends Record<string, any> ? TState : {}>, Partial<AllRulesDeclarations> & TCustomRules>, TDecl extends RegleRuleDecl<NonNullable<TState>, Partial<AllRulesDeclarations> & TCustomRules>, TValidationGroups extends Record<string, RegleValidationGroupEntry[]>>(state: Maybe<MaybeRef<TState> | DeepReactiveState<TState>>, rulesFactory: TState extends MaybeInput<PrimitiveTypes> ? MaybeRefOrGetter<TDecl> : TState extends Record<string, any> ? MaybeRefOrGetter<TRules> : {}, options?: TState extends MaybeInput<PrimitiveTypes> ? Partial<DeepMaybeRef<RegleBehaviourOptions>> & TAdditionalOptions : Partial<DeepMaybeRef<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<JoinDiscriminatedUnions<TState extends Record<string, any> ? Unwrap<TState> : {}>, TState extends Record<string, any> ? TRules : {}, TValidationGroups> & TAdditionalOptions): TState extends MaybeInput<PrimitiveTypes> ? RegleSingleField<TState, TDecl, TShortcuts, TAdditionalReturnProperties> : Regle<TState extends Record<string, any> ? Unwrap<TState> : {}, TRules, TValidationGroups, TShortcuts, TAdditionalReturnProperties>;
+}
+/**
+ * useRegle serves as the foundation for validation logic.
+ *
+ * It accepts the following inputs:
+ *
+ * @param state - This can be a plain object, a ref, a reactive object, or a structure containing nested refs.
+ * @param rules - These should align with the structure of your state.
+ * @param modifiers - Customize regle behaviour
+ *
+ * ```ts
+ * import { useRegle } from '@regle/core';
+   import { required } from '@regle/rules';
+
+   const { r$ } = useRegle({ email: '' }, {
+     email: { required }
+   })
+ * ```
+ * Docs: {@link https://reglejs.dev/core-concepts/}
+ */
+declare const useRegle: useRegleFn<Partial<AllRulesDeclarations>, RegleShortcutDefinition<any>, {}, {}>;
+
+interface inferRulesFn<TCustomRules extends Partial<AllRulesDeclarations>> {
+    <TState extends Record<string, any> | MaybeInput<PrimitiveTypes>, TRules extends TState extends MaybeInput<PrimitiveTypes> ? RegleRuleDecl<NonNullable<TState>, TCustomRules> : TState extends Record<string, any> ? ReglePartialRuleTree<Unwrap<TState>, Partial<AllRulesDeclarations> & TCustomRules> : {}>(state: MaybeRef<TState> | DeepReactiveState<TState>, rulesFactory: TRules): NoInferLegacy<TRules>;
+}
+/**
+ * Rule type helper to provide autocomplete and typecheck to your form rules or part of your form rules
+ * It will just return the rules without any processing.
+ *
+ * @param state - The state reference
+ * @param rules - Your rule tree
+ */
+declare const inferRules: inferRulesFn<Partial<AllRulesDeclarations>>;
+
+declare function useRootStorage({ initialState, options, scopeRules, state, customRules, shortcuts, schemaErrors, schemaMode, onValidate, }: {
+    scopeRules: Ref<$InternalReglePartialRuleTree>;
+    state: Ref<Record<string, any> | PrimitiveTypes>;
+    options: ResolvedRegleBehaviourOptions;
+    initialState: Ref<Record<string, any> | PrimitiveTypes>;
+    customRules?: () => CustomRulesDeclarationTree;
+    shortcuts: RegleShortcutDefinition | undefined;
+    schemaErrors?: Ref<any | undefined>;
+    schemaMode?: boolean;
+    onValidate?: () => Promise<$InternalRegleResult>;
+}): {
+    regle: $InternalRegleStatusType | undefined;
+};
+
+/**
+ * Converts an nested $errors object to a flat array of string errors
+ *
+ * Can also flatten to an array containing the path of each error with the options.includePath
+ */
+declare function flatErrors(errors: $InternalRegleErrors, options: {
+    includePath: true;
+}): {
+    error: string;
+    path: string;
+}[];
+declare function flatErrors(errors: $InternalRegleErrors, options?: {
+    includePath?: false;
+}): string[];
+
+type InferRegleRoot<T extends (...args: any[]) => Regle<any, any, any, any>> = T extends (...args: any[]) => infer U ? U extends Regle<any, any, any, any> ? Prettify<U['r$']> : never : never;
+type InferRegleRules<T extends useRegleFn<any, any>> = T extends useRegleFn<infer U, any> ? UnwrapRuleTree<Partial<U> & Partial<DefaultValidators>> : {};
+type InferRegleShortcuts<T extends useRegleFn<any, any>> = T extends useRegleFn<any, infer U> ? U : {};
+type RegleEnforceRequiredRules<TRules extends keyof DefaultValidators> = {
+    [K in TRules]-?: UnwrapRuleWithParams<DefaultValidators[K]>;
+};
+type RegleEnforceCustomRequiredRules<T extends Partial<AllRulesDeclarations> | useRegleFn<any>, TRules extends T extends useRegleFn<any> ? keyof InferRegleRules<T> : keyof T> = {
+    [K in TRules]-?: T extends useRegleFn<any> ? K extends keyof InferRegleRules<T> ? UnwrapRuleWithParams<InferRegleRules<T>[K]> : never : K extends keyof T ? NonNullable<T[K]> : never;
+};
+
 /**
  * Borrowed from vitest
  */
@@ -1675,13 +1691,46 @@ type MismatchInfo<Actual, Expected> = And<[Extends<PrintType<Actual>, '...'>, No
 } : StrictEqualUsingBranding<Actual, Expected> extends true ? Actual : `[Regle error] The parent property does not match the form schema`;
 
 type RemoveCommonKey<T extends readonly any[], K extends PropertyKey> = T extends [infer F, ...infer R] ? [Prettify<Omit<F, K>>, ...RemoveCommonKey<R, K>] : [];
-type JoinDiscriminatedUnions<TUnion extends unknown> = isRecordLiteral<TUnion> extends true ? Prettify<Partial<UnionToIntersection$1<RemoveCommonKey<UnionToTuple$1<TUnion>, keyof NonNullable<TUnion>>[number]>> & Pick<NonNullable<TUnion>, keyof NonNullable<TUnion>>> : TUnion;
+/**
+ * Get item value from object, otherwise fallback to undefined. Avoid TS to not be able to infer keys not present on all unions
+ */
+type GetMaybeObjectValue<O extends Record<string, any>, K extends string> = K extends keyof O ? O[K] : undefined;
+/**
+ * Combine all unions values to be able to get even the normally "never" values, act as an intersection type
+ */
+type RetrieveUnionUnknownValues<T extends readonly any[], TKeys extends string> = T extends [
+    infer F extends Record<string, any>,
+    ...infer R
+] ? [
+    {
+        [K in TKeys as GetMaybeObjectValue<F, K> extends NonNullable<GetMaybeObjectValue<F, K>> ? never : K]?: GetMaybeObjectValue<F, K>;
+    } & {
+        [K in TKeys as GetMaybeObjectValue<F, K> extends NonNullable<GetMaybeObjectValue<F, K>> ? K : never]: GetMaybeObjectValue<F, K>;
+    },
+    ...RetrieveUnionUnknownValues<R, TKeys>
+] : [];
+/**
+ * Get all possible keys from an union, even the ones present only on one union
+ */
+type RetrieveUnionUnknownKeysOf<T extends readonly any[]> = T extends [infer F, ...infer R] ? [keyof F, ...RetrieveUnionUnknownKeysOf<R>] : [];
+/**
+ * Transforms an union and apply undefined values to non-present keys to support intersection
+ */
+type NormalizeUnion<TUnion> = RetrieveUnionUnknownValues<NonNullable<UnionToTuple$1<TUnion>>, RetrieveUnionUnknownKeysOf<NonNullable<UnionToTuple$1<TUnion>>>[number]>[number];
+/**
+ * Combine all members of an union type, merging types for each keys, and keeping loose types
+ */
+type JoinDiscriminatedUnions<TUnion extends unknown> = isRecordLiteral<TUnion> extends true ? Prettify<Partial<UnionToIntersection$1<RemoveCommonKey<UnionToTuple$1<TUnion>, keyof NormalizeUnion<TUnion>>[number]>> & Pick<NormalizeUnion<TUnion>, keyof NormalizeUnion<TUnion>>> : TUnion;
+type LazyJoinDiscriminatedUnions<TUnion extends unknown> = isRecordLiteral<TUnion> extends true ? Prettify<Partial<UnionToIntersection$1<RemoveCommonKey<UnionToTuple$1<TUnion>, keyof NonNullable<TUnion>>[number]>> & Pick<NonNullable<TUnion>, keyof NonNullable<TUnion>>> : TUnion;
 type EnumLike = {
     [k: string]: string | number;
     [nu: number]: string;
 };
 type enumType<T extends Record<string, unknown>> = T[keyof T];
 type UnwrapMaybeRef<T extends MaybeRef<any> | DeepReactiveState<any>> = T extends Ref<any> ? UnwrapRef<T> : UnwrapNestedRefs<T>;
+type TupleToPlainObj<T> = {
+    [I in keyof T & `${number}`]: T[I];
+};
 
 type CreateFn<T extends any[]> = (...args: T) => any;
 /**
@@ -1856,8 +1905,10 @@ type DefaultValidators = {
     exactLength: RegleRuleWithParamsDefinition<string | any[] | Record<PropertyKey, any>, [
         count: number
     ], false, boolean>;
+    exactValue: RegleRuleWithParamsDefinition<number, [count: number], false, boolean>;
     integer: RegleRuleDefinition<string | number, [], false, boolean, string | number>;
     ipAddress: RegleRuleDefinition<string, [], false, boolean, string>;
+    literal: RegleRuleDefinition<string | number, [literal: string | number], false, boolean, string | number>;
     macAddress: RegleRuleWithParamsDefinition<string, [separator?: string | undefined], false, boolean>;
     maxLength: RegleRuleWithParamsDefinition<string | any[] | Record<PropertyKey, any>, [
         count: number,
@@ -1876,7 +1927,6 @@ type DefaultValidators = {
     required: RegleRuleDefinition<unknown, []>;
     sameAs: RegleRuleWithParamsDefinition<unknown, [target: unknown, otherName?: string], false, boolean>;
     startsWith: RegleRuleWithParamsDefinition<string, [part: Maybe<string>], false, boolean>;
-    exactValue: RegleRuleWithParamsDefinition<number, [count: number], false, boolean>;
     url: RegleRuleDefinition<string, [], false, boolean, string>;
 };
 
@@ -1903,7 +1953,7 @@ type RegleRuleTree<TForm extends Record<string, any>, TCustomRules extends Parti
  * @public
  */
 type RegleComputedRules<TForm extends MaybeRef<Record<string, any>> | DeepReactiveState<Record<string, any>>, TCustomRules extends Partial<AllRulesDeclarations> | Regle<any, any> = Partial<AllRulesDeclarations>, TState = Unwrap<TForm>, TCustom = TCustomRules extends Regle<any, infer R> ? R extends ReglePartialRuleTree<any, infer C> ? C : Partial<AllRulesDeclarations> : TCustomRules> = {
-    [TKey in keyof TState]?: RegleFormPropertyType<TState[TKey], TCustom extends Partial<AllRulesDeclarations> ? TCustom : {}>;
+    [TKey in keyof JoinDiscriminatedUnions<TState>]?: RegleFormPropertyType<JoinDiscriminatedUnions<TState>[TKey], TCustom extends Partial<AllRulesDeclarations> ? TCustom : {}>;
 };
 /**
  * @internal
@@ -1926,7 +1976,7 @@ type $InternalFormPropertyTypes = $InternalRegleRuleDecl | $InternalRegleCollect
  * Rule tree for a form property
  */
 type RegleRuleDecl<TValue extends any = any, TCustomRules extends Partial<AllRulesDeclarations> = Partial<AllRulesDeclarations>> = FieldRegleBehaviourOptions & {
-    [TKey in keyof TCustomRules]?: NonNullable<TCustomRules[TKey]> extends RegleRuleWithParamsDefinition<any, infer TParams> ? RegleRuleDefinition<TValue, [...TParams, ...args: [...any[]]], boolean> : NonNullable<TCustomRules[TKey]> extends RegleRuleDefinition<any, any, any, any> ? FormRuleDeclaration<TValue, any> : FormRuleDeclaration<TValue, any> | FieldRegleBehaviourOptions[keyof FieldRegleBehaviourOptions];
+    [TKey in keyof TCustomRules]?: NonNullable<TCustomRules[TKey]> extends RegleRuleWithParamsDefinition<any, infer TParams> ? RegleRuleDefinition<TValue, [...TParams, ...args: [...any[]]], boolean> : NonNullable<TCustomRules[TKey]> extends RegleRuleDefinition<any, any[], any, any> ? FormRuleDeclaration<TValue, any[]> : FormRuleDeclaration<TValue, any[]> | FieldRegleBehaviourOptions[keyof FieldRegleBehaviourOptions];
 };
 /**
  * @internal
@@ -2011,7 +2061,7 @@ type $InternalRegleResult = {
 /**
  * @public
  */
-type RegleRoot<TState extends Record<string, any> = Record<string, any>, TRules extends ReglePartialRuleTree<TState> = Record<string, any>, TValidationGroups extends Record<string, RegleValidationGroupEntry[]> = never, TShortcuts extends RegleShortcutDefinition = {}> = RegleStatus<TState, TRules, TShortcuts> & ([TValidationGroups] extends [never] ? {} : {
+type RegleRoot<TState extends Record<string, any> = Record<string, any>, TRules extends ReglePartialRuleTree<TState> = Record<string, any>, TValidationGroups extends Record<string, RegleValidationGroupEntry[]> = never, TShortcuts extends RegleShortcutDefinition = {}> = MaybeVariantStatus<TState, TRules, TShortcuts> & ([TValidationGroups] extends [never] ? {} : {
     /**
      * Collection of validation groups used declared with the `validationGroups` modifier
      */
@@ -2071,9 +2121,9 @@ type SuperCompatibleRegleCollectionErrors = $InternalRegleCollectionErrors;
 type RegleStatus<TState extends Record<string, any> | undefined = Record<string, any>, TRules extends ReglePartialRuleTree<NonNullable<TState>> = Record<string, any>, TShortcuts extends RegleShortcutDefinition = {}> = RegleCommonStatus<TState> & {
     /** Represents all the children of your object. You can access any nested child at any depth to get the relevant data you need for your form. */
     readonly $fields: {
-        readonly [TKey in keyof TState]: InferRegleStatusType<NonNullable<TRules[TKey]>, NonNullable<TState>, TKey, TShortcuts>;
+        readonly [TKey in keyof TState as IsEmptyObject<TRules[TKey]> extends true ? never : TKey]: InferRegleStatusType<NonNullable<TRules[TKey]>, NonNullable<TState>, TKey, TShortcuts>;
     } & {
-        readonly [TKey in keyof TState as TRules[TKey] extends NonNullable<TRules[TKey]> ? NonNullable<TRules[TKey]> extends RegleRuleDecl ? TKey : never : never]-?: InferRegleStatusType<NonNullable<TRules[TKey]>, NonNullable<TState>, TKey, TShortcuts>;
+        readonly [TKey in keyof TState as TRules[TKey] extends NonNullable<TRules[TKey]> ? NonNullable<TRules[TKey]> extends RegleRuleDecl ? IsEmptyObject<TRules[TKey]> extends true ? TKey : never : never : never]-?: InferRegleStatusType<NonNullable<TRules[TKey]>, NonNullable<TState>, TKey, TShortcuts>;
     };
     /**
      * Collection of all the error messages, collected for all children properties and nested forms.
@@ -2105,7 +2155,7 @@ interface $InternalRegleStatus extends $InternalRegleCommonStatus {
 /**
  * @public
  */
-type InferRegleStatusType<TRule extends RegleCollectionRuleDecl | RegleRuleDecl | ReglePartialRuleTree<any>, TState extends Record<PropertyKey, any> = any, TKey extends PropertyKey = string, TShortcuts extends RegleShortcutDefinition = {}> = NonNullable<TState[TKey]> extends Array<infer U extends Record<string, any>> ? ExtendOnlyRealRecord<U> extends true ? TRule extends RegleCollectionRuleDefinition<any, any> ? ExtractFromGetter<TRule['$each']> extends ReglePartialRuleTree<any> ? RegleCollectionStatus<TState[TKey], ExtractFromGetter<TRule['$each']>, TRule, TShortcuts> : RegleFieldStatus<TState[TKey], TRule, TShortcuts> : RegleCollectionStatus<TState[TKey], {}, TRule, TShortcuts> : RegleFieldStatus<TState[TKey], TRule, TShortcuts> : TRule extends ReglePartialRuleTree<any> ? NonNullable<TState[TKey]> extends Array<any> ? RegleFieldStatus<TState[TKey], TRule, TShortcuts> : NonNullable<TState[TKey]> extends Date | File ? RegleFieldStatus<TState[TKey], TRule, TShortcuts> : NonNullable<TState[TKey]> extends Record<PropertyKey, any> ? RegleStatus<TState[TKey], TRule, TShortcuts> : RegleFieldStatus<TState[TKey], TRule, TShortcuts> : NonNullable<TState[TKey]> extends Date | File ? RegleFieldStatus<TState[TKey], TRule, TShortcuts> : NonNullable<TState[TKey]> extends Record<PropertyKey, any> ? RegleStatus<TState[TKey], ReglePartialRuleTree<TState[TKey]>, TShortcuts> : RegleFieldStatus<TState[TKey], TRule, TShortcuts>;
+type InferRegleStatusType<TRule extends RegleCollectionRuleDecl | RegleRuleDecl | ReglePartialRuleTree<any>, TState extends Record<PropertyKey, any> = any, TKey extends PropertyKey = string, TShortcuts extends RegleShortcutDefinition = {}> = NonNullable<TState[TKey]> extends Array<infer U extends Record<string, any>> ? ExtendOnlyRealRecord<U> extends true ? TRule extends RegleCollectionRuleDefinition<any, any> ? ExtractFromGetter<TRule['$each']> extends ReglePartialRuleTree<any> ? RegleCollectionStatus<TState[TKey], ExtractFromGetter<TRule['$each']>, TRule, TShortcuts> : RegleFieldStatus<TState[TKey], TRule, TShortcuts> : RegleCollectionStatus<TState[TKey], {}, TRule, TShortcuts> : RegleFieldStatus<TState[TKey], TRule, TShortcuts> : TRule extends ReglePartialRuleTree<any> ? NonNullable<TState[TKey]> extends Array<any> ? RegleFieldStatus<TState[TKey], TRule, TShortcuts> : NonNullable<TState[TKey]> extends Date | File ? RegleFieldStatus<TState[TKey], TRule, TShortcuts> : NonNullable<TState[TKey]> extends Record<PropertyKey, any> ? MaybeVariantStatus<TState[TKey], TRule, TShortcuts> : RegleFieldStatus<TState[TKey], TRule, TShortcuts> : NonNullable<TState[TKey]> extends Date | File ? RegleFieldStatus<TState[TKey], TRule, TShortcuts> : NonNullable<TState[TKey]> extends Record<PropertyKey, any> ? MaybeVariantStatus<TState[TKey], ReglePartialRuleTree<TState[TKey]>, TShortcuts> : RegleFieldStatus<TState[TKey], TRule, TShortcuts>;
 /**
  * @internal
  * @reference {@link InferRegleStatusType}
@@ -2116,9 +2166,9 @@ type $InternalRegleStatusType = $InternalRegleCollectionStatus | $InternalRegleS
  */
 type RegleFieldStatus<TState extends any = any, TRules extends RegleFormPropertyType<any, Partial<AllRulesDeclarations>> = Record<string, any>, TShortcuts extends RegleShortcutDefinition = never> = Omit<RegleCommonStatus<TState>, '$value'> & {
     /** A reference to the original validated model. It can be used to bind your form with v-model.*/
-    $value: Maybe<UnwrapNestedRefs<TState>>;
+    $value: MaybeOutput<UnwrapNestedRefs<TState>>;
     /** $value variant that will not "touch" the field and update the value silently, running only the rules, so you can easily swap values without impacting user interaction. */
-    $silentValue: Maybe<UnwrapNestedRefs<TState>>;
+    $silentValue: MaybeOutput<UnwrapNestedRefs<TState>>;
     /** Collection of all the error messages, collected for all children properties and nested forms.
      *
      * Only contains errors from properties where $dirty equals true. */
@@ -2132,7 +2182,7 @@ type RegleFieldStatus<TState extends any = any, TRules extends RegleFormProperty
     /** Represents the inactive status. Is true when this state have empty rules */
     readonly $inactive: boolean;
     /** Will return a copy of your state with only the fields that are dirty. By default it will filter out nullish values or objects, but you can override it with the first parameter $extractDirtyFields(false). */
-    $extractDirtyFields: (filterNullishValues?: boolean) => Maybe<TState>;
+    $extractDirtyFields: (filterNullishValues?: boolean) => MaybeOutput<TState>;
     /** Sets all properties as dirty, triggering all rules. It returns a promise that will either resolve to false or a type safe copy of your form state. Values that had the required rule will be transformed into a non-nullable value (type only). */
     $validate: () => Promise<RegleResult<TState, TRules>>;
     /** This is reactive tree containing all the declared rules of your field. To know more about the rule properties check the rules properties section */
@@ -2233,7 +2283,7 @@ type RegleRuleStatus<TValue = any, TParams extends any[] = any[], TMetadata exte
     /** Reset the $valid, $metadata and $pending states */
     $reset(): void;
     /** Returns the original rule validator function. */
-    $validator: ((value: Maybe<TValue>, ...args: any[]) => RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>) & ((value: TValue, ...args: [TParams] extends [never[]] ? [] : [unknown[]] extends [TParams] ? any[] : TParams) => RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>);
+    $validator: ((value: MaybeInput<TValue>, ...args: any[]) => RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>) & ((value: TValue, ...args: [TParams] extends [never[]] ? [] : [unknown[]] extends [TParams] ? any[] : TParams) => RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>);
 } & ([TParams] extends [never[]] ? {} : [unknown[]] extends [TParams] ? {
     readonly $params?: any[];
 } : {
@@ -2272,9 +2322,9 @@ interface $InternalRegleRuleStatus {
  */
 type RegleCollectionStatus<TState extends any[] = any[], TRules extends ReglePartialRuleTree<ArrayElement<TState>> = Record<string, any>, TFieldRule extends RegleCollectionRuleDecl<any, any> = never, TShortcuts extends RegleShortcutDefinition = {}> = Omit<RegleCommonStatus<TState>, '$value'> & {
     /** A reference to the original validated model. It can be used to bind your form with v-model.*/
-    $value: Maybe<TState>;
+    $value: MaybeOutput<TState>;
     /** $value variant that will not "touch" the field and update the value silently, running only the rules, so you can easily swap values without impacting user interaction. */
-    $silentValue: Maybe<TState>;
+    $silentValue: MaybeOutput<TState>;
     /** Collection of status of every item in your collection. Each item will be a field you can access, or map on it to display your elements. */
     readonly $each: Array<InferRegleStatusType<NonNullable<TRules>, NonNullable<TState>, number, TShortcuts>>;
     /** Represents the status of the collection itself. You can have validation rules on the array like minLength, this field represents the isolated status of the collection. */
@@ -2451,4 +2501,36 @@ declare const useScopedRegle: useRegleFn<Partial<AllRulesDeclarations>, never, {
     namespace?: MaybeRefOrGetter<string>;
 }>;
 
-export { type $InternalRegleStatus, type AllRulesDeclarations, type CommonComparationOptions, type DeepMaybeRef, type DeepReactiveState, type FormRuleDeclaration, type InferRegleRoot, type InferRegleRule, type InferRegleRules, type InferRegleShortcuts, type InferRegleStatusType, type InlineRuleDeclaration, InternalRuleType, type JoinDiscriminatedUnions, type LocalRegleBehaviourOptions, type Maybe, type MaybeInput, type MaybeOutput, type MergedRegles, type MismatchInfo, type NoInferLegacy, type PrimitiveTypes, type Regle, type RegleBehaviourOptions, type RegleCollectionErrors, type RegleCollectionRuleDecl, type RegleCollectionRuleDefinition, type RegleCollectionStatus, type RegleCommonStatus, type RegleComputedRules, type RegleEnforceCustomRequiredRules, type RegleEnforceRequiredRules, type RegleErrorTree, type RegleExternalCollectionErrors, type RegleExternalErrorTree, type RegleFieldStatus, type RegleFormPropertyType, type RegleInternalRuleDefs, type ReglePartialRuleTree, type RegleResult, type RegleRoot, type RegleRuleCore, type RegleRuleDecl, type RegleRuleDefinition, type RegleRuleDefinitionProcessor, type RegleRuleDefinitionWithMetadataProcessor, type RegleRuleInit, type RegleRuleMetadataConsumer, type RegleRuleMetadataDefinition, type RegleRuleMetadataExtended, type RegleRuleRaw, type RegleRuleStatus, type RegleRuleTypeReturn, type RegleRuleWithParamsDefinition, type RegleShortcutDefinition, type RegleSingleField, type RegleStatus, type RegleUniversalParams, type RegleValidationErrors, type RegleValidationGroupEntry, type RegleValidationGroupOutput, type RegleRuleTree as RegleValidationTree, type ResolvedRegleBehaviourOptions, type ScopedInstancesRecord, type ScopedInstancesRecordLike, type SuperCompatibleRegleCollectionErrors, type SuperCompatibleRegleCollectionStatus, type SuperCompatibleRegleFieldStatus, type SuperCompatibleRegleResult, type SuperCompatibleRegleRoot, type SuperCompatibleRegleRuleStatus, type SuperCompatibleRegleStatus, type Unwrap, type UnwrapRegleUniversalParams, type UnwrapRuleWithParams, createRule, createScopedUseRegle, defineRegleConfig, flatErrors, inferRules, mergeRegles, unwrapRuleParameters, useCollectScope, useRegle, useRootStorage, useScopedRegle };
+type PossibleLiteralTypes<T extends Record<string, any>, TKey extends keyof T> = {
+    [TVal in NonNullable<T[TKey]>]: {
+        [K in TKey]-?: Omit<RegleRuleDecl<TVal, Partial<AllRulesDeclarations>>, 'literal'> & {
+            literal?: RegleRuleDefinition<TVal, [literal: TVal], false, boolean, string | number>;
+        };
+    };
+};
+type RequiredForm<T extends Record<string, any>, TKey extends keyof T> = Omit<ReglePartialRuleTree<T>, TKey> & PossibleLiteralTypes<T, TKey>[keyof PossibleLiteralTypes<T, TKey>];
+type Variant1<T extends Record<string, any>, TKey extends keyof T> = [
+    RequiredForm<T, TKey>,
+    ...RequiredForm<T, TKey>[]
+];
+/**
+ *
+ * Autocomplete may not work here because of https://github.com/microsoft/TypeScript/issues/49547
+ */
+declare function createVariant<const TForm extends Record<string, any>, const TDiscriminant extends keyof JoinDiscriminatedUnions<TForm>, const TVariants extends Variant1<JoinDiscriminatedUnions<TForm>, TDiscriminant>>(root: MaybeRefOrGetter<TForm> | DeepReactiveState<TForm>, disciminantKey: TDiscriminant, variants: [...TVariants]): Ref<TVariants[number]>;
+declare function discriminateVariant<TRoot extends {
+    [x: string]: unknown;
+}, TKey extends keyof TRoot, const TValue extends LazyJoinDiscriminatedUnions<Exclude<TRoot[TKey], RegleCollectionStatus<any, any, any> | RegleStatus<any, any, any>>> extends {
+    $value: infer V;
+} ? V : unknown>(root: TRoot, discriminantKey: TKey, discriminantValue: TValue): root is Extract<TRoot, {
+    [K in TKey]: RegleFieldStatus<TValue, any, any>;
+}>;
+declare function inferVariantRef<TRoot extends {
+    [x: string]: unknown;
+}, TKey extends keyof TRoot, const TValue extends LazyJoinDiscriminatedUnions<Exclude<TRoot[TKey], RegleCollectionStatus<any, any, any> | RegleStatus<any, any, any>>> extends {
+    $value: infer V;
+} ? V : unknown>(root: TRoot, discriminantKey: TKey, discriminantValue: TValue): Ref<Extract<TRoot, {
+    [K in TKey]: RegleFieldStatus<TValue, any, any>;
+}>> | undefined;
+
+export { type $InternalRegleStatus, type AllRulesDeclarations, type CommonComparationOptions, type DeepMaybeRef, type DeepReactiveState, type FormRuleDeclaration, type InferRegleRoot, type InferRegleRule, type InferRegleRules, type InferRegleShortcuts, type InferRegleStatusType, type InlineRuleDeclaration, InternalRuleType, type JoinDiscriminatedUnions, type LocalRegleBehaviourOptions, type Maybe, type MaybeInput, type MaybeOutput, type MaybeVariantStatus, type MergedRegles, type MismatchInfo, type NoInferLegacy, type PrimitiveTypes, type Regle, type RegleBehaviourOptions, type RegleCollectionErrors, type RegleCollectionRuleDecl, type RegleCollectionRuleDefinition, type RegleCollectionStatus, type RegleCommonStatus, type RegleComputedRules, type RegleEnforceCustomRequiredRules, type RegleEnforceRequiredRules, type RegleErrorTree, type RegleExternalCollectionErrors, type RegleExternalErrorTree, type RegleFieldStatus, type RegleFormPropertyType, type RegleInternalRuleDefs, type ReglePartialRuleTree, type RegleResult, type RegleRoot, type RegleRuleCore, type RegleRuleDecl, type RegleRuleDefinition, type RegleRuleDefinitionProcessor, type RegleRuleDefinitionWithMetadataProcessor, type RegleRuleInit, type RegleRuleMetadataConsumer, type RegleRuleMetadataDefinition, type RegleRuleMetadataExtended, type RegleRuleRaw, type RegleRuleStatus, type RegleRuleTypeReturn, type RegleRuleWithParamsDefinition, type RegleShortcutDefinition, type RegleSingleField, type RegleStatus, type RegleUniversalParams, type RegleValidationErrors, type RegleValidationGroupEntry, type RegleValidationGroupOutput, type RegleRuleTree as RegleValidationTree, type ResolvedRegleBehaviourOptions, type ScopedInstancesRecord, type ScopedInstancesRecordLike, type SuperCompatibleRegleCollectionErrors, type SuperCompatibleRegleCollectionStatus, type SuperCompatibleRegleFieldStatus, type SuperCompatibleRegleResult, type SuperCompatibleRegleRoot, type SuperCompatibleRegleRuleStatus, type SuperCompatibleRegleStatus, type Unwrap, type UnwrapRegleUniversalParams, type UnwrapRuleWithParams, createRule, createScopedUseRegle, createVariant, defineRegleConfig, discriminateVariant, flatErrors, inferRules, inferVariantRef, mergeRegles, unwrapRuleParameters, useCollectScope, useRegle, useRootStorage, useScopedRegle };