@regle/schemas 1.8.5 → 1.9.0-beta.1

package/dist/regle-schemas.d.ts

@@ -1,3 +1,4 @@
+import * as vue0 from "vue";
 import { MaybeRef, MaybeRefOrGetter, Raw, Ref, UnwrapNestedRefs, UnwrapRef } from "vue";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 
@@ -21,9 +22,9 @@ type isRecordLiteral<T extends unknown> = NonNullable<T> extends Date | File ? f
 type NoInferLegacy<A extends any> = [A][A extends any ? 0 : never];
 //#endregion
 //#region src/types/utils/Array.types.d.ts
-type ArrayElement$1<T> = T extends Array<infer U> ? U : never;
+type ArrayElement<T> = T extends Array<infer U> ? U : never;
 //#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).
 
@@ -31,27 +32,7 @@ Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/
 */
 type Primitive$1 = 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).
 
@@ -113,7 +94,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$1: unique symbol;
 
 /**
@@ -145,7 +126,6 @@ Unfortunately, `Record<string, never>`, `Record<keyof any, never>` and `Record<n
 type EmptyObject$1 = {
   [emptyObjectSymbol$1]?: never;
 };
-
 /**
 Returns a `boolean` for whether the type is strictly equal to an empty plain object, the `{}` value.
 
@@ -161,9 +141,83 @@ type Fail = IsEmptyObject<null>; //=> false
 @see EmptyObject
 @category Object
 */
-type IsEmptyObject$1<T> = T extends EmptyObject$1 ? true : false;
+type IsEmptyObject<T> = T extends EmptyObject$1 ? true : false;
+//#endregion
+//#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$1<T> = 0 extends 1 & NoInfer<T> ? 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-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$1<Type extends object, Key extends keyof Type> = IsAny$1<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.
 
@@ -197,11 +251,11 @@ const update2: UpdateOperation<User> = {
 
 @category Utilities
 */
-type OptionalKeysOf$1<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$1<Type extends object> = Type extends unknown // For distributing `Type`
+? (keyof { [Key in keyof Type as IsOptionalKeyOf$1<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.
 
@@ -226,11 +280,10 @@ const validator2 = createValidation<User>('surname', value => value.length < 25)
 
 @category Utilities
 */
-type RequiredKeysOf$1<BaseType extends object> = BaseType extends unknown // For distributing `BaseType`
-? Exclude<keyof BaseType, OptionalKeysOf$1<BaseType>> : never; // Should never happen
-
+type RequiredKeysOf$1<Type extends object> = Type extends unknown // For distributing `Type`
+? Exclude<keyof Type, OptionalKeysOf$1<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`.
 
@@ -274,124 +327,171 @@ 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$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$1<T> = T extends infer U ? U : never;
-
-/**
-Returns a boolean for whether the given type is `any`.
+type C = If<boolean, 'yes', 'no'>;
+//=> 'yes' | 'no'
 
-@link https://stackoverflow.com/a/49928360/1490091
+type D = If<any, 'yes', 'no'>;
+//=> 'yes' | 'no'
 
-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$1<T> = 0 extends 1 & NoInfer$1<T> ? true : false;
+type If$1<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
+/**
+Matches any primitive, `void`, `Date`, or `RegExp` value.
+*/
+type BuiltIns$1 = Primitive$1 | void | Date | RegExp;
 /**
-Returns a boolean for whether the two given types are equal.
+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
+*/
+
+/**
+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$1<IsAny$1<T>, IfAny, If$1<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.
 
@@ -451,7 +551,7 @@ fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface`
 */
 type Simplify$1<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.
 
@@ -544,7 +644,7 @@ type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
 */
 type OmitIndexSignature$1<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.
 
@@ -592,7 +692,7 @@ type ExampleIndexSignature = PickIndexSignature<Example>;
 */
 type PickIndexSignature$1<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$1<Destination, Source> = { [Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key] } & Source;
 
@@ -632,70 +732,7 @@ export type FooBar = Merge<Foo, Bar>;
 */
 type Merge$1<Destination, Source> = Simplify$1<SimpleMerge$1<PickIndexSignature$1<Destination>, PickIndexSignature$1<Source>> & SimpleMerge$1<OmitIndexSignature$1<Destination>, OmitIndexSignature$1<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$1<T, TypeIfAny = true, TypeIfNotAny = false> = (IsAny$1<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$1 = Primitive$1 | 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
-*/
-
-// 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$1<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.
 
@@ -748,10 +785,95 @@ type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOp
 // Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
 ```
 */
-type ApplyDefaultOptions$1<Options extends object, Defaults extends Simplify$1<Omit<Required<Options>, RequiredKeysOf$1<Options>> & Partial<Record<RequiredKeysOf$1<Options>, never>>>, SpecifiedOptions extends Options> = IfAny$1$1<SpecifiedOptions, Defaults, IfNever$1$1<SpecifiedOptions, Defaults, Simplify$1<Merge$1<Defaults, { [Key in keyof SpecifiedOptions as Key extends OptionalKeysOf$1<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$1<Options extends object, Defaults extends Simplify$1<Omit<Required<Options>, RequiredKeysOf$1<Options>> & Partial<Record<RequiredKeysOf$1<Options>, never>>>, SpecifiedOptions extends Options> = If$1<IsAny$1<SpecifiedOptions>, Defaults, If$1<IsNever$1<SpecifiedOptions>, Defaults, Simplify$1<Merge$1<Defaults, { [Key in keyof SpecifiedOptions as Key extends OptionalKeysOf$1<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$1<IsNever$1<A>, false, A>, If$1<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.
 
@@ -781,10 +903,10 @@ const responder: RequireExactlyOne<Responder, 'text' | 'json'> = {
 
 @category Object
 */
-type RequireExactlyOne<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> = IfNotAnyOrNever<ObjectType, IfNever$1$1<KeysType, never, _RequireExactlyOne<ObjectType, IfAny$1$1<KeysType, keyof ObjectType, KeysType>>>>;
+type RequireExactlyOne<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> = IfNotAnyOrNever<ObjectType, If$1<IsNever$1<KeysType>, never, _RequireExactlyOne<ObjectType, If$1<IsAny$1<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.
 
@@ -815,10 +937,28 @@ const responder3: Responder = {
 
 @category Object
 */
-type RequireOneOrNone<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> = IfNotAnyOrNever<ObjectType, IfNever$1$1<KeysType, ObjectType, _RequireOneOrNone<ObjectType, IfAny$1$1<KeysType, keyof ObjectType, KeysType>>>>;
+type RequireOneOrNone<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> = IfNotAnyOrNever<ObjectType, If$1<IsNever$1<KeysType>, ObjectType, _RequireOneOrNone<ObjectType, If$1<IsAny$1<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
+```
+*/
+
+// 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}
 */
@@ -833,24 +973,23 @@ type PartialDeepOptions$1 = {
   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$1 = {
   recurseIntoArrays: false;
-  allowUndefinedInNonTupleArrays: true;
+  allowUndefinedInNonTupleArrays: false;
 };
 
 /**
@@ -864,19 +1003,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}});
 ```
@@ -886,13 +1025,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}
@@ -936,127 +1077,98 @@ Same as `PartialDeep`, but accepts only `object`s as inputs. Internal helper for
 */
 type PartialObjectDeep$1<ObjectType extends object, Options extends Required<PartialDeepOptions$1>> = (ObjectType extends ((...arguments_: any) => unknown) ? (...arguments_: Parameters<ObjectType>) => ReturnType<ObjectType> : {}) & ({ [KeyType in keyof ObjectType]?: _PartialDeep$1<ObjectType[KeyType], Options> });
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/required-deep.d.ts
-
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/union-to-tuple.d.ts
-/**
-Returns the last element of a union type.
-
-@example
-```
-type Last = LastOfUnion<1 | 2 | 3>;
-//=> 3
-```
-*/
-type LastOfUnion<T> = UnionToIntersection<T extends any ? () => T : never> extends (() => (infer R)) ? R : never;
-
+//#region ../../node_modules/.pnpm/type-fest@5.0.0/node_modules/type-fest/source/required-deep.d.ts
 /**
-Convert a union type into an unordered tuple type of its elements.
-
-"Unordered" means the elements of the tuple are not guaranteed to be in the same order as in the union type. The arrangement can appear random and may change at any time.
+Create a type from another type with all keys and nested keys set to required.
 
-This can be useful when you have objects with a finite set of keys and want a type defining only the allowed keys, but do not want to repeat yourself.
+Use-cases:
+- Creating optional configuration interfaces where the underlying implementation still requires all options to be fully specified.
+- Modeling the resulting type after a deep merge with a set of defaults.
 
 @example
 ```
-import type {UnionToTuple} from 'type-fest';
-
-type Numbers = 1 | 2 | 3;
-type NumbersTuple = UnionToTuple<Numbers>;
-//=> [1, 2, 3]
-```
+import type {RequiredDeep} from 'type-fest';
 
-@example
+type Settings = {
+	textEditor?: {
+		fontSize?: number;
+		fontColor?: string;
+		fontWeight?: number | undefined;
+	};
+	autocomplete?: boolean;
+	autosave?: boolean | undefined;
+};
+
+type RequiredSettings = RequiredDeep<Settings>;
+//=> {
+// 	textEditor: {
+// 		fontSize: number;
+// 		fontColor: string;
+// 		fontWeight: number | undefined;
+// 	};
+// 	autocomplete: boolean;
+// 	autosave: boolean | undefined;
+// }
 ```
-import type {UnionToTuple} from 'type-fest';
-
-const pets = {
-  dog: '🐶',
-  cat: '🐱',
-  snake: '🐍',
-};
-
-type Pet = keyof typeof pets;
-//=> 'dog' | 'cat' | 'snake'
 
-const petList = Object.keys(pets) as UnionToTuple<Pet>;
-//=> ['dog', 'cat', 'snake']
-```
+Note that types containing overloaded functions are not made deeply required due to a [TypeScript limitation](https://github.com/microsoft/TypeScript/issues/29732).
 
+@category Utilities
+@category Object
 @category Array
+@category Set
+@category Map
 */
-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
+//#region ../../node_modules/.pnpm/type-fest@5.0.0/node_modules/type-fest/source/union-to-tuple.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.
+Returns the last element of a union type.
 
 @example
 ```
-import type {IsUnknown} from 'type-fest';
+type Last = LastOfUnion<1 | 2 | 3>;
+//=> 3
+```
+*/
+type LastOfUnion<T> = UnionToIntersection<T extends any ? () => T : never> extends (() => (infer R)) ? R : never;
 
-// 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;
+/**
+Convert a union type into an unordered tuple type of its elements.
 
-class Store<TState> {
-	constructor(private state: TState) {}
+"Unordered" means the elements of the tuple are not guaranteed to be in the same order as in the union type. The arrangement can appear random and may change at any time.
 
-	execute<TPayload = void>(action: Action<TState, TPayload>, payload?: TPayload): TState {
-		this.state = action(this.state, payload);
-		return this.state;
-	}
+This can be useful when you have objects with a finite set of keys and want a type defining only the allowed keys, but do not want to repeat yourself.
 
-	// ... other methods
-}
+@example
+```
+import type {UnionToTuple} from 'type-fest';
 
-const store = new Store({value: 1});
-declare const someExternalData: unknown;
+type Numbers = 1 | 2 | 3;
+type NumbersTuple = UnionToTuple<Numbers>;
+//=> [1, 2, 3]
+```
 
-store.execute(state => ({value: state.value + 1}));
-//=> `TPayload` is `void`
+@example
+```
+import type {UnionToTuple} from 'type-fest';
 
-store.execute((state, payload) => ({value: state.value + payload}), 5);
-//=> `TPayload` is `5`
+const pets = {
+  dog: '🐶',
+  cat: '🐱',
+  snake: '🐍',
+};
 
-store.execute((state, payload) => ({value: state.value + payload}), someExternalData);
-//=> Errors: `action` is `(state: TState) => TState`
+type Pet = keyof typeof pets;
+//=> 'dog' | 'cat' | 'snake'
+
+const petList = Object.keys(pets) as UnionToTuple<Pet>;
+//=> ['dog', 'cat', 'snake']
 ```
 
-@category Utilities
+@category Array
 */
-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);
+type UnionToTuple<T, L = LastOfUnion<T>> = IsNever$1<T> extends false ? [...UnionToTuple<Exclude<T, L>>, L] : [];
 //#endregion
 //#region src/types/core/modifiers.types.d.ts
 interface RegleBehaviourOptions {
@@ -1126,7 +1238,7 @@ type CollectionRegleBehaviourOptions = FieldRegleBehaviourOptions & {
   $deepCompare?: boolean;
 };
 type ShortcutCommonFn<T extends Record<string, any>> = {
-  [x: string]: (element: OmitByType<T, Function>) => unknown;
+  [x: string]: (element: Omit<OmitByType<T, Function>, '~standard'>) => unknown;
 };
 type RegleShortcutDefinition<TCustomRules extends Record<string, any> = {}> = {
   /**
@@ -1226,6 +1338,28 @@ type RegleResult<Data extends Record<string, any> | any[] | unknown, TRules exte
   valid: true;
   data: IsUnknown<Data> extends true ? unknown : IsAny$1<Data> extends true ? unknown : HasNamedKeys<Data> extends true ? Data extends Array<infer U extends Record<string, any>> ? DeepSafeFormState<U, TRules>[] : Data extends Date | File ? SafeFieldProperty<Data, TRules> : Data extends Record<string, any> ? DeepSafeFormState<Data, TRules> : SafeFieldProperty<Data, TRules> : unknown;
 };
+type RegleNestedResult<Data extends Record<string, any> | unknown, TRules extends ReglePartialRuleTree<any> | RegleFormPropertyType<any>> = RegleResult<Data, TRules> & ({
+  valid: false;
+  issues: RegleIssuesTree<Data>;
+  errors: RegleErrorTree<Data>;
+} | {
+  valid: true;
+  issues: EmptyObject$1;
+  errors: EmptyObject$1;
+});
+type RegleCollectionResult<Data extends any[], TRules extends ReglePartialRuleTree<any> | RegleFormPropertyType<any>> = RegleResult<Data, TRules> & ({
+  valid: false;
+  issues: RegleCollectionErrors<Data, true>;
+  errors: RegleCollectionErrors<Data>;
+} | {
+  valid: true;
+  issues: EmptyObject$1;
+  errors: EmptyObject$1;
+});
+type RegleFieldResult<Data extends any, TRules extends ReglePartialRuleTree<any> | RegleFormPropertyType<any>> = RegleResult<Data, TRules> & {
+  issues: RegleFieldIssue<TRules>[];
+  errors: string[];
+};
 /**
  * Infer safe output from any `r$` instance
  *
@@ -1237,11 +1371,13 @@ type RegleResult<Data extends Record<string, any> | any[] | unknown, TRules exte
 type $InternalRegleResult = {
   valid: boolean;
   data: any;
+  errors: $InternalRegleErrorTree | $InternalRegleCollectionErrors | string[];
+  issues: $InternalRegleIssuesTree | $InternalRegleCollectionIssues | RegleFieldIssue[];
 };
 type DeepSafeFormState<TState extends Record<string, any>, TRules extends ReglePartialRuleTree<Record<string, any>, CustomRulesDeclarationTree> | RegleFormPropertyType<any, any> | 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]> extends MaybeInput<infer M> ? MaybeOutput<M> : SafeProperty<TState[K], TRules[K]> } & { [K in keyof TState as IsPropertyOutputRequired<TState[K], TRules[K]> extends false ? never : K]-?: unknown extends SafeProperty<TState[K], TRules[K]> ? unknown : NonNullable<SafeProperty<TState[K], TRules[K]>> }> : TState;
 type FieldHaveRequiredRule<TRule extends RegleFormPropertyType<any, any> | undefined = never> = TRule extends MaybeRef<RegleRuleDecl<any, any>> ? [unknown] extends UnwrapRef<TRule>['required'] ? NonNullable<UnwrapRef<TRule>['literal']> extends RegleRuleDefinition<any, any[], any, any, any, any> ? true : false : NonNullable<UnwrapRef<TRule>['required']> extends UnwrapRef<TRule>['required'] ? UnwrapRef<TRule>['required'] extends RegleRuleDefinition<any, infer Params, any, any, any, any> ? Params extends never[] ? true : false : false : false : false;
 type ObjectHaveAtLeastOneRequiredField<TState extends Record<string, any>, TRule extends ReglePartialRuleTree<TState, any>> = TState extends Maybe<TState> ? { [K in keyof NonNullable<TState>]-?: IsPropertyOutputRequired<NonNullable<TState>[K], TRule[K]> }[keyof TState] extends false ? false : true : true;
-type ArrayHaveAtLeastOneRequiredField<TState extends Maybe<any[]>, TRule extends RegleCollectionRuleDecl<TState>> = TState extends Maybe<TState> ? FieldHaveRequiredRule<Omit<TRule, '$each'> extends MaybeRef<RegleRuleDecl> ? Omit<UnwrapRef<TRule>, '$each'> : {}> | ObjectHaveAtLeastOneRequiredField<ArrayElement$1<NonNullable<TState>>, ExtractFromGetter<TRule['$each']> extends undefined ? {} : NonNullable<ExtractFromGetter<TRule['$each']>>> extends false ? false : true : true;
+type ArrayHaveAtLeastOneRequiredField<TState extends Maybe<any[]>, TRule extends RegleCollectionRuleDecl<TState>> = TState extends Maybe<TState> ? FieldHaveRequiredRule<Omit<TRule, '$each'> extends MaybeRef<RegleRuleDecl> ? Omit<UnwrapRef<TRule>, '$each'> : {}> | ObjectHaveAtLeastOneRequiredField<ArrayElement<NonNullable<TState>>, ExtractFromGetter<TRule['$each']> extends undefined ? {} : NonNullable<ExtractFromGetter<TRule['$each']>>> extends false ? false : true : true;
 type SafeProperty<TState, TRule extends RegleFormPropertyType<any, any> | undefined> = unknown extends TState ? unknown : TRule extends RegleCollectionRuleDecl<any, any> ? TState extends Array<infer U extends Record<string, any>> ? DeepSafeFormState<U, ExtractFromGetter<TRule['$each']>>[] : TState : TRule extends ReglePartialRuleTree<any, any> ? ExtendOnlyRealRecord<TState> extends true ? DeepSafeFormState<NonNullable<TState> extends Record<string, any> ? JoinDiscriminatedUnions<NonNullable<TState>> : {}, TRule> : TRule extends MaybeRef<RegleRuleDecl<any, any>> ? FieldHaveRequiredRule<UnwrapRef<TRule>> extends true ? TState : MaybeOutput<TState> : TState : TState;
 type IsPropertyOutputRequired<TState, TRule extends RegleFormPropertyType<any, any> | undefined> = [unknown] extends [TState] ? unknown : NonNullable<TState> extends Array<any> ? TRule extends RegleCollectionRuleDecl<any, any> ? ArrayHaveAtLeastOneRequiredField<NonNullable<TState>, TRule> extends false ? false : true : false : TRule extends ReglePartialRuleTree<any, any> ? ExtendOnlyRealRecord<TState> extends true ? ObjectHaveAtLeastOneRequiredField<NonNullable<TState> extends Record<string, any> ? NonNullable<TState> : {}, TRule> extends false ? false : true : TRule extends MaybeRef<RegleRuleDecl<any, any>> ? FieldHaveRequiredRule<UnwrapRef<TRule>> extends false ? false : true : false : false;
 type SafeFieldProperty<TState, TRule extends RegleFormPropertyType<any, any> | undefined = never> = FieldHaveRequiredRule<TRule> extends true ? NonNullable<TState> : MaybeOutput<TState>;
@@ -1251,30 +1387,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$2<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$2<Left> extends true ? IsNever$2<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`
@@ -1297,24 +1419,13 @@ type TuplifyUnion<Union, LastElement = LastOf<Union>> = IsNever$2<Union> extends
  */
 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 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' | keyof RegleStatus<TState, TRules, TShortcuts>['$fields']> & {
   $fields: ProcessChildrenFields<TState, TRules, TShortcuts>[keyof ProcessChildrenFields<TState, TRules, TShortcuts>];
 } & (HasNamedKeys<TState> extends true ? ProcessChildrenFields<TState, TRules, TShortcuts>[keyof ProcessChildrenFields<TState, TRules, TShortcuts>] : {}) : RegleStatus<TState, TRules, TShortcuts>;
-type ProcessChildrenFields<TState extends Record<string, any> | undefined, TRules extends ReglePartialRuleTree<NonNullable<TState>>, TShortcuts extends RegleShortcutDefinition = {}> = { [TIndex in keyof TupleToPlainObj<UnionToTuple<TState>>]: TIndex extends `${infer TIndexInt extends number}` ? { [TKey in keyof UnionToTuple<TState>[TIndexInt] as IsEmptyObject$1<FindCorrespondingVariant<UnionToTuple<TState>[TIndexInt] extends Record<string, any> ? UnionToTuple<TState>[TIndexInt] : never, UnionToTuple<TRules>> extends [infer U] ? TKey extends keyof U ? U[TKey] : EmptyObject$1 : EmptyObject$1> extends true ? TKey extends keyof TState ? TState[TKey] extends NonNullable<TState[TKey]> ? TKey : never : never : TKey]-?: InferRegleStatusType<FindCorrespondingVariant<UnionToTuple<TState>[TIndexInt] extends Record<string, any> ? UnionToTuple<TState>[TIndexInt] : never, UnionToTuple<TRules>> extends [infer U] ? TKey extends keyof U ? U[TKey] : EmptyObject$1 : EmptyObject$1, NonNullable<UnionToTuple<TState>[TIndexInt]>, TKey, TShortcuts> } & { [TKey in keyof UnionToTuple<TState>[TIndexInt] as IsEmptyObject$1<FindCorrespondingVariant<UnionToTuple<TState>[TIndexInt] extends Record<string, any> ? UnionToTuple<TState>[TIndexInt] : never, UnionToTuple<TRules>> extends [infer U] ? TKey extends keyof U ? U[TKey] : EmptyObject$1 : EmptyObject$1> extends true ? TKey extends keyof TState ? TState[TKey] extends NonNullable<TState[TKey]> ? never : TKey : TKey : never]?: InferRegleStatusType<FindCorrespondingVariant<UnionToTuple<TState>[TIndexInt] extends Record<string, any> ? UnionToTuple<TState>[TIndexInt] : never, UnionToTuple<TRules>> extends [infer U] ? TKey extends keyof U ? U[TKey] : EmptyObject$1 : EmptyObject$1, NonNullable<UnionToTuple<TState>[TIndexInt]>, TKey, TShortcuts> } : {} };
+type ProcessChildrenFields<TState extends Record<string, any> | undefined, TRules extends ReglePartialRuleTree<NonNullable<TState>>, TShortcuts extends RegleShortcutDefinition = {}> = { [TIndex in keyof TupleToPlainObj<UnionToTuple<TState>>]: TIndex extends `${infer TIndexInt extends number}` ? { [TKey in keyof UnionToTuple<TState>[TIndexInt] as IsEmptyObject<FindCorrespondingVariant<UnionToTuple<TState>[TIndexInt] extends Record<string, any> ? UnionToTuple<TState>[TIndexInt] : never, UnionToTuple<TRules>> extends [infer U] ? TKey extends keyof U ? U[TKey] : EmptyObject$1 : EmptyObject$1> extends true ? TKey extends keyof TState ? TState[TKey] extends NonNullable<TState[TKey]> ? TKey : never : never : TKey]-?: InferRegleStatusType<FindCorrespondingVariant<UnionToTuple<TState>[TIndexInt] extends Record<string, any> ? UnionToTuple<TState>[TIndexInt] : never, UnionToTuple<TRules>> extends [infer U] ? TKey extends keyof U ? U[TKey] : EmptyObject$1 : EmptyObject$1, NonNullable<UnionToTuple<TState>[TIndexInt]>, TKey, TShortcuts> } & { [TKey in keyof UnionToTuple<TState>[TIndexInt] as IsEmptyObject<FindCorrespondingVariant<UnionToTuple<TState>[TIndexInt] extends Record<string, any> ? UnionToTuple<TState>[TIndexInt] : never, UnionToTuple<TRules>> extends [infer U] ? TKey extends keyof U ? U[TKey] : EmptyObject$1 : EmptyObject$1> extends true ? TKey extends keyof TState ? TState[TKey] extends NonNullable<TState[TKey]> ? never : TKey : TKey : never]?: InferRegleStatusType<FindCorrespondingVariant<UnionToTuple<TState>[TIndexInt] extends Record<string, any> ? UnionToTuple<TState>[TIndexInt] : never, UnionToTuple<TRules>> extends [infer U] ? TKey extends keyof U ? U[TKey] : EmptyObject$1 : EmptyObject$1, NonNullable<UnionToTuple<TState>[TIndexInt]>, TKey, TShortcuts> } : {} };
 type FindCorrespondingVariant<TState extends Record<string, any>, TRules extends any[]> = TRules extends [infer F, ...infer R] ? F extends ReglePartialRuleTree<TState> ? [F] : FindCorrespondingVariant<TState, R> : [];
 //#endregion
 //#region src/core/useRegle/useRegle.d.ts
@@ -1347,6 +1458,72 @@ interface useRegleFn<TCustomRules extends Partial<AllRulesDeclarations>, TShortc
  * Docs: {@link https://reglejs.dev/core-concepts/}
  */
 
+//#endregion
+//#region ../../node_modules/.pnpm/@standard-schema+spec@1.0.0/node_modules/@standard-schema/spec/dist/index.d.ts
+/** The Standard Schema interface. */
+interface StandardSchemaV1$1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly "~standard": StandardSchemaV1$1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1$1 {
+  /** The Standard Schema properties interface. */
+  export interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The result interface of the validate function. */
+  export type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  export interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** The non-existent issues. */
+    readonly issues?: undefined;
+  }
+  /** The result interface if validation fails. */
+  export interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  export interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  export interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard Schema types interface. */
+  export interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard Schema. */
+  export type InferInput<Schema extends StandardSchemaV1$1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /** Infers the output type of a Standard Schema. */
+  export type InferOutput<Schema extends StandardSchemaV1$1> = NonNullable<Schema["~standard"]["types"]>["output"];
+  export {};
+}
+//#endregion
+//#region src/core/useRegle/useErrors.d.ts
+/**
+ * Converts a 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
+ */
+
 //#endregion
 //#region src/types/utils/mismatch.types.d.ts
 /**
@@ -1439,7 +1616,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;
@@ -1448,10 +1625,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
  */
@@ -1491,10 +1664,6 @@ type PossibleRegleRuleMetadataConsumer<TValue> = {
 } & DefaultMetadataProperties & {
   $params?: [...any[]];
 };
-/**
- * @internal
- */
-
 /**
  * Generic types for a created RegleRule
  */
@@ -1512,9 +1681,9 @@ type RegleRuleRawInput<TValue extends any = any, TParams extends [...any[]] = [.
 
 type RegleRuleDefinitionProcessor<TValue extends any = any, TParams extends any[] = [], TReturn = any> = (value: Maybe<TValue>, ...params: TParams) => TReturn;
 type RegleCollectionRuleDefinition<TValue = any[], TCustomRules extends Partial<AllRulesDeclarations> = Partial<AllRulesDeclarations>> = (RegleRuleDecl<NonNullable<TValue>, TCustomRules, CollectionRegleBehaviourOptions> & {
-  $each: MaybeGetter<RegleFormPropertyType<ArrayElement$1<NonNullable<TValue>>, TCustomRules>, ArrayElement$1<TValue>>;
+  $each: MaybeGetter<RegleFormPropertyType<ArrayElement<NonNullable<TValue>>, TCustomRules>, ArrayElement<TValue>>;
 }) | ({
-  $each: MaybeGetter<RegleFormPropertyType<ArrayElement$1<NonNullable<TValue>>, TCustomRules>, ArrayElement$1<TValue>>;
+  $each: MaybeGetter<RegleFormPropertyType<ArrayElement<NonNullable<TValue>>, TCustomRules>, ArrayElement<TValue>>;
 } & CollectionRegleBehaviourOptions);
 //#endregion
 //#region src/types/rules/rule.init.types.d.ts
@@ -1536,11 +1705,6 @@ interface RegleRuleCore<TValue extends any, TParams extends any[] = [], TAsync e
   type?: string;
   async?: boolean;
 }
-/**
- * @internal
- * createRule arguments options
- */
-
 //#endregion
 //#region src/core/defaultValidators.d.ts
 interface CommonComparisonOptions {
@@ -1657,7 +1821,7 @@ type RegleCollectionRuleDecl<TValue = any[], TCustomRules extends Partial<AllRul
   $each?: RegleCollectionEachRules<TValue, TCustomRules>;
 } & CollectionRegleBehaviourOptions);
 /** @public */
-type RegleCollectionEachRules<TValue = any[], TCustomRules extends Partial<AllRulesDeclarations> = Partial<AllRulesDeclarations>> = MaybeGetter<RegleFormPropertyType<ArrayElement$1<NonNullable<TValue>>, TCustomRules>, ArrayElement$1<TValue>, RegleCollectionRuleDeclKeyProperty>;
+type RegleCollectionEachRules<TValue = any[], TCustomRules extends Partial<AllRulesDeclarations> = Partial<AllRulesDeclarations>> = MaybeGetter<RegleFormPropertyType<ArrayElement<NonNullable<TValue>>, TCustomRules>, ArrayElement<TValue>, RegleCollectionRuleDeclKeyProperty>;
 /**
  * @internal
  * @reference {@link RegleCollectionRuleDecl}
@@ -1667,10 +1831,6 @@ type RegleCollectionEachRules<TValue = any[], TCustomRules extends Partial<AllRu
  * @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
@@ -1687,7 +1847,7 @@ type RegleRoot<TState extends Record<string, unknown> = {}, TRules extends Regle
    */
   $groups: { readonly [TKey in keyof TValidationGroups]: RegleValidationGroupOutput };
 });
-type ProcessNestedFields$1<TState extends Record<string, any> | undefined, TRules extends ReglePartialRuleTree<NonNullable<TState>>, TShortcuts extends RegleShortcutDefinition = {}, TIsFields extends boolean = false> = Or<HasNamedKeys<TState>, TIsFields> extends true ? { readonly [TKey in keyof TState as TRules[TKey] extends NonNullable<TRules[TKey]> ? NonNullable<TRules[TKey]> extends MaybeRef<RegleRuleDecl> ? IsEmptyObject$1<TRules[TKey]> extends true ? TKey : never : never : TKey]: IsUnion<NonNullable<TRules[TKey]>> extends true ? ExtendOnlyRealRecord<TState[TKey]> extends true ? MaybeVariantStatus<NonNullable<TState>[TKey], NonNullable<TRules[TKey]>, TShortcuts> : InferRegleStatusType<NonNullable<TRules[TKey]>, NonNullable<TState>, TKey, TShortcuts> : InferRegleStatusType<NonNullable<TRules[TKey]>, NonNullable<TState>, TKey, TShortcuts> } & { readonly [TKey in keyof TState as TRules[TKey] extends NonNullable<TRules[TKey]> ? NonNullable<TRules[TKey]> extends MaybeRef<RegleRuleDecl> ? IsEmptyObject$1<TRules[TKey]> extends true ? never : TKey : TKey : never]-?: IsUnion<NonNullable<TRules[TKey]>> extends true ? ExtendOnlyRealRecord<TState[TKey]> extends true ? MaybeVariantStatus<NonNullable<TState>[TKey], NonNullable<TRules[TKey]>, TShortcuts> : InferRegleStatusType<NonNullable<TRules[TKey]>, NonNullable<TState>, TKey, TShortcuts> : InferRegleStatusType<NonNullable<TRules[TKey]>, NonNullable<TState>, TKey, TShortcuts> } : {};
+type ProcessNestedFields$1<TState extends Record<string, any> | undefined, TRules extends ReglePartialRuleTree<NonNullable<TState>>, TShortcuts extends RegleShortcutDefinition = {}, TIsFields extends boolean = false> = Or<HasNamedKeys<TState>, TIsFields> extends true ? { readonly [TKey in keyof TState as TRules[TKey] extends NonNullable<TRules[TKey]> ? NonNullable<TRules[TKey]> extends MaybeRef<RegleRuleDecl> ? IsEmptyObject<TRules[TKey]> extends true ? TKey : never : never : TKey]: IsUnion<NonNullable<TRules[TKey]>> extends true ? ExtendOnlyRealRecord<TState[TKey]> extends true ? MaybeVariantStatus<NonNullable<TState>[TKey], NonNullable<TRules[TKey]>, TShortcuts> : InferRegleStatusType<NonNullable<TRules[TKey]>, NonNullable<TState>, TKey, TShortcuts> : InferRegleStatusType<NonNullable<TRules[TKey]>, NonNullable<TState>, TKey, TShortcuts> } & { readonly [TKey in keyof TState as TRules[TKey] extends NonNullable<TRules[TKey]> ? NonNullable<TRules[TKey]> extends MaybeRef<RegleRuleDecl> ? IsEmptyObject<TRules[TKey]> extends true ? never : TKey : TKey : never]-?: IsUnion<NonNullable<TRules[TKey]>> extends true ? ExtendOnlyRealRecord<TState[TKey]> extends true ? MaybeVariantStatus<NonNullable<TState>[TKey], NonNullable<TRules[TKey]>, TShortcuts> : InferRegleStatusType<NonNullable<TRules[TKey]>, NonNullable<TState>, TKey, TShortcuts> : InferRegleStatusType<NonNullable<TRules[TKey]>, NonNullable<TState>, TKey, TShortcuts> } : {};
 /**
  * @public
  */
@@ -1711,7 +1871,7 @@ type RegleStatus<TState extends Record<string, any> | undefined = Record<string,
   /** 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) => PartialDeep$1<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<JoinDiscriminatedUnions<TState>, TRules>>;
+  $validate: (forceValues?: JoinDiscriminatedUnions<TState> extends EmptyObject$1 ? any : HasNamedKeys<JoinDiscriminatedUnions<TState>> extends true ? IsUnknown<JoinDiscriminatedUnions<TState>> extends true ? any : JoinDiscriminatedUnions<TState> : any) => Promise<RegleNestedResult<JoinDiscriminatedUnions<TState>, TRules>>;
 } & ProcessNestedFields$1<TState, TRules, TShortcuts> & ([TShortcuts['nested']] extends [never] ? {} : { [K in keyof TShortcuts['nested']]: ReturnType<NonNullable<TShortcuts['nested']>[K]> });
 /**
  * @internal
@@ -1731,7 +1891,7 @@ type RegleFieldIssue<TRules extends RegleFormPropertyType<any, Partial<AllRulesD
   readonly $property: string;
   readonly $type?: string;
   readonly $message: string;
-} & (IsEmptyObject$1<TRules> extends true ? {
+} & (IsEmptyObject<TRules> extends true ? {
   readonly $rule: string;
 } : { [K in keyof ComputeFieldRules<any, TRules>]: ComputeFieldRules<any, TRules>[K] extends {
   $metadata: infer TMetadata;
@@ -1744,7 +1904,7 @@ type RegleFieldIssue<TRules extends RegleFormPropertyType<any, Partial<AllRulesD
 } : {
   readonly $rule: string;
 } }[keyof ComputeFieldRules<any, TRules>]);
-type ComputeFieldRules<TState extends any, TRules extends RegleFormPropertyType<any, Partial<AllRulesDeclarations>>> = IsEmptyObject$1<TRules> extends true ? {
+type ComputeFieldRules<TState extends any, TRules extends RegleFormPropertyType<any, Partial<AllRulesDeclarations>>> = IsEmptyObject<TRules> extends true ? {
   readonly [x: string]: RegleRuleStatus<TState, any[], any>;
 } : { readonly [TRuleKey in keyof Omit<TRules, '$each' | keyof FieldRegleBehaviourOptions>]: RegleRuleStatus<TState, TRules[TRuleKey] extends RegleRuleDefinition<any, infer TParams, any> ? TParams : [], TRules[TRuleKey] extends RegleRuleDefinition<any, any, any, infer TMetadata> ? TMetadata : TRules[TRuleKey] extends InlineRuleDeclaration<any, any[], infer TMetadata> ? TMetadata extends Promise<infer P> ? P : TMetadata : boolean> };
 /**
@@ -1778,7 +1938,7 @@ type RegleFieldStatus<TState extends any = any, TRules extends RegleFormProperty
   /** 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) => 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>>;
+  $validate: (forceValues?: IsUnknown<TState> extends true ? any : TState) => Promise<RegleFieldResult<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 */
   readonly $rules: ComputeFieldRules<TState, TRules>;
 } & ([TShortcuts['fields']] extends [never] ? {} : { [K in keyof TShortcuts['fields']]: ReturnType<NonNullable<TShortcuts['fields']>[K]> });
@@ -1790,7 +1950,7 @@ type RegleFieldStatus<TState extends any = any, TRules extends RegleFormProperty
 /**
  * @public
  */
-interface RegleCommonStatus<TValue = any> {
+interface RegleCommonStatus<TValue = any> extends StandardSchemaV1$1<TValue> {
   /** Indicates whether the field is invalid. It becomes true if any associated rules return false. */
   readonly $invalid: boolean;
   /**
@@ -1915,7 +2075,7 @@ interface $InternalRegleRuleStatus {
 /**
  * @public
  */
-type RegleCollectionStatus<TState extends any[] = any[], TRules extends ReglePartialRuleTree<ArrayElement$1<TState>> = Record<string, any>, TFieldRule extends RegleCollectionRuleDecl<any, any> = never, TShortcuts extends RegleShortcutDefinition = {}> = Omit<RegleCommonStatus<TState>, '$value'> & {
+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: 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. */
@@ -1939,7 +2099,7 @@ type RegleCollectionStatus<TState extends any[] = any[], TRules extends ReglePar
   /** 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) => PartialDeep$1<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<JoinDiscriminatedUnions<TState>, JoinDiscriminatedUnions<TRules>>>;
+  $validate: (value?: JoinDiscriminatedUnions<TState>) => Promise<RegleCollectionResult<TState, JoinDiscriminatedUnions<TRules>>>;
 } & ([TShortcuts['collections']] extends [never] ? {} : { [K in keyof TShortcuts['collections']]: ReturnType<NonNullable<TShortcuts['collections']>[K]> });
 /**
  * @internal
@@ -1961,13 +2121,31 @@ type RegleExternalCollectionErrors<TState extends Record<string, any>, TIssue ex
   readonly $each?: RegleValidationErrors<TState, true, TIssue>[];
 };
 /** @internal */
+type $InternalRegleCollectionErrors = {
+  readonly $self?: string[];
+  readonly $each?: $InternalRegleErrors[];
+};
+type $InternalRegleErrorTree = {
+  [x: string]: $InternalRegleErrors;
+};
+type $InternalRegleErrors = $InternalRegleCollectionErrors | string[] | $InternalRegleErrorTree;
+type $InternalRegleIssuesTree = {
+  [x: string]: $InternalRegleIssues;
+};
+type $InternalRegleIssues = $InternalRegleCollectionIssues | RegleFieldIssue[] | $InternalRegleIssuesTree;
+type $InternalRegleCollectionIssues = {
+  readonly $self?: RegleFieldIssue[];
+  readonly $each?: $InternalRegleIssues[];
+};
+//#endregion
+//#region src/types/rules/compatibility.rules.d.ts
 
 /** Supports both core Regle and schemas Regle for Zod/Valibot */
 type SuperCompatibleRegleRoot = SuperCompatibleRegleStatus & {
   $groups?: {
     [x: string]: RegleValidationGroupOutput;
   };
-  $validate: () => Promise<SuperCompatibleRegleResult>;
+  $validate: (...args: any[]) => Promise<SuperCompatibleRegleResult>;
 };
 type SuperCompatibleRegleResult = $InternalRegleResult;
 type SuperCompatibleRegleStatus = {
@@ -1996,10 +2174,12 @@ type MergedRegles<TRegles extends Record<string, SuperCompatibleRegleRoot>, TVal
   readonly $errors: { [K in keyof TRegles]: TRegles[K]['$errors'] };
   /** Collection of all the error messages, collected for all children properties. */
   readonly $silentErrors: { [K in keyof TRegles]: TRegles[K]['$silentErrors'] };
+  readonly $issues: { [K in keyof TRegles]: TRegles[K]['$issues'] };
+  readonly $silentIssues: { [K in keyof TRegles]: TRegles[K]['$silentIssues'] };
   /** 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) => PartialDeep$1<TValue>;
   /** 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<MergedReglesResult<TRegles>>;
+  $validate: (forceValues?: TRegles['$value']) => Promise<MergedReglesResult<TRegles>>;
 };
 type MergedScopedRegles<TValue extends Record<string, unknown>[] = Record<string, unknown>[]> = Omit<MergedRegles<Record<string, SuperCompatibleRegleRoot>, TValue>, '$instances' | '$errors' | '$silentErrors' | '$value' | '$silentValue' | '$validate'> & {
   /** Array of scoped Regles instances  */
@@ -2010,10 +2190,16 @@ type MergedScopedRegles<TValue extends Record<string, unknown>[] = Record<string
   readonly $errors: RegleValidationErrors<Record<string, unknown>>[];
   /** Collection of all registered Regles instances silent errors */
   readonly $silentErrors: RegleValidationErrors<Record<string, unknown>>[];
+  /** Collection of all registered Regles instances issues */
+  readonly $issues: RegleValidationErrors<Record<string, unknown>, false, true>[];
+  /** Collection of all registered Regles instances silent issues */
+  readonly $silentIssues: RegleValidationErrors<Record<string, unknown>, false, true>[];
   /** 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<{
+  $validate: (forceValues?: TValue) => Promise<{
     valid: boolean;
     data: TValue;
+    errors: RegleValidationErrors<Record<string, unknown>>[];
+    issues: RegleValidationErrors<Record<string, unknown>>[];
   }>;
 };
 type MergedReglesResult<TRegles extends Record<string, SuperCompatibleRegleRoot>> = {
@@ -2021,11 +2207,15 @@ type MergedReglesResult<TRegles extends Record<string, SuperCompatibleRegleRoot>
   data: { [K in keyof TRegles]: Extract<PromiseReturn<ReturnType<TRegles[K]['$validate']>>, {
     valid: false;
   }>['data'] };
+  errors: { [K in keyof TRegles]: TRegles[K]['$errors'] };
+  issues: { [K in keyof TRegles]: TRegles[K]['$issues'] };
 } | {
   valid: true;
   data: { [K in keyof TRegles]: Extract<PromiseReturn<ReturnType<TRegles[K]['$validate']>>, {
     valid: true;
   }>['data'] };
+  errors: EmptyObject$1;
+  issues: EmptyObject$1;
 };
 //#endregion
 //#region src/core/createScopedUseRegle/useCollectScope.d.ts
@@ -2060,7 +2250,7 @@ type CreateScopedUseRegleOptions<TCustomRegle extends useRegleFn<any, any>, TAsR
   asRecord?: TAsRecord;
 };
 //#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).
 
@@ -2068,26 +2258,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/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;
 
 /**
@@ -2119,24 +2290,82 @@ Unfortunately, `Record<string, never>`, `Record<keyof any, never>` and `Record<n
 type EmptyObject = {
   [emptyObjectSymbol]?: never;
 };
+//#endregion
+//#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 type is strictly equal to an empty plain object, the `{}` value.
+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 {IsEmptyObject} from 'type-fest';
+import type {IsOptionalKeyOf} from 'type-fest';
 
-type Pass = IsEmptyObject<{}>; //=> true
-type Fail = IsEmptyObject<[]>; //=> false
-type Fail = IsEmptyObject<null>; //=> false
+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
 ```
 
-@see EmptyObject
-@category Object
+@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@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/optional-keys-of.d.ts
 /**
 Extract all optional keys from the given type.
 
@@ -2170,11 +2399,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.
 
@@ -2199,11 +2428,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`.
 
@@ -2247,85 +2475,73 @@ endIfEqual('abc', '123');
 */
 type IsNever<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`.
 
-@see {@link IsNever}
+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'>`.
+
+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';
-
-type ShouldBeTrue = IfNever<never>;
-//=> true
+import {If} from 'type-fest';
 
-type ShouldBeBar = IfNever<'not never', 'foo', 'bar'>;
-//=> 'bar'
-```
+type A = If<true, 'yes', 'no'>;
+//=> 'yes'
 
-@category Type Guard
-@category Utilities
-*/
-type IfNever$1<T, TypeIfNever = true, TypeIfNotNever = false> = (IsNever<T> extends true ? TypeIfNever : TypeIfNotNever);
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/internal/array.d.ts
-/**
-Extract the element of an array that also works for array union.
+type B = If<false, 'yes', 'no'>;
+//=> 'no'
 
-Returns `never` if T is not an array.
+type C = If<boolean, 'yes', 'no'>;
+//=> 'yes' | 'no'
 
-It creates a type-safe way to access the element type of `unknown` type.
-*/
-type ArrayElement<T> = T extends readonly unknown[] ? T[0] : never;
+type D = If<any, 'yes', 'no'>;
+//=> 'yes' | 'no'
 
-/**
-Returns the static, fixed-length portion of the given array, excluding variable-length parts.
+type E = If<never, 'yes', 'no'>;
+//=> 'no'
+```
 
 @example
 ```
-type A = [string, number, boolean, ...string[]];
-type B = StaticPartOfArray<A>;
-//=> [string, number, boolean]
-```
-*/
-//#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;
+import {If, IsAny, IsNever} from 'type-fest';
 
-/**
-Returns a boolean for whether the given type is `any`.
-
-@link https://stackoverflow.com/a/49928360/1490091
+type A = If<IsAny<unknown>, 'is any', 'not any'>;
+//=> 'not any'
 
-Useful in type utilities, such as disallowing `any`s to be passed to a function.
+type B = If<IsNever<never>, 'is never', 'not never'>;
+//=> 'is never'
+```
 
 @example
 ```
-import type {IsAny} from 'type-fest';
-
-const typedObject = {a: 1, b: 2} as const;
-const anyObject: any = {a: 1, b: 2};
+import {If, IsEqual} from 'type-fest';
 
-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 IfEqual<T, U, IfBranch, ElseBranch> = If<IsEqual<T, U>, IfBranch, ElseBranch>;
 
-const typedA = get(typedObject, 'a');
-//=> 1
+type A = IfEqual<string, string, 'equal', 'not equal'>;
+//=> 'equal'
 
-const anyA = get(anyObject, 'a');
-//=> any
+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<Type> extends true ? ElseBranch : Type extends true ? IfBranch : ElseBranch;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.0.0/node_modules/type-fest/source/internal/type.d.ts
+/**
+Matches any primitive, `void`, `Date`, or `RegExp` value.
+*/
+type BuiltIns = Primitive | void | Date | RegExp;
 //#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.
 
@@ -2385,7 +2601,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.
 
@@ -2478,7 +2694,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.
 
@@ -2526,7 +2742,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;
 
@@ -2566,40 +2782,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.
-*/
-
-//#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.
 
@@ -2652,10 +2835,9 @@ 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<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@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/partial-deep.d.ts
 /**
 @see {@link PartialDeep}
 */
@@ -2670,24 +2852,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;
 };
 
 /**
@@ -2701,19 +2882,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}});
 ```
@@ -2723,13 +2904,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}
@@ -2790,15 +2973,19 @@ type RegleSingleFieldSchema<TState extends Maybe<PrimitiveTypes>, TSchema extend
    */
   r$: Raw<RegleSchemaFieldStatus<TState, TSchema, TShortcuts> & {
     /** 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<RegleSchemaResult<TSchema>>;
+    $validate: (forceValues?: TSchema extends EmptyObject ? any : HasNamedKeys<TSchema> extends true ? TSchema : any) => Promise<RegleSchemaResult<TSchema>>;
   }>;
 } & TAdditionalReturnProperties;
 type RegleSchemaResult<TSchema extends unknown> = {
   valid: false;
   data: PartialDeep<TSchema>;
+  issues: RegleIssuesTree<TSchema>;
+  errors: RegleErrorTree<TSchema>;
 } | {
   valid: true;
   data: TSchema;
+  issues: EmptyObject;
+  errors: EmptyObject;
 };
 type ProcessNestedFields<TState extends Record<string, any>, TSchema extends Record<string, any>, TShortcuts extends RegleShortcutDefinition> = HasNamedKeys<TState> extends true ? { readonly [TKey in keyof JoinDiscriminatedUnions<TState>]: TKey extends keyof JoinDiscriminatedUnions<TSchema> ? InferRegleSchemaStatusType<NonNullable<JoinDiscriminatedUnions<TSchema>[TKey]>, JoinDiscriminatedUnions<TState>[TKey], TShortcuts> : never } & { readonly [TKey in keyof JoinDiscriminatedUnions<TState> as TKey extends keyof JoinDiscriminatedUnions<TSchema> ? JoinDiscriminatedUnions<TSchema>[TKey] extends NonNullable<JoinDiscriminatedUnions<TSchema>[TKey]> ? TKey : never : never]-?: TKey extends keyof JoinDiscriminatedUnions<TSchema> ? InferRegleSchemaStatusType<NonNullable<JoinDiscriminatedUnions<TSchema>[TKey]>, JoinDiscriminatedUnions<TState>[TKey], TShortcuts> : never } : {};
 /**
@@ -2821,7 +3008,7 @@ type RegleSchemaStatus<TState extends Record<string, any> = Record<string, any>,
   $extractDirtyFields: (filterNullishValues?: boolean) => PartialDeep<TState>;
 } & ProcessNestedFields<TState, TSchema, TShortcuts> & (IsRoot extends true ? {
   /** 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<RegleSchemaResult<TSchema>>;
+  $validate: (forceValues?: TSchema extends EmptyObject ? (HasNamedKeys<TSchema> extends true ? TSchema : any) : TSchema) => Promise<RegleSchemaResult<TSchema>>;
 } : {}) & ([TShortcuts['nested']] extends [never] ? {} : { [K in keyof TShortcuts['nested']]: ReturnType<NonNullable<TShortcuts['nested']>[K]> });
 /**
  * @public
@@ -2830,7 +3017,7 @@ type InferRegleSchemaStatusType<TSchema extends unknown, TState extends unknown,
 /**
  * @public
  */
-type RegleSchemaFieldStatus<TSchema extends unknown, TState = any, TShortcuts extends RegleShortcutDefinition = {}> = Omit<RegleCommonStatus<TState>, '$pending'> & {
+type RegleSchemaFieldStatus<_TSchema extends unknown, TState = any, TShortcuts extends RegleShortcutDefinition = {}> = Omit<RegleCommonStatus<TState>, '$pending'> & {
   /** Collection of all the error messages, collected for all children properties and nested forms.
    *
    * Only contains errors from properties where $dirty equals true. */
@@ -2944,7 +3131,7 @@ declare const useRegleSchema: useRegleSchemaFn<RegleShortcutDefinition<any>, {},
  * useRegleSchema({name: ''}, schema)
  * ```
  */
-declare function withDeps<TSchema extends StandardSchemaV1, TParams extends unknown[] = []>(schema: TSchema, depsArray: [...TParams]): TSchema;
+declare function withDeps<TSchema extends StandardSchemaV1, TParams extends unknown[] = []>(schema: TSchema, _depsArray: [...TParams]): TSchema;
 //#endregion
 //#region src/core/inferSchema.d.ts
 interface inferSchemaFn {
@@ -2992,7 +3179,7 @@ type CreateScopedUseRegleSchemaOptions<TCustomRegle extends useRegleSchemaFn<any
    */
   customUseRegle?: TCustomRegle;
 };
-declare const useCollectSchemaScope: <TValue extends Record<string, unknown>[] = Record<string, unknown>[]>(namespace?: MaybeRefOrGetter<string>) => {
+declare const useCollectSchemaScope: <TValue extends Record<string, unknown>[] = Record<string, unknown>[]>(namespace?: vue0.MaybeRefOrGetter<string>) => {
     r$: MergedScopedRegles<TValue>;
   }, useScopedRegleSchema: useRegleSchemaFn<RegleShortcutDefinition<any>, {}, {}>;
 declare const createScopedUseRegleSchema: <TCustomRegle extends useRegleSchemaFn = useRegleSchemaFn, TAsRecord extends boolean = false, TReturnedRegle extends useRegleSchemaFn<any, any, any> = (TCustomRegle extends useRegleSchemaFn<infer S> ? useRegleSchemaFn<S, {