@regle/core 1.8.4 → 1.8.6

package/dist/regle-core.d.ts

@@ -23,8 +23,9 @@ type NoInferLegacy<A extends any> = [A][A extends any ? 0 : never];
 //#endregion
 //#region src/types/utils/Array.types.d.ts
 type ArrayElement<T> = T extends Array<infer U> ? U : never;
+type NonEmptyTuple<T> = [T, ...T[]] | T[];
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/primitive.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.0.0/node_modules/type-fest/source/primitive.d.ts
 /**
 Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
 
@@ -32,27 +33,7 @@ Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/
 */
 type Primitive = null | undefined | string | number | boolean | symbol | bigint;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/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;
-  }
-}
-
-/**
-@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
-*/
-
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/union-to-intersection.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.0.0/node_modules/type-fest/source/union-to-intersection.d.ts
 /**
 Convert a union type to an intersection type using [distributive conditional types](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
 
@@ -114,7 +95,7 @@ Union extends unknown
 // The `& Union` is to allow indexing by the resulting type
 ? Intersection & Union : never;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/empty-object.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.0.0/node_modules/type-fest/source/empty-object.d.ts
 declare const emptyObjectSymbol: unique symbol;
 
 /**
@@ -146,7 +127,6 @@ 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.
 
@@ -164,7 +144,81 @@ type Fail = IsEmptyObject<null>; //=> false
 */
 type IsEmptyObject<T> = T extends EmptyObject ? true : false;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/optional-keys-of.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.0.0/node_modules/type-fest/source/is-any.d.ts
+/**
+Returns a boolean for whether the given type is `any`.
+
+@link https://stackoverflow.com/a/49928360/1490091
+
+Useful in type utilities, such as disallowing `any`s to be passed to a function.
+
+@example
+```
+import type {IsAny} from 'type-fest';
+
+const typedObject = {a: 1, b: 2} as const;
+const anyObject: any = {a: 1, b: 2};
+
+function get<O extends (IsAny<O> extends true ? {} : Record<string, number>), K extends keyof O = keyof O>(obj: O, key: K) {
+	return obj[key];
+}
+
+const typedA = get(typedObject, 'a');
+//=> 1
+
+const anyA = get(anyObject, 'a');
+//=> any
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.0.0/node_modules/type-fest/source/is-optional-key-of.d.ts
+/**
+Returns a boolean for whether the given key is an optional key of type.
+
+This is useful when writing utility types or schema validators that need to differentiate `optional` keys.
+
+@example
+```
+import type {IsOptionalKeyOf} from 'type-fest';
+
+interface User {
+	name: string;
+	surname: string;
+
+	luckyNumber?: number;
+}
+
+interface Admin {
+	name: string;
+	surname?: string;
+}
+
+type T1 = IsOptionalKeyOf<User, 'luckyNumber'>;
+//=> true
+
+type T2 = IsOptionalKeyOf<User, 'name'>;
+//=> false
+
+type T3 = IsOptionalKeyOf<User, 'name' | 'luckyNumber'>;
+//=> boolean
+
+type T4 = IsOptionalKeyOf<User | Admin, 'name'>;
+//=> false
+
+type T5 = IsOptionalKeyOf<User | Admin, 'surname'>;
+//=> boolean
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsOptionalKeyOf<Type extends object, Key extends keyof Type> = IsAny<Type | Key> extends true ? never : Key extends keyof Type ? Type extends Record<Key, Type[Key]> ? false : true : false;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.0.0/node_modules/type-fest/source/optional-keys-of.d.ts
 /**
 Extract all optional keys from the given type.
 
@@ -198,11 +252,11 @@ const update2: UpdateOperation<User> = {
 
 @category Utilities
 */
-type OptionalKeysOf<BaseType extends object> = BaseType extends unknown // For distributing `BaseType`
-? (keyof { [Key in keyof BaseType as BaseType extends Record<Key, BaseType[Key]> ? never : Key]: never }) & (keyof BaseType) // Intersect with `keyof BaseType` to ensure result of `OptionalKeysOf<BaseType>` is always assignable to `keyof BaseType`
-: never; // Should never happen
+type OptionalKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
+? (keyof { [Key in keyof Type as IsOptionalKeyOf<Type, Key> extends false ? never : Key]: never }) & keyof Type // Intersect with `keyof Type` to ensure result of `OptionalKeysOf<Type>` is always assignable to `keyof Type`
+: never;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/required-keys-of.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.0.0/node_modules/type-fest/source/required-keys-of.d.ts
 /**
 Extract all required keys from the given type.
 
@@ -227,11 +281,10 @@ const validator2 = createValidation<User>('surname', value => value.length < 25)
 
 @category Utilities
 */
-type RequiredKeysOf<BaseType extends object> = BaseType extends unknown // For distributing `BaseType`
-? Exclude<keyof BaseType, OptionalKeysOf<BaseType>> : never; // Should never happen
-
+type RequiredKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
+? Exclude<keyof Type, OptionalKeysOf<Type>> : never;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/is-never.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.0.0/node_modules/type-fest/source/is-never.d.ts
 /**
 Returns a boolean for whether the given type is `never`.
 
@@ -275,124 +328,174 @@ endIfEqual('abc', '123');
 */
 type IsNever$1<T> = [T] extends [never] ? true : false;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/if-never.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.0.0/node_modules/type-fest/source/if.d.ts
 /**
-An if-else-like type that resolves depending on whether the given type is `never`.
+An if-else-like type that resolves depending on whether the given `boolean` type is `true` or `false`.
+
+Use-cases:
+- You can use this in combination with `Is*` types to create an if-else-like experience. For example, `If<IsAny<any>, 'is any', 'not any'>`.
 
-@see {@link IsNever}
+Note:
+- Returns a union of if branch and else branch if the given type is `boolean` or `any`. For example, `If<boolean, 'Y', 'N'>` will return `'Y' | 'N'`.
+- Returns the else branch if the given type is `never`. For example, `If<never, 'Y', 'N'>` will return `'N'`.
 
 @example
 ```
-import type {IfNever} from 'type-fest';
+import {If} from 'type-fest';
 
-type ShouldBeTrue = IfNever<never>;
-//=> true
+type A = If<true, 'yes', 'no'>;
+//=> 'yes'
 
-type ShouldBeBar = IfNever<'not never', 'foo', 'bar'>;
-//=> 'bar'
-```
+type B = If<false, 'yes', 'no'>;
+//=> 'no'
 
-@category Type Guard
-@category Utilities
-*/
-type IfNever$1<T, TypeIfNever = true, TypeIfNotNever = false> = (IsNever$1<T> extends true ? TypeIfNever : TypeIfNotNever);
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/is-any.d.ts
-// Can eventually be replaced with the built-in once this library supports
-// TS5.4+ only. Tracked in https://github.com/sindresorhus/type-fest/issues/848
-type NoInfer<T> = T extends infer U ? U : never;
+type C = If<boolean, 'yes', 'no'>;
+//=> 'yes' | 'no'
 
-/**
-Returns a boolean for whether the given type is `any`.
+type D = If<any, 'yes', 'no'>;
+//=> 'yes' | 'no'
 
-@link https://stackoverflow.com/a/49928360/1490091
-
-Useful in type utilities, such as disallowing `any`s to be passed to a function.
+type E = If<never, 'yes', 'no'>;
+//=> 'no'
+```
 
 @example
 ```
-import type {IsAny} from 'type-fest';
+import {If, IsAny, IsNever} from 'type-fest';
 
-const typedObject = {a: 1, b: 2} as const;
-const anyObject: any = {a: 1, b: 2};
+type A = If<IsAny<unknown>, 'is any', 'not any'>;
+//=> 'not any'
 
-function get<O extends (IsAny<O> extends true ? {} : Record<string, number>), K extends keyof O = keyof O>(obj: O, key: K) {
-	return obj[key];
-}
+type B = If<IsNever<never>, 'is never', 'not never'>;
+//=> 'is never'
+```
 
-const typedA = get(typedObject, 'a');
-//=> 1
+@example
+```
+import {If, IsEqual} from 'type-fest';
 
-const anyA = get(anyObject, 'a');
-//=> any
+type IfEqual<T, U, IfBranch, ElseBranch> = If<IsEqual<T, U>, IfBranch, ElseBranch>;
+
+type A = IfEqual<string, string, 'equal', 'not equal'>;
+//=> 'equal'
+
+type B = IfEqual<string, number, 'equal', 'not equal'>;
+//=> 'not equal'
 ```
 
 @category Type Guard
 @category Utilities
 */
-type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
+type If<Type extends boolean, IfBranch, ElseBranch> = IsNever$1<Type> extends true ? ElseBranch : Type extends true ? IfBranch : ElseBranch;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/is-equal.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.0.0/node_modules/type-fest/source/internal/type.d.ts
 /**
-Returns a boolean for whether the two given types are equal.
+Matches any primitive, `void`, `Date`, or `RegExp` value.
+*/
+type BuiltIns = Primitive | void | Date | RegExp;
+/**
+Test if the given function has multiple call signatures.
 
-@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
-@link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
+Needed to handle the case of a single call signature with properties.
 
-Use-cases:
-- If you want to make a conditional branch based on the result of a comparison of two types.
+Multiple call signatures cannot currently be supported due to a TypeScript limitation.
+@see https://github.com/microsoft/TypeScript/issues/29732
+*/
+type HasMultipleCallSignatures<T extends (...arguments_: any[]) => unknown> = T extends {
+  (...arguments_: infer A): unknown;
+  (...arguments_: infer B): unknown;
+} ? B extends A ? A extends B ? false : true : true : false;
+/**
+An if-else-like type that resolves depending on whether the given type is `any` or `never`.
 
 @example
 ```
-import type {IsEqual} from 'type-fest';
+// When `T` is a NOT `any` or `never` (like `string`) => Returns `IfNotAnyOrNever` branch
+type A = IfNotAnyOrNever<string, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+//=> 'VALID'
 
-// This type returns a boolean for whether the given array includes the given item.
-// `IsEqual` is used to compare the given array at position 0 and the given item and then return true if they are equal.
-type Includes<Value extends readonly any[], Item> =
-	Value extends readonly [Value[0], ...infer rest]
-		? IsEqual<Value[0], Item> extends true
-			? true
-			: Includes<rest, Item>
-		: false;
-```
+// When `T` is `any` => Returns `IfAny` branch
+type B = IfNotAnyOrNever<any, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+//=> 'IS_ANY'
 
-@category Type Guard
-@category Utilities
+// When `T` is `never` => Returns `IfNever` branch
+type C = IfNotAnyOrNever<never, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+//=> 'IS_NEVER'
+```
 */
-type IsEqual<A, B> = (<G>() => G extends A & G | G ? 1 : 2) extends (<G>() => G extends B & G | G ? 1 : 2) ? true : false;
+type IfNotAnyOrNever<T, IfNotAnyOrNever, IfAny = any, IfNever = never> = If<IsAny<T>, IfAny, If<IsNever$1<T>, IfNever, IfNotAnyOrNever>>;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/or.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.0.0/node_modules/type-fest/source/is-null.d.ts
 /**
-Returns a boolean for whether either of two given types are true.
-
-Use-case: Constructing complex conditional types where multiple conditions must be satisfied.
+Returns a boolean for whether the given type is `null`.
 
 @example
 ```
-import type {Or} from 'type-fest';
+import type {IsNull} from 'type-fest';
 
-Or<true, false>;
-//=> true
+type NonNullFallback<T, Fallback> = IsNull<T> extends true ? Fallback : T;
 
-Or<false, false>;
-//=> false
+type Example1 = NonNullFallback<null, string>;
+//=> string
+
+type Example2 = NonNullFallback<number, string>;
+//=? number
 ```
 
-@see {@link And}
+@category Type Guard
+@category Utilities
 */
-type Or<A extends boolean, B extends boolean> = [A, B][number] extends false ? false : true extends [IsEqual<A, true>, IsEqual<B, true>][number] ? true : never;
+type IsNull<T> = [T] extends [null] ? true : false;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/internal/keys.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.0.0/node_modules/type-fest/source/is-unknown.d.ts
 /**
-Disallows any of the given keys.
-*/
-type RequireNone<KeysType extends PropertyKey> = Partial<Record<KeysType, never>>;
+Returns a boolean for whether the given type is `unknown`.
 
-/**
-Utility type to retrieve only literal keys from type.
+@link https://github.com/dsherret/conditional-type-checks/pull/16
+
+Useful in type utilities, such as when dealing with unknown data from API calls.
+
+@example
+```
+import type {IsUnknown} from 'type-fest';
+
+// https://github.com/pajecawav/tiny-global-store/blob/master/src/index.ts
+type Action<TState, TPayload = void> =
+	IsUnknown<TPayload> extends true
+		? (state: TState) => TState,
+		: (state: TState, payload: TPayload) => TState;
+
+class Store<TState> {
+	constructor(private state: TState) {}
+
+	execute<TPayload = void>(action: Action<TState, TPayload>, payload?: TPayload): TState {
+		this.state = action(this.state, payload);
+		return this.state;
+	}
+
+	// ... other methods
+}
+
+const store = new Store({value: 1});
+declare const someExternalData: unknown;
+
+store.execute(state => ({value: state.value + 1}));
+//=> `TPayload` is `void`
+
+store.execute((state, payload) => ({value: state.value + payload}), 5);
+//=> `TPayload` is `5`
+
+store.execute((state, payload) => ({value: state.value + payload}), someExternalData);
+//=> Errors: `action` is `(state: TState) => TState`
+```
+
+@category Utilities
 */
+type IsUnknown<T> = (unknown extends T // `T` can be `unknown` or `any`
+? IsNull<T> extends false // `any` can be `null`, but `unknown` can't be
+? true : false : false);
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/simplify.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.0.0/node_modules/type-fest/source/simplify.d.ts
 /**
 Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
 
@@ -452,7 +555,7 @@ fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface`
 */
 type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/omit-index-signature.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.0.0/node_modules/type-fest/source/omit-index-signature.d.ts
 /**
 Omit any index signatures from the given object type, leaving only explicitly defined properties.
 
@@ -545,7 +648,7 @@ type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
 */
 type OmitIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType] };
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/pick-index-signature.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.0.0/node_modules/type-fest/source/pick-index-signature.d.ts
 /**
 Pick only index signatures from the given object type, leaving out all explicitly defined properties.
 
@@ -593,7 +696,7 @@ type ExampleIndexSignature = PickIndexSignature<Example>;
 */
 type PickIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never]: ObjectType[KeyType] };
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/merge.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.0.0/node_modules/type-fest/source/merge.d.ts
 // Merges two objects without worrying about index signatures.
 type SimpleMerge<Destination, Source> = { [Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key] } & Source;
 
@@ -633,101 +736,7 @@ export type FooBar = Merge<Foo, Bar>;
 */
 type Merge<Destination, Source> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/if-any.d.ts
-/**
-An if-else-like type that resolves depending on whether the given type is `any`.
-
-@see {@link IsAny}
-
-@example
-```
-import type {IfAny} from 'type-fest';
-
-type ShouldBeTrue = IfAny<any>;
-//=> true
-
-type ShouldBeBar = IfAny<'not any', 'foo', 'bar'>;
-//=> 'bar'
-```
-
-@category Type Guard
-@category Utilities
-*/
-type IfAny$1<T, TypeIfAny = true, TypeIfNotAny = false> = (IsAny<T> extends true ? TypeIfAny : TypeIfNotAny);
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/internal/type.d.ts
-/**
-Matches any primitive, `void`, `Date`, or `RegExp` value.
-*/
-type BuiltIns = Primitive | void | Date | RegExp;
-
-/**
-Matches non-recursive types.
-*/
-
-/**
-Test if the given function has multiple call signatures.
-
-Needed to handle the case of a single call signature with properties.
-
-Multiple call signatures cannot currently be supported due to a TypeScript limitation.
-@see https://github.com/microsoft/TypeScript/issues/29732
-*/
-type HasMultipleCallSignatures<T extends (...arguments_: any[]) => unknown> = T extends {
-  (...arguments_: infer A): unknown;
-  (...arguments_: infer B): unknown;
-} ? B extends A ? A extends B ? false : true : true : false;
-
-/**
-Returns a boolean for whether the given `boolean` is not `false`.
-*/
-
-/**
-Returns a boolean for whether the given type is a union type.
-
-@example
-```
-type A = IsUnion<string | number>;
-//=> true
-
-type B = IsUnion<string>;
-//=> false
-```
-*/
-type IsUnion$1<T> = InternalIsUnion<T>;
-
-/**
-The actual implementation of `IsUnion`.
-*/
-type InternalIsUnion<T, U = T> = (
-// @link https://ghaiklor.github.io/type-challenges-solutions/en/medium-isunion.html
-IsNever$1<T> extends true ? false : T extends any ? [U] extends [T] ? false : true : never) extends infer Result
-// In some cases `Result` will return `false | true` which is `boolean`,
-// that means `T` has at least two types and it's a union type,
-// so we will return `true` instead of `boolean`.
-? boolean extends Result ? true : Result : never; // Should never happen
-
-/**
-An if-else-like type that resolves depending on whether the given type is `any` or `never`.
-
-@example
-```
-// When `T` is a NOT `any` or `never` (like `string`) => Returns `IfNotAnyOrNever` branch
-type A = IfNotAnyOrNever<string, 'VALID', 'IS_ANY', 'IS_NEVER'>;
-//=> 'VALID'
-
-// When `T` is `any` => Returns `IfAny` branch
-type B = IfNotAnyOrNever<any, 'VALID', 'IS_ANY', 'IS_NEVER'>;
-//=> 'IS_ANY'
-
-// When `T` is `never` => Returns `IfNever` branch
-type C = IfNotAnyOrNever<never, 'VALID', 'IS_ANY', 'IS_NEVER'>;
-//=> 'IS_NEVER'
-```
-*/
-type IfNotAnyOrNever<T, IfNotAnyOrNever, IfAny = any, IfNever = never> = IsAny<T> extends true ? IfAny : IsNever$1<T> extends true ? IfNever : IfNotAnyOrNever;
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/internal/object.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.0.0/node_modules/type-fest/source/internal/object.d.ts
 /**
 Merges user specified options with default options.
 
@@ -780,10 +789,95 @@ type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOp
 // Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
 ```
 */
-type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = IfAny$1<SpecifiedOptions, Defaults, IfNever$1<SpecifiedOptions, Defaults, Simplify<Merge<Defaults, { [Key in keyof SpecifiedOptions as Key extends OptionalKeysOf<Options> ? Extract<SpecifiedOptions[Key], undefined> extends never ? Key : never : Key]: SpecifiedOptions[Key] }> & Required<Options>> // `& Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`
->>;
+type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = If<IsAny<SpecifiedOptions>, Defaults, If<IsNever$1<SpecifiedOptions>, Defaults, Simplify<Merge<Defaults, { [Key in keyof SpecifiedOptions as Key extends OptionalKeysOf<Options> ? undefined extends SpecifiedOptions[Key] ? never : Key : Key]: SpecifiedOptions[Key] }> & Required<Options>>>>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.0.0/node_modules/type-fest/source/or.d.ts
+/**
+Returns a boolean for whether either of two given types are true.
+
+Use-case: Constructing complex conditional types where multiple conditions must be satisfied.
+
+@example
+```
+import type {Or} from 'type-fest';
+
+type TT = Or<true, false>;
+//=> true
+
+type TF = Or<true, false>;
+//=> true
+
+type FT = Or<false, true>;
+//=> true
+
+type FF = Or<false, false>;
+//=> false
+```
+
+Note: When `boolean` is passed as an argument, it is distributed into separate cases, and the final result is a union of those cases.
+For example, `And<false, boolean>` expands to `And<false, true> | And<false, false>`, which simplifies to `true | false` (i.e., `boolean`).
+@example
+```
+import type {And} from 'type-fest';
+
+type A = Or<false, boolean>;
+//=> boolean
+
+type B = Or<boolean, false>;
+//=> boolean
+
+type C = Or<true, boolean>;
+//=> true
+
+type D = Or<boolean, true>;
+//=> true
+
+type E = Or<boolean, boolean>;
+//=> boolean
+```
+
+Note: If `never` is passed as an argument, it is treated as `false` and the result is computed accordingly.
+
+@example
+```
+import type {Or} from 'type-fest';
+
+type A = Or<true, never>;
+//=> true
+
+type B = Or<never, true>;
+//=> true
+
+type C = Or<false, never>;
+//=> false
+
+type D = Or<never, false>;
+//=> false
+
+type E = Or<boolean, never>;
+//=> boolean
+
+type F = Or<never, boolean>;
+//=> boolean
+
+type G = Or<never, never>;
+//=> false
+```
+
+@see {@link And}
+*/
+type Or<A extends boolean, B extends boolean> = _Or<If<IsNever$1<A>, false, A>, If<IsNever$1<B>, false, B>>;
+// `never` is treated as `false`
+
+type _Or<A extends boolean, B extends boolean> = A extends true ? true : B extends true ? true : false;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.0.0/node_modules/type-fest/source/internal/keys.d.ts
+/**
+Disallows any of the given keys.
+*/
+type RequireNone<KeysType extends PropertyKey> = Partial<Record<KeysType, never>>;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/require-exactly-one.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.0.0/node_modules/type-fest/source/require-exactly-one.d.ts
 /**
 Create a type that requires exactly one of the given keys and disallows more. The remaining keys are kept as is.
 
@@ -813,10 +907,10 @@ const responder: RequireExactlyOne<Responder, 'text' | 'json'> = {
 
 @category Object
 */
-type RequireExactlyOne<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> = IfNotAnyOrNever<ObjectType, IfNever$1<KeysType, never, _RequireExactlyOne<ObjectType, IfAny$1<KeysType, keyof ObjectType, KeysType>>>>;
+type RequireExactlyOne<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> = IfNotAnyOrNever<ObjectType, If<IsNever$1<KeysType>, never, _RequireExactlyOne<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>>>;
 type _RequireExactlyOne<ObjectType, KeysType extends keyof ObjectType> = { [Key in KeysType]: (Required<Pick<ObjectType, Key>> & Partial<Record<Exclude<KeysType, Key>, never>>) }[KeysType] & Omit<ObjectType, KeysType>;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/require-one-or-none.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.0.0/node_modules/type-fest/source/require-one-or-none.d.ts
 /**
 Create a type that requires exactly one of the given keys and disallows more, or none of the given keys. The remaining keys are kept as is.
 
@@ -847,10 +941,35 @@ const responder3: Responder = {
 
 @category Object
 */
-type RequireOneOrNone<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> = IfNotAnyOrNever<ObjectType, IfNever$1<KeysType, ObjectType, _RequireOneOrNone<ObjectType, IfAny$1<KeysType, keyof ObjectType, KeysType>>>>;
+type RequireOneOrNone<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> = IfNotAnyOrNever<ObjectType, If<IsNever$1<KeysType>, ObjectType, _RequireOneOrNone<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>>>;
 type _RequireOneOrNone<ObjectType, KeysType extends keyof ObjectType> = (RequireExactlyOne<ObjectType, KeysType> | RequireNone<KeysType>) & Omit<ObjectType, KeysType>; // Ignore unspecified keys.
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/partial-deep.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.0.0/node_modules/type-fest/source/is-union.d.ts
+/**
+Returns a boolean for whether the given type is a union.
+
+@example
+```
+import type {IsUnion} from 'type-fest';
+
+type A = IsUnion<string | number>;
+//=> true
+
+type B = IsUnion<string>;
+//=> false
+```
+*/
+type IsUnion$1<T> = InternalIsUnion<T>;
+/**
+The actual implementation of `IsUnion`.
+*/
+type InternalIsUnion<T, U = T> = (IsNever$1<T> extends true ? false : T extends any ? [U] extends [T] ? false : true : never) extends infer Result
+// In some cases `Result` will return `false | true` which is `boolean`,
+// that means `T` has at least two types and it's a union type,
+// so we will return `true` instead of `boolean`.
+? boolean extends Result ? true : Result : never; // Should never happen
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.0.0/node_modules/type-fest/source/partial-deep.d.ts
 /**
 @see {@link PartialDeep}
 */
@@ -865,24 +984,23 @@ type PartialDeepOptions = {
   Allows `undefined` values in non-tuple arrays.
   	- When set to `true`, elements of non-tuple arrays can be `undefined`.
   - When set to `false`, only explicitly defined elements are allowed in non-tuple arrays, ensuring stricter type checking.
-  	@default true
+  	@default false
   	@example
-  You can prevent `undefined` values in non-tuple arrays by passing `{recurseIntoArrays: true; allowUndefinedInNonTupleArrays: false}` as the second type argument:
+  You can allow `undefined` values in non-tuple arrays by passing `{recurseIntoArrays: true; allowUndefinedInNonTupleArrays: true}` as the second type argument:
   	```
   import type {PartialDeep} from 'type-fest';
   	type Settings = {
   	languages: string[];
   };
-  	declare const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true; allowUndefinedInNonTupleArrays: false}>;
-  	partialSettings.languages = [undefined]; // Error
-  partialSettings.languages = []; // Ok
+  	declare const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true; allowUndefinedInNonTupleArrays: true}>;
+  	partialSettings.languages = [undefined]; // OK
   ```
   */
   readonly allowUndefinedInNonTupleArrays?: boolean;
 };
 type DefaultPartialDeepOptions = {
   recurseIntoArrays: false;
-  allowUndefinedInNonTupleArrays: true;
+  allowUndefinedInNonTupleArrays: false;
 };
 
 /**
@@ -896,19 +1014,19 @@ Use-cases:
 ```
 import type {PartialDeep} from 'type-fest';
 
-const settings: Settings = {
+let settings = {
 	textEditor: {
 		fontSize: 14,
 		fontColor: '#000000',
-		fontWeight: 400
+		fontWeight: 400,
 	},
 	autocomplete: false,
-	autosave: true
+	autosave: true,
 };
 
-const applySavedSettings = (savedSettings: PartialDeep<Settings>) => {
-	return {...settings, ...savedSettings};
-}
+const applySavedSettings = (savedSettings: PartialDeep<typeof settings>) => (
+	{...settings, ...savedSettings, textEditor: {...settings.textEditor, ...savedSettings.textEditor}}
+);
 
 settings = applySavedSettings({textEditor: {fontWeight: 500}});
 ```
@@ -918,13 +1036,15 @@ By default, this does not affect elements in array and tuple types. You can chan
 ```
 import type {PartialDeep} from 'type-fest';
 
-type Settings = {
-	languages: string[];
-}
+type Shape = {
+	dimensions: [number, number];
+};
 
-const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true}> = {
-	languages: [undefined]
+const partialShape: PartialDeep<Shape, {recurseIntoArrays: true}> = {
+	dimensions: [], // OK
 };
+
+partialShape.dimensions = [15]; // OK
 ```
 
 @see {@link PartialDeepOptions}
@@ -968,9 +1088,7 @@ Same as `PartialDeep`, but accepts only `object`s as inputs. Internal helper for
 */
 type PartialObjectDeep<ObjectType extends object, Options extends Required<PartialDeepOptions>> = (ObjectType extends ((...arguments_: any) => unknown) ? (...arguments_: Parameters<ObjectType>) => ReturnType<ObjectType> : {}) & ({ [KeyType in keyof ObjectType]?: _PartialDeep<ObjectType[KeyType], Options> });
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/required-deep.d.ts
-type ExcludeUndefined<T> = Exclude<T, undefined>;
-
+//#region ../../node_modules/.pnpm/type-fest@5.0.0/node_modules/type-fest/source/required-deep.d.ts
 /**
 Create a type from another type with all keys and nested keys set to required.
 
@@ -984,23 +1102,23 @@ import type {RequiredDeep} from 'type-fest';
 
 type Settings = {
 	textEditor?: {
-		fontSize?: number | undefined;
-		fontColor?: string | undefined;
+		fontSize?: number;
+		fontColor?: string;
 		fontWeight?: number | undefined;
-	}
-	autocomplete?: boolean | undefined;
+	};
+	autocomplete?: boolean;
 	autosave?: boolean | undefined;
 };
 
 type RequiredSettings = RequiredDeep<Settings>;
-// type RequiredSettings = {
+//=> {
 // 	textEditor: {
 // 		fontSize: number;
 // 		fontColor: string;
-// 		fontWeight: number;
-// 	}
+// 		fontWeight: number | undefined;
+// 	};
 // 	autocomplete: boolean;
-// 	autosave: boolean;
+// 	autosave: boolean | undefined;
 // }
 ```
 
@@ -1012,14 +1130,10 @@ Note that types containing overloaded functions are not made deeply required due
 @category Set
 @category Map
 */
-type RequiredDeep<T, E extends ExcludeUndefined<T> = ExcludeUndefined<T>> = E extends BuiltIns ? E : E extends Map<infer KeyType, infer ValueType> ? Map<RequiredDeep<KeyType>, RequiredDeep<ValueType>> : E extends Set<infer ItemType> ? Set<RequiredDeep<ItemType>> : E extends ReadonlyMap<infer KeyType, infer ValueType> ? ReadonlyMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>> : E extends ReadonlySet<infer ItemType> ? ReadonlySet<RequiredDeep<ItemType>> : E extends WeakMap<infer KeyType, infer ValueType> ? WeakMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>> : E extends WeakSet<infer ItemType> ? WeakSet<RequiredDeep<ItemType>> : E extends Promise<infer ValueType> ? Promise<RequiredDeep<ValueType>> : E extends ((...arguments_: any[]) => unknown) ? {} extends RequiredObjectDeep<E> ? E : HasMultipleCallSignatures<E> extends true ? E : ((...arguments_: Parameters<E>) => ReturnType<E>) & RequiredObjectDeep<E> : E extends object ? E extends Array<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
-? ItemType[] extends E // Test for arrays (non-tuples) specifically
-? Array<RequiredDeep<ItemType>> // Recreate relevant array type to prevent eager evaluation of circular reference
-: RequiredObjectDeep<E> // Tuples behave properly
-: RequiredObjectDeep<E> : unknown;
+type RequiredDeep<T> = T extends BuiltIns ? T : T extends Map<infer KeyType, infer ValueType> ? Map<RequiredDeep<KeyType>, RequiredDeep<ValueType>> : T extends Set<infer ItemType> ? Set<RequiredDeep<ItemType>> : T extends ReadonlyMap<infer KeyType, infer ValueType> ? ReadonlyMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>> : T extends ReadonlySet<infer ItemType> ? ReadonlySet<RequiredDeep<ItemType>> : T extends WeakMap<infer KeyType, infer ValueType> ? WeakMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>> : T extends WeakSet<infer ItemType> ? WeakSet<RequiredDeep<ItemType>> : T extends Promise<infer ValueType> ? Promise<RequiredDeep<ValueType>> : T extends ((...arguments_: any[]) => unknown) ? {} extends RequiredObjectDeep<T> ? T : HasMultipleCallSignatures<T> extends true ? T : ((...arguments_: Parameters<T>) => ReturnType<T>) & RequiredObjectDeep<T> : T extends object ? RequiredObjectDeep<T> : unknown;
 type RequiredObjectDeep<ObjectType extends object> = { [KeyType in keyof ObjectType]-?: RequiredDeep<ObjectType[KeyType]> };
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/union-to-tuple.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.0.0/node_modules/type-fest/source/union-to-tuple.d.ts
 /**
 Returns the last element of a union type.
 
@@ -1068,76 +1182,6 @@ const petList = Object.keys(pets) as UnionToTuple<Pet>;
 */
 type UnionToTuple<T, L = LastOfUnion<T>> = IsNever$1<T> extends false ? [...UnionToTuple<Exclude<T, L>>, L] : [];
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/is-null.d.ts
-/**
-Returns a boolean for whether the given type is `null`.
-
-@example
-```
-import type {IsNull} from 'type-fest';
-
-type NonNullFallback<T, Fallback> = IsNull<T> extends true ? Fallback : T;
-
-type Example1 = NonNullFallback<null, string>;
-//=> string
-
-type Example2 = NonNullFallback<number, string>;
-//=? number
-```
-
-@category Type Guard
-@category Utilities
-*/
-type IsNull<T> = [T] extends [null] ? true : false;
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/is-unknown.d.ts
-/**
-Returns a boolean for whether the given type is `unknown`.
-
-@link https://github.com/dsherret/conditional-type-checks/pull/16
-
-Useful in type utilities, such as when dealing with unknown data from API calls.
-
-@example
-```
-import type {IsUnknown} from 'type-fest';
-
-// https://github.com/pajecawav/tiny-global-store/blob/master/src/index.ts
-type Action<TState, TPayload = void> =
-	IsUnknown<TPayload> extends true
-		? (state: TState) => TState,
-		: (state: TState, payload: TPayload) => TState;
-
-class Store<TState> {
-	constructor(private state: TState) {}
-
-	execute<TPayload = void>(action: Action<TState, TPayload>, payload?: TPayload): TState {
-		this.state = action(this.state, payload);
-		return this.state;
-	}
-
-	// ... other methods
-}
-
-const store = new Store({value: 1});
-declare const someExternalData: unknown;
-
-store.execute(state => ({value: state.value + 1}));
-//=> `TPayload` is `void`
-
-store.execute((state, payload) => ({value: state.value + payload}), 5);
-//=> `TPayload` is `5`
-
-store.execute((state, payload) => ({value: state.value + payload}), someExternalData);
-//=> Errors: `action` is `(state: TState) => TState`
-```
-
-@category Utilities
-*/
-type IsUnknown<T> = (unknown extends T // `T` can be `unknown` or `any`
-? IsNull<T> extends false // `any` can be `null`, but `unknown` can't be
-? true : false : false);
-//#endregion
 //#region src/types/core/modifiers.types.d.ts
 interface RegleBehaviourOptions {
   /**
@@ -1332,30 +1376,16 @@ type SafeFieldProperty<TState, TRule extends RegleFormPropertyType<any, any> | u
  * Negates a boolean type.
  */
 type Not<T extends boolean> = T extends true ? false : true;
-/**
- * Returns `true` if at least one of the types in the
- * {@linkcode Types} array is `true`, otherwise returns `false`.
- */
-
 /**
  * Checks if the given type is `never`.
  */
 type IsNever<T> = [T] extends [never] ? true : false;
-/**
- * Checks if the given type is `any`.
- */
-
 /**
  * Checks if one type extends another. Note: this is not quite the same as `Left extends Right` because:
  * 1. If either type is `never`, the result is `true` iff the other type is also `never`.
  * 2. Types are wrapped in a 1-tuple so that union types are not distributed - instead we consider `string | number` to _not_ extend `number`. If we used `Left extends Right` directly you would get `Extends<string | number, number>` => `false | true` => `boolean`.
  */
 type Extends<Left, Right> = IsNever<Left> extends true ? IsNever<Right> : [Left] extends [Right] ? true : false;
-/**
- * Checks if the {@linkcode Left} type extends the {@linkcode Right} type,
- * excluding `any` or `never`.
- */
-
 /**
  * Convert a union to an intersection.
  * `A | B | C` -\> `A & B & C`
@@ -1378,17 +1408,6 @@ type TuplifyUnion<Union, LastElement = LastOf<Union>> = IsNever<Union> extends t
  */
 type UnionToTuple$1<Union> = TuplifyUnion<Union>;
 type IsUnion<T> = Not<Extends<UnionToTuple$1<T>['length'], 1>>;
-/**
- * A recursive version of `Pick` that selects properties from the left type that are present in the right type.
- * The "leaf" types from `Left` are used - only the keys of `Right` are considered.
- *
- * @example
- * ```ts
- * const user = {email: 'a@b.com', name: 'John Doe', address: {street: '123 2nd St', city: 'New York', zip: '10001', state: 'NY', country: 'USA'}}
- *
- * type Result = DeepPickMatchingProps<typeof user, {name: unknown; address: {city: unknown}}> // {name: string, address: {city: string}}
- * ```
- */
 //#endregion
 //#region src/types/core/variants.types.d.ts
 type NarrowVariant<TRoot extends {
@@ -1631,7 +1650,7 @@ type IsLiteral<T> = string extends T ? false : true;
 /**
  * Returned typed of rules created with `createRule`
  * */
-interface RegleRuleDefinition<TValue extends unknown = unknown, TParams extends any[] = [], TAsync extends boolean = boolean, TMetaData extends RegleRuleMetadataDefinition = RegleRuleMetadataDefinition, TInput = unknown, TFilteredValue extends any = (TValue extends Date & File & infer M ? M : TValue)> extends RegleInternalRuleDefs<TFilteredValue, TParams, TAsync, TMetaData> {
+interface RegleRuleDefinition<TValue extends unknown = unknown, TParams extends any[] = [], TAsync extends boolean = boolean, TMetaData extends RegleRuleMetadataDefinition = RegleRuleMetadataDefinition, _TInput = unknown, TFilteredValue extends any = (TValue extends Date & File & infer M ? M : TValue)> extends RegleInternalRuleDefs<TFilteredValue, TParams, TAsync, TMetaData> {
   validator: RegleRuleDefinitionProcessor<TFilteredValue, TParams, TAsync extends false ? TMetaData : Promise<TMetaData>>;
   message: (metadata: PossibleRegleRuleMetadataConsumer<TFilteredValue>) => string | string[];
   active: (metadata: PossibleRegleRuleMetadataConsumer<TFilteredValue>) => boolean;
@@ -1640,10 +1659,6 @@ interface RegleRuleDefinition<TValue extends unknown = unknown, TParams extends
   _value?: IsLiteral<TValue> extends true ? TValue : any;
   exec: (value: Maybe<TFilteredValue>) => TAsync extends false ? TMetaData : Promise<TMetaData>;
 }
-/**
- * @internal
- * */
-
 /**
  * Rules with params created with `createRules` are callable while being customizable
  */
@@ -1687,10 +1702,6 @@ type PossibleRegleRuleMetadataConsumer<TValue> = {
 } & DefaultMetadataProperties & {
   $params?: [...any[]];
 };
-/**
- * @internal
- */
-
 /**
  * Generic types for a created RegleRule
  */
@@ -1740,11 +1751,6 @@ interface RegleRuleCore<TValue extends any, TParams extends any[] = [], TAsync e
   type?: string;
   async?: boolean;
 }
-/**
- * @internal
- * createRule arguments options
- */
-
 type RegleRuleTypeReturn<TValue, TParams extends [...any[]]> = {
   value: TValue;
   params: [...TParams];
@@ -1894,10 +1900,6 @@ type $InternalRegleCollectionRuleDecl = $InternalRegleRuleDecl & {
  * @public
  */
 type InlineRuleDeclaration<TValue extends any = any, TParams extends any[] = any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition> = boolean> = (value: Maybe<TValue>, ...args: UnwrapRegleUniversalParams<TParams>) => TReturn;
-/**
- * @internal
- */
-
 /**
  * @public
  * Regroup inline and registered rules
@@ -2336,11 +2338,6 @@ declare function createRule<TValue extends any, TParams extends any[], TReturn e
  * Removing Ref and executing function to return the unwrapped value
  */
 declare function unwrapRuleParameters<TParams extends any[]>(params: MaybeRefOrGetter[]): TParams;
-/**
- * Returns a clean list of parameters
- * Removing Ref and executing function to return the unwrapped value
- */
-
 //#endregion
 //#region src/core/defineRegleConfig.d.ts
 /**
@@ -2460,7 +2457,9 @@ type CreateScopedUseRegleOptions<TCustomRegle extends useRegleFn<any, any>, TAsR
    */
   customStore?: Ref<ScopedInstancesRecordLike>;
   /**
-   * Set the
+   * Collect instances in a Record instead of an array
+   *
+   * ⚠️ Each nested `useScopedRegle` must provide a parameter `scopeKey` to be collected.
    */
   asRecord?: TAsRecord;
 };
@@ -2516,9 +2515,14 @@ declare function createVariant<TForm extends Record<string, any>, TDiscriminant
  */
 declare function narrowVariant<TRoot extends {
   [x: string]: unknown;
+  $fields: {
+    [x: string]: unknown;
+  };
 }, const 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> | RegleFieldStatus<MaybeInput<TValue>, any, any> }>;
+} ? V : unknown)>(root: TRoot, discriminantKey: TKey, discriminantValue: TValue): root is Extract<TRoot, { [K in TKey]: RegleFieldStatus<TValue, any, any> | RegleFieldStatus<MaybeInput<TValue>, any, any> }> & {
+  $fields: Extract<TRoot['$fields'], { [K in TKey]: RegleFieldStatus<TValue, any, any> | RegleFieldStatus<MaybeInput<TValue>, any, any> }>;
+};
 /**
  * Narrow a nested variant root to a reactive reference
  *
@@ -2530,7 +2534,9 @@ declare function narrowVariant<TRoot extends {
  */
 declare function variantToRef<TRoot extends RegleStatus<{}, any, any>, const TKey extends keyof TRoot['$fields'], const TValue extends (LazyJoinDiscriminatedUnions<Exclude<TRoot['$fields'][TKey], RegleCollectionStatus<any, any, any> | RegleStatus<any, any, any>>> extends {
   $value: infer V;
-} ? V : unknown)>(root: MaybeRef<TRoot>, discriminantKey: TKey, discriminantValue: TValue): Ref<Extract<TRoot['$fields'], { [K in TKey]: RegleFieldStatus<TValue, any, any> }> | undefined>;
+} ? V : unknown)>(root: MaybeRef<TRoot>, discriminantKey: TKey, discriminantValue: TValue): Ref<(Extract<TRoot, { [K in TKey]: RegleFieldStatus<TValue, any, any> | RegleFieldStatus<MaybeInput<TValue>, any, any> }> & {
+  $fields: Extract<TRoot['$fields'], { [K in TKey]: RegleFieldStatus<TValue, any, any> | RegleFieldStatus<MaybeInput<TValue>, any, any> }>;
+}) | undefined>;
 //#endregion
 //#region src/core/refineRules.d.ts
 /**
@@ -2560,4 +2566,4 @@ declare function defineRules<TRules extends RegleUnknownRulesTree>(rules: TRules
  */
 declare function refineRules<TRules extends RegleUnknownRulesTree, TRefinement extends ReglePartialRuleTree<InferInput<TRules>> & RegleUnknownRulesTree>(rules: TRules, refinement: (state: Ref<InferInput<TRules>>) => TRefinement): (state: Ref<InferInput<TRules>>) => Merge<TRules, TRefinement>;
 //#endregion
-export { type $InternalRegleStatus, type AllRulesDeclarations, type CommonAlphaOptions, type CommonComparisonOptions, type CreateScopedUseRegleOptions, type DeepMaybeRef, type DeepReactiveState, type DefaultValidatorsTree, type FormRuleDeclaration, type HasNamedKeys, type HaveAnyRequiredProps, type InferInput, type InferRegleRoot, type InferRegleRule, type InferRegleRules, type InferRegleShortcuts, type InferRegleStatusType, type InferSafeOutput, type InlineRuleDeclaration, InternalRuleType, type JoinDiscriminatedUnions, type LocalRegleBehaviourOptions, type Maybe, type MaybeInput, type MaybeOutput, type MaybeReadonly, type MaybeVariantStatus, type MergedRegles, type MergedScopedRegles, type NarrowVariant, type NoInferLegacy, type PrimitiveTypes, type Regle, type RegleBehaviourOptions, type RegleCollectionErrors, type RegleCollectionRuleDecl, type RegleCollectionRuleDefinition, type RegleCollectionStatus, type RegleCommonStatus, type RegleComputedRules, type RegleCustomFieldStatus, type RegleEnforceCustomRequiredRules, type RegleEnforceRequiredRules, type RegleErrorTree, type RegleExternalCollectionErrors, type RegleExternalErrorTree, type RegleExternalSchemaErrorTree, type RegleFieldIssue, type RegleFieldStatus, type RegleFormPropertyType, type RegleInternalRuleDefs, type RegleIssuesTree, 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 RegleUnknownRulesTree, type RegleValidationErrors, type RegleValidationGroupEntry, type RegleValidationGroupOutput, type RegleRuleTree as RegleValidationTree, type ResolvedRegleBehaviourOptions, type ScopedInstancesRecord, type ScopedInstancesRecordLike, type SuperCompatibleRegle, type SuperCompatibleRegleCollectionErrors, type SuperCompatibleRegleCollectionStatus, type SuperCompatibleRegleFieldStatus, type SuperCompatibleRegleResult, type SuperCompatibleRegleRoot, type SuperCompatibleRegleRuleStatus, type SuperCompatibleRegleStatus, type Unwrap, type UnwrapRegleUniversalParams, type UnwrapRuleWithParams, type UseScopedRegleOptions, createRule, createScopedUseRegle, createVariant, defineRegleConfig, defineRules, extendRegleConfig, flatErrors, inferRules, type inferRulesFn, mergeRegles, narrowVariant, refineRules, unwrapRuleParameters, useCollectScope, type useCollectScopeFn, useRegle, type useRegleFn, useRootStorage, useScopedRegle, variantToRef };
+export { type $InternalRegleStatus, type AllRulesDeclarations, type ArrayElement, type CommonAlphaOptions, type CommonComparisonOptions, type CreateScopedUseRegleOptions, type DeepMaybeRef, type DeepReactiveState, type DefaultValidatorsTree, type FormRuleDeclaration, type HasNamedKeys, type HaveAnyRequiredProps, type InferInput, type InferRegleRoot, type InferRegleRule, type InferRegleRules, type InferRegleShortcuts, type InferRegleStatusType, type InferSafeOutput, type InlineRuleDeclaration, InternalRuleType, type JoinDiscriminatedUnions, type LocalRegleBehaviourOptions, type Maybe, type MaybeInput, type MaybeOutput, type MaybeReadonly, type MaybeVariantStatus, type MergedRegles, type MergedScopedRegles, type NarrowVariant, type NoInferLegacy, type NonEmptyTuple, type PrimitiveTypes, type Regle, type RegleBehaviourOptions, type RegleCollectionErrors, type RegleCollectionRuleDecl, type RegleCollectionRuleDefinition, type RegleCollectionStatus, type RegleCommonStatus, type RegleComputedRules, type RegleCustomFieldStatus, type RegleEnforceCustomRequiredRules, type RegleEnforceRequiredRules, type RegleErrorTree, type RegleExternalCollectionErrors, type RegleExternalErrorTree, type RegleExternalSchemaErrorTree, type RegleFieldIssue, type RegleFieldStatus, type RegleFormPropertyType, type RegleInternalRuleDefs, type RegleIssuesTree, 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 RegleUnknownRulesTree, type RegleValidationErrors, type RegleValidationGroupEntry, type RegleValidationGroupOutput, type RegleRuleTree as RegleValidationTree, type ResolvedRegleBehaviourOptions, type ScopedInstancesRecord, type ScopedInstancesRecordLike, type SuperCompatibleRegle, type SuperCompatibleRegleCollectionErrors, type SuperCompatibleRegleCollectionStatus, type SuperCompatibleRegleFieldStatus, type SuperCompatibleRegleResult, type SuperCompatibleRegleRoot, type SuperCompatibleRegleRuleStatus, type SuperCompatibleRegleStatus, type Unwrap, type UnwrapRegleUniversalParams, type UnwrapRuleWithParams, type UseScopedRegleOptions, createRule, createScopedUseRegle, createVariant, defineRegleConfig, defineRules, extendRegleConfig, flatErrors, inferRules, type inferRulesFn, mergeRegles, narrowVariant, refineRules, unwrapRuleParameters, useCollectScope, type useCollectScopeFn, useRegle, type useRegleFn, useRootStorage, useScopedRegle, variantToRef };