notform 1.0.7 → 2.0.0-alpha.0

package/dist/index.d.ts

@@ -1,422 +1,2230 @@
-import * as vue0 from "vue";
-import { ComputedRef, MaybeRefOrGetter, Ref, VNodeChild, useAttrs } from "vue";
 import { StandardSchemaV1 } from "@standard-schema/spec";
-import { PartialDeep, Paths as Paths$1 } from "type-fest";
+import { MaybeRefOrGetter } from "vue";
 
-//#region src/types/shared.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/primitive.d.ts
 /**
- * Validation execution strategy.
- * - `lazy`: Validates on blur or submission.
- * - `eager`: Validates on blur, then on every change if an error exists.
- */
-type ValidationMode = 'lazy' | 'eager';
+Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
+
+@category Type
+*/
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.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>(object: O, key: K) {
+	return object[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.5.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';
+
+type User = {
+	name: string;
+	surname: string;
+
+	luckyNumber?: number;
+};
+
+type Admin = {
+	name: string;
+	surname?: string;
+};
+
+type T1 = IsOptionalKeyOf<User, 'luckyNumber'>;
+//=> true
+
+type T2 = IsOptionalKeyOf<User, 'name'>;
+//=> false
+
+type T3 = IsOptionalKeyOf<User, 'name' | 'luckyNumber'>;
+//=> boolean
+
+type T4 = IsOptionalKeyOf<User | Admin, 'name'>;
+//=> false
+
+type T5 = IsOptionalKeyOf<User | Admin, 'surname'>;
+//=> boolean
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsOptionalKeyOf<Type extends object, Key extends keyof Type> = IsAny<Type | Key> extends true ? never : Key extends keyof Type ? Type extends Record<Key, Type[Key]> ? false : true : false;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/optional-keys-of.d.ts
+/**
+Extract all optional keys from the given type.
+
+This is useful when you want to create a new type that contains different type values for the optional keys only.
+
+@example
+```
+import type {OptionalKeysOf, Except} from 'type-fest';
+
+type User = {
+	name: string;
+	surname: string;
+
+	luckyNumber?: number;
+};
+
+const REMOVE_FIELD = Symbol('remove field symbol');
+type UpdateOperation<Entity extends object> = Except<Partial<Entity>, OptionalKeysOf<Entity>> & {
+	[Key in OptionalKeysOf<Entity>]?: Entity[Key] | typeof REMOVE_FIELD;
+};
+
+const update1: UpdateOperation<User> = {
+	name: 'Alice',
+};
+
+const update2: UpdateOperation<User> = {
+	name: 'Bob',
+	luckyNumber: REMOVE_FIELD,
+};
+```
+
+@category Utilities
+*/
+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@5.5.0/node_modules/type-fest/source/required-keys-of.d.ts
+/**
+Extract all required keys from the given type.
+
+This is useful when you want to create a new type that contains different type values for the required keys only or use the list of keys for validation purposes, etc...
+
+@example
+```
+import type {RequiredKeysOf} from 'type-fest';
+
+declare function createValidation<
+	Entity extends object,
+	Key extends RequiredKeysOf<Entity> = RequiredKeysOf<Entity>,
+>(field: Key, validator: (value: Entity[Key]) => boolean): (entity: Entity) => boolean;
+
+type User = {
+	name: string;
+	surname: string;
+	luckyNumber?: number;
+};
+
+const validator1 = createValidation<User>('name', value => value.length < 25);
+const validator2 = createValidation<User>('surname', value => value.length < 25);
+
+// @ts-expect-error
+const validator3 = createValidation<User>('luckyNumber', value => value > 0);
+// Error: Argument of type '"luckyNumber"' is not assignable to parameter of type '"name" | "surname"'.
+```
+
+@category Utilities
+*/
+type RequiredKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
+? Exclude<keyof Type, OptionalKeysOf<Type>> : never;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/is-never.d.ts
+/**
+Returns a boolean for whether the given type is `never`.
+
+@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
+@link https://stackoverflow.com/a/53984913/10292952
+@link https://www.zhenghao.io/posts/ts-never
+
+Useful in type utilities, such as checking if something does not occur.
+
+@example
+```
+import type {IsNever, And} from 'type-fest';
+
+type A = IsNever<never>;
+//=> true
+
+type B = IsNever<any>;
+//=> false
+
+type C = IsNever<unknown>;
+//=> false
+
+type D = IsNever<never[]>;
+//=> false
+
+type E = IsNever<object>;
+//=> false
+
+type F = IsNever<string>;
+//=> false
+```
+
+@example
+```
+import type {IsNever} from 'type-fest';
+
+type IsTrue<T> = T extends true ? true : false;
+
+// When a distributive conditional is instantiated with `never`, the entire conditional results in `never`.
+type A = IsTrue<never>;
+//=> never
+
+// If you don't want that behaviour, you can explicitly add an `IsNever` check before the distributive conditional.
+type IsTrueFixed<T> =
+	IsNever<T> extends true ? false : T extends true ? true : false;
+
+type B = IsTrueFixed<never>;
+//=> false
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsNever<T> = [T] extends [never] ? true : false;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/if.d.ts
+/**
+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'>`.
+
+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 {If} from 'type-fest';
+
+type A = If<true, 'yes', 'no'>;
+//=> 'yes'
+
+type B = If<false, 'yes', 'no'>;
+//=> 'no'
+
+type C = If<boolean, 'yes', 'no'>;
+//=> 'yes' | 'no'
+
+type D = If<any, 'yes', 'no'>;
+//=> 'yes' | 'no'
+
+type E = If<never, 'yes', 'no'>;
+//=> 'no'
+```
+
+@example
+```
+import type {If, IsAny, IsNever} from 'type-fest';
+
+type A = If<IsAny<unknown>, 'is any', 'not any'>;
+//=> 'not any'
+
+type B = If<IsNever<never>, 'is never', 'not never'>;
+//=> 'is never'
+```
+
+@example
+```
+import type {If, IsEqual} from 'type-fest';
+
+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'
+```
+
+Note: Sometimes using the `If` type can make an implementation non–tail-recursive, which can impact performance. In such cases, it’s better to use a conditional directly. Refer to the following example:
+
+@example
+```
+import type {If, IsEqual, StringRepeat} from 'type-fest';
+
+type HundredZeroes = StringRepeat<'0', 100>;
+
+// The following implementation is not tail recursive
+type Includes<S extends string, Char extends string> =
+	S extends `${infer First}${infer Rest}`
+		? If<IsEqual<First, Char>,
+			'found',
+			Includes<Rest, Char>>
+		: 'not found';
+
+// Hence, instantiations with long strings will fail
+// @ts-expect-error
+type Fails = Includes<HundredZeroes, '1'>;
+//           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Error: Type instantiation is excessively deep and possibly infinite.
+
+// However, if we use a simple conditional instead of `If`, the implementation becomes tail-recursive
+type IncludesWithoutIf<S extends string, Char extends string> =
+	S extends `${infer First}${infer Rest}`
+		? IsEqual<First, Char> extends true
+			? 'found'
+			: IncludesWithoutIf<Rest, Char>
+		: 'not found';
+
+// Now, instantiations with long strings will work
+type Works = IncludesWithoutIf<HundredZeroes, '1'>;
+//=> 'not found'
+```
+
+@category Type Guard
+@category Utilities
+*/
+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.5.0/node_modules/type-fest/source/unknown-array.d.ts
+/**
+Represents an array with `unknown` value.
+
+Use case: You want a type that all arrays can be assigned to, but you don't care about the value.
+
+@example
+```
+import type {UnknownArray} from 'type-fest';
+
+type IsArray<T> = T extends UnknownArray ? true : false;
+
+type A = IsArray<['foo']>;
+//=> true
+
+type B = IsArray<readonly number[]>;
+//=> true
+
+type C = IsArray<string>;
+//=> false
+```
+
+@category Type
+@category Array
+*/
+type UnknownArray = readonly unknown[];
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.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.
+*/
+type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown) | Promise<unknown>;
+/**
+Matches maps, sets, or arrays.
+*/
+type MapsSetsOrArrays = ReadonlyMap<unknown, unknown> | WeakMap<WeakKey, unknown> | ReadonlySet<unknown> | WeakSet<WeakKey> | UnknownArray;
+/**
+Test if the given function has multiple call signatures.
+
+Needed to handle the case of a single call signature with properties.
+
+Multiple call signatures cannot currently be supported due to a TypeScript limitation.
+@see https://github.com/microsoft/TypeScript/issues/29732
+*/
+type HasMultipleCallSignatures<T extends (...arguments_: any[]) => unknown> = T extends {
+  (...arguments_: infer A): unknown;
+  (...arguments_: infer B): unknown;
+} ? B extends A ? A extends B ? false : true : true : false;
+/**
+Returns a boolean for whether A is false.
+
+@example
+```
+type A = Not<true>;
+//=> false
+
+type B = Not<false>;
+//=> true
+```
+*/
+type Not<A extends boolean> = A extends true ? false : A extends false ? true : never;
+/**
+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'
+```
+
+Note: Wrapping a tail-recursive type with `IfNotAnyOrNever` makes the implementation non-tail-recursive. To fix this, move the recursion into a helper type. Refer to the following example:
+
+@example
+```ts
+import type {StringRepeat} from 'type-fest';
+
+type NineHundredNinetyNineSpaces = StringRepeat<' ', 999>;
+
+// The following implementation is not tail recursive
+type TrimLeft<S extends string> = IfNotAnyOrNever<S, S extends ` ${infer R}` ? TrimLeft<R> : S>;
+
+// Hence, instantiations with long strings will fail
+// @ts-expect-error
+type T1 = TrimLeft<NineHundredNinetyNineSpaces>;
+//        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Error: Type instantiation is excessively deep and possibly infinite.
+
+// To fix this, move the recursion into a helper type
+type TrimLeftOptimised<S extends string> = IfNotAnyOrNever<S, _TrimLeftOptimised<S>>;
+
+type _TrimLeftOptimised<S extends string> = S extends ` ${infer R}` ? _TrimLeftOptimised<R> : S;
+
+type T2 = TrimLeftOptimised<NineHundredNinetyNineSpaces>;
+//=> ''
+```
+*/
+type IfNotAnyOrNever<T, IfNotAnyOrNever, IfAny = any, IfNever = never> = If<IsAny<T>, IfAny, If<IsNever<T>, IfNever, IfNotAnyOrNever>>;
+/**
+Indicates the value of `exactOptionalPropertyTypes` compiler option.
+*/
+type IsExactOptionalPropertyTypesEnabled = [(string | undefined)?] extends [string?] ? false : true;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/internal/array.d.ts
+/**
+Transforms a tuple type by replacing it's rest element with a single element that has the same type as the rest element, while keeping all the non-rest elements intact.
+
+@example
+```
+type A = CollapseRestElement<[string, string, ...number[]]>;
+//=> [string, string, number]
+
+type B = CollapseRestElement<[...string[], number, number]>;
+//=> [string, number, number]
+
+type C = CollapseRestElement<[string, string, ...Array<number | bigint>]>;
+//=> [string, string, number | bigint]
+
+type D = CollapseRestElement<[string, number]>;
+//=> [string, number]
+```
+
+Note: Optional modifiers (`?`) are removed from elements unless the `exactOptionalPropertyTypes` compiler option is disabled. When disabled, there's an additional `| undefined` for optional elements.
+
+@example
+```
+// `exactOptionalPropertyTypes` enabled
+type A = CollapseRestElement<[string?, string?, ...number[]]>;
+//=> [string, string, number]
+
+// `exactOptionalPropertyTypes` disabled
+type B = CollapseRestElement<[string?, string?, ...number[]]>;
+//=> [string | undefined, string | undefined, number]
+```
+*/
+type CollapseRestElement<TArray extends UnknownArray> = IfNotAnyOrNever<TArray, _CollapseRestElement<TArray>>;
+type _CollapseRestElement<TArray extends UnknownArray, ForwardAccumulator extends UnknownArray = [], BackwardAccumulator extends UnknownArray = []> = TArray extends UnknownArray // For distributing `TArray`
+? keyof TArray & `${number}` extends never // Enters this branch, if `TArray` is empty (e.g., []),
+// or `TArray` contains no non-rest elements preceding the rest element (e.g., `[...string[]]` or `[...string[], string]`).
+? TArray extends readonly [...infer Rest, infer Last] ? _CollapseRestElement<Rest, ForwardAccumulator, [Last, ...BackwardAccumulator]> // Accumulate elements that are present after the rest element.
+: TArray extends readonly [] ? [...ForwardAccumulator, ...BackwardAccumulator] : [...ForwardAccumulator, TArray[number], ...BackwardAccumulator] // Add the rest element between the accumulated elements.
+: TArray extends readonly [(infer First)?, ...infer Rest] ? _CollapseRestElement<Rest, [...ForwardAccumulator, '0' extends OptionalKeysOf<TArray> ? If<IsExactOptionalPropertyTypesEnabled, First, First | undefined> // Add `| undefined` for optional elements, if `exactOptionalPropertyTypes` is disabled.
+: First], BackwardAccumulator> : never // Should never happen, since `[(infer First)?, ...infer Rest]` is a top-type for arrays.
+: never; // Should never happen
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/numeric.d.ts
+type _Numeric = number | bigint;
+type Zero = 0 | 0n;
+/**
+Matches the hidden `Infinity` type.
+
+Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/32277) if you want to have this type as a built-in in TypeScript.
+
+@see {@link NegativeInfinity}
+
+@category Numeric
+*/
+// See https://github.com/microsoft/TypeScript/issues/31752
+// eslint-disable-next-line no-loss-of-precision
+type PositiveInfinity = 1e999;
+/**
+Matches the hidden `-Infinity` type.
+
+Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/32277) if you want to have this type as a built-in in TypeScript.
+
+@see {@link PositiveInfinity}
+
+@category Numeric
+*/
+// See https://github.com/microsoft/TypeScript/issues/31752
+// eslint-disable-next-line no-loss-of-precision
+type NegativeInfinity = -1e999;
+/**
+A negative `number`/`bigint` (`-∞ < x < 0`)
+
+Use-case: Validating and documenting parameters.
+
+@see {@link NegativeInteger}
+@see {@link NonNegative}
+
+@category Numeric
+*/
+type Negative<T extends _Numeric> = T extends Zero ? never : `${T}` extends `-${string}` ? T : never;
+/**
+Returns a boolean for whether the given number is a negative number.
+
+@see {@link Negative}
+
+@example
+```
+import type {IsNegative} from 'type-fest';
+
+type ShouldBeFalse = IsNegative<1>;
+type ShouldBeTrue = IsNegative<-1>;
+```
+
+@category Numeric
+*/
+type IsNegative<T extends _Numeric> = T extends Negative<T> ? true : false;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/tuple-of.d.ts
+/**
+Create a tuple type of the specified length with elements of the specified type.
+
+@example
+```
+import type {TupleOf} from 'type-fest';
+
+type RGB = TupleOf<3, number>;
+//=> [number, number, number]
+
+type Line = TupleOf<2, {x: number; y: number}>;
+//=> [{x: number; y: number}, {x: number; y: number}]
+
+type TicTacToeBoard = TupleOf<3, TupleOf<3, 'X' | 'O' | null>>;
+//=> [['X' | 'O' | null, 'X' | 'O' | null, 'X' | 'O' | null], ['X' | 'O' | null, 'X' | 'O' | null, 'X' | 'O' | null], ['X' | 'O' | null, 'X' | 'O' | null, 'X' | 'O' | null]]
+```
+
+@example
+```
+import type {TupleOf} from 'type-fest';
+
+type Range<Start extends number, End extends number> = Exclude<keyof TupleOf<End>, keyof TupleOf<Start>>;
+
+type ZeroToFour = Range<0, 5>;
+//=> '0' | '1' | '2' | '3' | '4'
+
+type ThreeToEight = Range<3, 9>;
+//=> '5' | '3' | '4' | '6' | '7' | '8'
+```
+
+Note: If the specified length is the non-literal `number` type, the result will not be a tuple but a regular array.
+
+@example
+```
+import type {TupleOf} from 'type-fest';
+
+type StringArray = TupleOf<number, string>;
+//=> string[]
+```
+
+Note: If the type for elements is not specified, it will default to `unknown`.
+
+@example
+```
+import type {TupleOf} from 'type-fest';
+
+type UnknownTriplet = TupleOf<3>;
+//=> [unknown, unknown, unknown]
+```
+
+Note: If the specified length is negative, the result will be an empty tuple.
+
+@example
+```
+import type {TupleOf} from 'type-fest';
+
+type EmptyTuple = TupleOf<-3, string>;
+//=> []
+```
+
+Note: If you need a readonly tuple, simply wrap this type with `Readonly`, for example, to create `readonly [number, number, number]` use `Readonly<TupleOf<3, number>>`.
+
+@category Array
+*/
+type TupleOf<Length extends number, Fill = unknown> = IfNotAnyOrNever<Length, _TupleOf<If<IsNegative<Length>, 0, Length>, Fill, []>, Fill[], []>;
+type _TupleOf<L extends number, Fill, Accumulator extends UnknownArray> = number extends L ? Fill[] : L extends Accumulator['length'] ? Accumulator : _TupleOf<L, Fill, [...Accumulator, Fill]>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/internal/string.d.ts
+/**
+Return a string representation of the given string or number.
+
+Note: This type is not the return type of the `.toString()` function.
+*/
+type ToString<T> = T extends string | number ? `${T}` : never;
+/**
+Converts a numeric string to a number.
+
+@example
+```
+type PositiveInt = StringToNumber<'1234'>;
+//=> 1234
+
+type NegativeInt = StringToNumber<'-1234'>;
+//=> -1234
+
+type PositiveFloat = StringToNumber<'1234.56'>;
+//=> 1234.56
+
+type NegativeFloat = StringToNumber<'-1234.56'>;
+//=> -1234.56
+
+type PositiveInfinity = StringToNumber<'Infinity'>;
+//=> Infinity
+
+type NegativeInfinity = StringToNumber<'-Infinity'>;
+//=> -Infinity
+```
+
+@category String
+@category Numeric
+@category Template literal
+*/
+type StringToNumber<S extends string> = S extends `${infer N extends number}` ? N : S extends 'Infinity' ? PositiveInfinity : S extends '-Infinity' ? NegativeInfinity : never;
+/**
+Returns an array of the characters of the string.
+
+@example
+```
+type A = StringToArray<'abcde'>;
+//=> ['a', 'b', 'c', 'd', 'e']
+
+type B = StringToArray<string>;
+//=> never
+```
+
+@category String
+*/
+type StringToArray<S extends string, Result extends string[] = []> = string extends S ? never : S extends `${infer F}${infer R}` ? StringToArray<R, [...Result, F]> : Result;
+/**
+Returns the length of the given string.
+
+@example
+```
+type A = StringLength<'abcde'>;
+//=> 5
+
+type B = StringLength<string>;
+//=> never
+```
+
+@category String
+@category Template literal
+*/
+type StringLength<S extends string> = string extends S ? never : StringToArray<S>['length'];
+/**
+Returns a boolean for whether `A` represents a number greater than `B`, where `A` and `B` are both numeric strings and have the same length.
+
+@example
+```
+type A = SameLengthPositiveNumericStringGt<'50', '10'>;
+//=> true
+
+type B = SameLengthPositiveNumericStringGt<'10', '10'>;
+//=> false
+```
+*/
+type SameLengthPositiveNumericStringGt<A extends string, B extends string> = A extends `${infer FirstA}${infer RestA}` ? B extends `${infer FirstB}${infer RestB}` ? FirstA extends FirstB ? SameLengthPositiveNumericStringGt<RestA, RestB> : PositiveNumericCharacterGt<FirstA, FirstB> : never : false;
+type NumericString = '0123456789';
+/**
+Returns a boolean for whether `A` is greater than `B`, where `A` and `B` are both positive numeric strings.
+
+@example
+```
+type A = PositiveNumericStringGt<'500', '1'>;
+//=> true
+
+type B = PositiveNumericStringGt<'1', '1'>;
+//=> false
+
+type C = PositiveNumericStringGt<'1', '500'>;
+//=> false
+```
+*/
+type PositiveNumericStringGt<A extends string, B extends string> = A extends B ? false : [TupleOf<StringLength<A>, 0>, TupleOf<StringLength<B>, 0>] extends infer R extends [readonly unknown[], readonly unknown[]] ? R[0] extends [...R[1], ...infer Remain extends readonly unknown[]] ? 0 extends Remain['length'] ? SameLengthPositiveNumericStringGt<A, B> : true : false : never;
+/**
+Returns a boolean for whether `A` represents a number greater than `B`, where `A` and `B` are both positive numeric characters.
+
+@example
+```
+type A = PositiveNumericCharacterGt<'5', '1'>;
+//=> true
+
+type B = PositiveNumericCharacterGt<'1', '1'>;
+//=> false
+```
+*/
+type PositiveNumericCharacterGt<A extends string, B extends string> = NumericString extends `${infer HeadA}${A}${infer TailA}` ? NumericString extends `${infer HeadB}${B}${infer TailB}` ? HeadA extends `${HeadB}${infer _}${infer __}` ? true : false : never : never;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/internal/numeric.d.ts
+/**
+Returns the absolute value of a given value.
+
+@example
+```
+type A = NumberAbsolute<-1>;
+//=> 1
+
+type B = NumberAbsolute<1>;
+//=> 1
+
+type C = NumberAbsolute<NegativeInfinity>;
+//=> PositiveInfinity
+```
+*/
+type NumberAbsolute<N extends number> = `${N}` extends `-${infer StringPositiveN}` ? StringToNumber<StringPositiveN> : N;
+/**
+Check whether the given type is a number or a number string.
+
+Supports floating-point as a string.
+
+@example
+```
+type A = IsNumberLike<'1'>;
+//=> true
+
+type B = IsNumberLike<'-1.1'>;
+//=> true
+
+type C = IsNumberLike<'5e-20'>;
+//=> true
+
+type D = IsNumberLike<1>;
+//=> true
+
+type E = IsNumberLike<'a'>;
+//=> false
+*/
+type IsNumberLike<N> = IfNotAnyOrNever<N, N extends number | `${number}` ? true : false, boolean, false>;
+/**
+Returns the number with reversed sign.
+
+@example
+```
+type A = ReverseSign<-1>;
+//=> 1
+
+type B = ReverseSign<1>;
+//=> -1
+
+type C = ReverseSign<NegativeInfinity>;
+//=> PositiveInfinity
+
+type D = ReverseSign<PositiveInfinity>;
+//=> NegativeInfinity
+```
+*/
+type ReverseSign<N extends number> = // Handle edge cases
+N extends 0 ? 0 : N extends PositiveInfinity ? NegativeInfinity : N extends NegativeInfinity ? PositiveInfinity : // Handle negative numbers
+`${N}` extends `-${infer P extends number}` ? P // Handle positive numbers
+: `-${N}` extends `${infer R extends number}` ? R : never;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.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.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+type PositionProps = {
+	top: number;
+	left: number;
+};
+
+type SizeProps = {
+	width: number;
+	height: number;
+};
+
+// In your editor, hovering over `Props` will show a flattened object with all the properties.
+type Props = Simplify<PositionProps & SizeProps>;
+```
+
+Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
+
+If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+interface SomeInterface {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+}
+
+type SomeType = {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+};
+
+const literal = {foo: 123, bar: 'hello', baz: 456};
+const someType: SomeType = literal;
+const someInterface: SomeInterface = literal;
+
+declare function fn(object: Record<string, unknown>): void;
+
+fn(literal); // Good: literal object type is sealed
+fn(someType); // Good: type is sealed
+// @ts-expect-error
+fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
+fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
+```
+
+@link https://github.com/microsoft/TypeScript/issues/15300
+@see {@link SimplifyDeep}
+@category Object
+*/
+type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/is-equal.d.ts
+/**
+Returns a boolean for whether the two given types are equal.
+
+@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
+
+Use-cases:
+- If you want to make a conditional branch based on the result of a comparison of two types.
+
+@example
+```
+import type {IsEqual} from 'type-fest';
+
+// 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;
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsEqual<A, B> = [A] extends [B] ? [B] extends [A] ? _IsEqual<A, B> : false : false;
+// This version fails the `equalWrappedTupleIntersectionToBeNeverAndNeverExpanded` test in `test-d/is-equal.ts`.
+type _IsEqual<A, B> = (<G>() => G extends A & G | G ? 1 : 2) extends (<G>() => G extends B & G | G ? 1 : 2) ? true : false;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.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.
+
+This is the counterpart of `PickIndexSignature`.
+
+Use-cases:
+- Remove overly permissive signatures from third-party types.
+
+This type was taken from this [StackOverflow answer](https://stackoverflow.com/a/68261113/420747).
+
+It relies on the fact that an empty object (`{}`) is assignable to an object with just an index signature, like `Record<string, unknown>`, but not to an object with explicitly defined keys, like `Record<'foo' | 'bar', unknown>`.
+
+(The actual value type, `unknown`, is irrelevant and could be any type. Only the key type matters.)
+
+```
+const indexed: Record<string, unknown> = {}; // Allowed
+
+// @ts-expect-error
+const keyed: Record<'foo', unknown> = {}; // Error
+// TS2739: Type '{}' is missing the following properties from type 'Record<"foo" | "bar", unknown>': foo, bar
+```
+
+Instead of causing a type error like the above, you can also use a [conditional type](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html) to test whether a type is assignable to another:
+
+```
+type Indexed = {} extends Record<string, unknown>
+	? '✅ `{}` is assignable to `Record<string, unknown>`'
+	: '❌ `{}` is NOT assignable to `Record<string, unknown>`';
+
+type IndexedResult = Indexed;
+//=> '✅ `{}` is assignable to `Record<string, unknown>`'
+
+type Keyed = {} extends Record<'foo' | 'bar', unknown>
+	? '✅ `{}` is assignable to `Record<\'foo\' | \'bar\', unknown>`'
+	: '❌ `{}` is NOT assignable to `Record<\'foo\' | \'bar\', unknown>`';
+
+type KeyedResult = Keyed;
+//=> '❌ `{}` is NOT assignable to `Record<\'foo\' | \'bar\', unknown>`'
+```
+
+Using a [mapped type](https://www.typescriptlang.org/docs/handbook/2/mapped-types.html#further-exploration), you can then check for each `KeyType` of `ObjectType`...
+
+```
+type OmitIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType // Map each key of `ObjectType`...
+	]: ObjectType[KeyType]; // ...to its original value, i.e. `OmitIndexSignature<Foo> == Foo`.
+};
+```
+
+...whether an empty object (`{}`) would be assignable to an object with that `KeyType` (`Record<KeyType, unknown>`)...
+
+```
+type OmitIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType
+	// Is `{}` assignable to `Record<KeyType, unknown>`?
+	as {} extends Record<KeyType, unknown>
+		? never // ✅ `{}` is assignable to `Record<KeyType, unknown>`
+		: KeyType // ❌ `{}` is NOT assignable to `Record<KeyType, unknown>`
+	]: ObjectType[KeyType];
+};
+```
+
+If `{}` is assignable, it means that `KeyType` is an index signature and we want to remove it. If it is not assignable, `KeyType` is a "real" key and we want to keep it.
+
+@example
+```
+import type {OmitIndexSignature} from 'type-fest';
+
+type Example = {
+	// These index signatures will be removed.
+	[x: string]: any;
+	[x: number]: any;
+	[x: symbol]: any;
+	[x: `head-${string}`]: string;
+	[x: `${string}-tail`]: string;
+	[x: `head-${string}-tail`]: string;
+	[x: `${bigint}`]: string;
+	[x: `embedded-${number}`]: string;
+
+	// These explicitly defined keys will remain.
+	foo: 'bar';
+	qux?: 'baz';
+};
+
+type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
+//=> {foo: 'bar'; qux?: 'baz'}
+```
+
+@see {@link PickIndexSignature}
+@category Object
+*/
+type OmitIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType] };
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.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.
+
+This is the counterpart of `OmitIndexSignature`.
+
+@example
+```
+import type {PickIndexSignature} from 'type-fest';
+
+declare const symbolKey: unique symbol;
+
+type Example = {
+	// These index signatures will remain.
+	[x: string]: unknown;
+	[x: number]: unknown;
+	[x: symbol]: unknown;
+	[x: `head-${string}`]: string;
+	[x: `${string}-tail`]: string;
+	[x: `head-${string}-tail`]: string;
+	[x: `${bigint}`]: string;
+	[x: `embedded-${number}`]: string;
+
+	// These explicitly defined keys will be removed.
+	['kebab-case-key']: string;
+	[symbolKey]: string;
+	foo: 'bar';
+	qux?: 'baz';
+};
+
+type ExampleIndexSignature = PickIndexSignature<Example>;
+// {
+// 	[x: string]: unknown;
+// 	[x: number]: unknown;
+// 	[x: symbol]: unknown;
+// 	[x: `head-${string}`]: string;
+// 	[x: `${string}-tail`]: string;
+// 	[x: `head-${string}-tail`]: string;
+// 	[x: `${bigint}`]: string;
+// 	[x: `embedded-${number}`]: string;
+// }
+```
+
+@see {@link OmitIndexSignature}
+@category Object
+*/
+type PickIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never]: ObjectType[KeyType] };
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/merge.d.ts
+// Merges two objects without worrying about index signatures.
+type SimpleMerge<Destination, Source> = Simplify<{ [Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key] } & Source>;
+/**
+Merge two types into a new type. Keys of the second type overrides keys of the first type.
+
+This is different from the TypeScript `&` (intersection) operator. With `&`, conflicting property types are intersected, which often results in `never`. For example, `{a: string} & {a: number}` makes `a` become `string & number`, which resolves to `never`. With `Merge`, the second type's keys cleanly override the first, so `Merge<{a: string}, {a: number}>` gives `{a: number}` as expected. `Merge` also produces a flattened type (via `Simplify`), making it more readable in IDE tooltips compared to `A & B`.
+
+@example
+```
+import type {Merge} from 'type-fest';
+
+type Foo = {
+	a: string;
+	b: number;
+};
+
+type Bar = {
+	a: number; // Conflicts with Foo['a']
+	c: boolean;
+};
+
+// With `&`, `a` becomes `string & number` which is `never`. Not what you want.
+type WithIntersection = (Foo & Bar)['a'];
+//=> never
+
+// With `Merge`, `a` is cleanly overridden to `number`.
+type WithMerge = Merge<Foo, Bar>['a'];
+//=> number
+```
+
+@example
+```
+import type {Merge} from 'type-fest';
+
+type Foo = {
+	[x: string]: unknown;
+	[x: number]: unknown;
+	foo: string;
+	bar: symbol;
+};
+
+type Bar = {
+	[x: number]: number;
+	[x: symbol]: unknown;
+	bar: Date;
+	baz: boolean;
+};
+
+export type FooBar = Merge<Foo, Bar>;
+//=> {
+// 	[x: string]: unknown;
+// 	[x: number]: number;
+// 	[x: symbol]: unknown;
+// 	foo: string;
+// 	bar: Date;
+// 	baz: boolean;
+// }
+```
+
+Note: If you want a merge type that more accurately reflects the runtime behavior of object spread or `Object.assign`, refer to the {@link ObjectMerge} type.
+
+@see {@link ObjectMerge}
+@category Object
+*/
+type Merge<Destination, Source> = Destination extends unknown // For distributing `Destination`
+? Source extends unknown // For distributing `Source`
+? If<IsEqual<Destination, Source>, Destination, _Merge<Destination, Source>> : never // Should never happen
+: never;
+// Should never happen
+type _Merge<Destination, Source> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/internal/object.d.ts
+/**
+Merges user specified options with default options.
+
+@example
+```
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
+type SpecifiedOptions = {leavesOnly: true};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//=> {maxRecursionDepth: 10; leavesOnly: true}
+```
+
+@example
+```
+// Complains if default values are not provided for optional options
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10};
+type SpecifiedOptions = {};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                              ~~~~~~~~~~~~~~~~~~~
+// Property 'leavesOnly' is missing in type 'DefaultPathsOptions' but required in type '{ maxRecursionDepth: number; leavesOnly: boolean; }'.
+```
+
+@example
+```
+// Complains if an option's default type does not conform to the expected type
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: 'no'};
+type SpecifiedOptions = {};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                              ~~~~~~~~~~~~~~~~~~~
+// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
+```
+
+@example
+```
+// Complains if an option's specified type does not conform to the expected type
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
+type SpecifiedOptions = {leavesOnly: 'yes'};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                                                   ~~~~~~~~~~~~~~~~
+// 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> = 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@5.5.0/node_modules/type-fest/source/some-extend.d.ts
+/**
+@see {@link SomeExtend}
+*/
+type SomeExtendOptions = {
+  /**
+  Consider `never` elements to match the target type only if the target type itself is `never` (or `any`).
+  	- When set to `true` (default), `never` is _not_ treated as a bottom type, instead, it is treated as a type that matches only itself (or `any`).
+  - When set to `false`, `never` is treated as a bottom type, and behaves as it normally would.
+  	@default true
+  	@example
+  ```
+  import type {SomeExtend} from 'type-fest';
+  	type A = SomeExtend<[1, 2, never], string, {strictNever: true}>;
+  //=> false
+  	type B = SomeExtend<[1, 2, never], string, {strictNever: false}>;
+  //=> true
+  	type C = SomeExtend<[1, never], never, {strictNever: true}>;
+  //=> true
+  	type D = SomeExtend<[1, never], never, {strictNever: false}>;
+  //=> true
+  	type E = SomeExtend<[never], any, {strictNever: true}>;
+  //=> true
+  	type F = SomeExtend<[never], any, {strictNever: false}>;
+  //=> true
+  ```
+  */
+  strictNever?: boolean;
+};
+type DefaultSomeExtendOptions = {
+  strictNever: true;
+};
+/**
+Returns a boolean for whether some element in an array type extends another type.
+
+@example
+```
+import type {SomeExtend} from 'type-fest';
+
+type A = SomeExtend<['1', '2', 3], number>;
+//=> true
+
+type B = SomeExtend<[1, 2, 3], string>;
+//=> false
+
+type C = SomeExtend<[string, number | string], number>;
+//=> boolean
+
+type D = SomeExtend<[true, boolean, true], false>;
+//=> boolean
+```
+
+Note: Behaviour of optional elements depend on the `exactOptionalPropertyTypes` compiler option. When the option is disabled, the target type must include `undefined` for a successful match.
+
+```
+// @exactOptionalPropertyTypes: true
+import type {SomeExtend} from 'type-fest';
+
+type A = SomeExtend<[1?, 2?, '3'?], string>;
+//=> true
+```
+
+```
+// @exactOptionalPropertyTypes: false
+import type {SomeExtend} from 'type-fest';
+
+type A = SomeExtend<[1?, 2?, '3'?], string>;
+//=> boolean
+
+type B = SomeExtend<[1?, 2?, '3'?], string | undefined>;
+//=> true
+```
+
+@see {@link SomeExtendOptions}
+
+@category Utilities
+@category Array
+*/
+type SomeExtend<TArray extends UnknownArray, Type, Options extends SomeExtendOptions = {}> = _SomeExtend<CollapseRestElement<TArray>, Type, ApplyDefaultOptions<SomeExtendOptions, DefaultSomeExtendOptions, Options>>;
+type _SomeExtend<TArray extends UnknownArray, Type, Options extends Required<SomeExtendOptions>> = IfNotAnyOrNever<TArray, TArray extends readonly [infer First, ...infer Rest] ? IsNever<First> extends true ? Or<Or<IsNever<Type>, IsAny<Type>>, Not<Options['strictNever']>> extends true // If target `Type` is also `never`, or is `any`, or `strictNever` is disabled, return `true`.
+? true : _SomeExtend<Rest, Type, Options> : First extends Type ? true : _SomeExtend<Rest, Type, Options> : false, false, false>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/or-all.d.ts
+/**
+Returns a boolean for whether any of the given elements is `true`.
+
+Use-cases:
+- Check if at least one condition in a list of booleans is met.
+
+@example
+```
+import type {OrAll} from 'type-fest';
+
+type FFT = OrAll<[false, false, true]>;
+//=> true
+
+type FFF = OrAll<[false, false, false]>;
+//=> false
+```
+
+Note: When `boolean` is passed as an element, it is distributed into separate cases, and the final result is a union of those cases.
+For example, `OrAll<[false, boolean]>` expands to `OrAll<[false, true]> | OrAll<[false, false]>`, which simplifies to `true | false` (i.e., `boolean`).
+
+@example
+```
+import type {OrAll} from 'type-fest';
+
+type A = OrAll<[false, boolean]>;
+//=> boolean
+
+type B = OrAll<[true, boolean]>;
+//=> true
+```
+
+Note: If `never` is passed as an element, it is treated as `false` and the result is computed accordingly.
+
+@example
+```
+import type {OrAll} from 'type-fest';
+
+type A = OrAll<[never, never, true]>;
+//=> true
+
+type B = OrAll<[never, never, false]>;
+//=> false
+
+type C = OrAll<[never, never, never]>;
+//=> false
+
+type D = OrAll<[never, never, boolean]>;
+//=> boolean
+```
+
+Note: If `any` is passed as an element, it is treated as `boolean` and the result is computed accordingly.
+
+@example
+```
+import type {OrAll} from 'type-fest';
+
+type A = OrAll<[false, any]>;
+//=> boolean
+
+type B = OrAll<[true, any]>;
+//=> true
+```
+
+Note: `OrAll<[]>` evaluates to `false` because there are no `true` elements in an empty tuple. See [Wikipedia: Clause (logic) > Empty clauses](https://en.wikipedia.org/wiki/Clause_(logic)#Empty_clauses:~:text=The%20truth%20evaluation%20of%20an%20empty%20disjunctive%20clause%20is%20always%20false.).
+
+@see {@link Or}
+@see {@link AndAll}
+*/
+type OrAll<T extends readonly boolean[]> = SomeExtend<T, true>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/or.d.ts
+/**
+Returns a boolean for whether either of two given types is true.
+
+Use-case: Constructing complex conditional types where at least one condition must be satisfied.
+
+@example
+```
+import type {Or} from 'type-fest';
+
+type TT = Or<true, true>;
+//=> 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, `Or<false, boolean>` expands to `Or<false, true> | Or<false, false>`, which simplifies to `true | false` (i.e., `boolean`).
+
+@example
+```
+import type {Or} 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 OrAll}
+@see {@link And}
+@see {@link Xor}
+*/
+type Or<A extends boolean, B extends boolean> = OrAll<[A, B]>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/all-extend.d.ts
+/**
+@see {@link AllExtend}
+*/
+type AllExtendOptions = {
+  /**
+  Consider `never` elements to match the target type only if the target type itself is `never` (or `any`).
+  	- When set to `true` (default), `never` is _not_ treated as a bottom type, instead, it is treated as a type that matches only itself (or `any`).
+  - When set to `false`, `never` is treated as a bottom type, and behaves as it normally would.
+  	@default true
+  	@example
+  ```
+  import type {AllExtend} from 'type-fest';
+  	type A = AllExtend<[1, 2, never], number, {strictNever: true}>;
+  //=> false
+  	type B = AllExtend<[1, 2, never], number, {strictNever: false}>;
+  //=> true
+  	type C = AllExtend<[never, never], never, {strictNever: true}>;
+  //=> true
+  	type D = AllExtend<[never, never], never, {strictNever: false}>;
+  //=> true
+  	type E = AllExtend<['a', 'b', never], any, {strictNever: true}>;
+  //=> true
+  	type F = AllExtend<['a', 'b', never], any, {strictNever: false}>;
+  //=> true
+  	type G = AllExtend<[never, 1], never, {strictNever: true}>;
+  //=> false
+  	type H = AllExtend<[never, 1], never, {strictNever: false}>;
+  //=> false
+  ```
+  */
+  strictNever?: boolean;
+};
+type DefaultAllExtendOptions = {
+  strictNever: true;
+};
+/**
+Returns a boolean for whether every element in an array type extends another type.
+
+@example
+```
+import type {AllExtend} from 'type-fest';
+
+type A = AllExtend<[1, 2, 3], number>;
+//=> true
+
+type B = AllExtend<[1, 2, '3'], number>;
+//=> false
+
+type C = AllExtend<[number, number | string], number>;
+//=> boolean
+
+type D = AllExtend<[true, boolean, true], true>;
+//=> boolean
+```
+
+Note: Behaviour of optional elements depend on the `exactOptionalPropertyTypes` compiler option. When the option is disabled, the target type must include `undefined` for a successful match.
+
+```
+// @exactOptionalPropertyTypes: true
+import type {AllExtend} from 'type-fest';
+
+type A = AllExtend<[1?, 2?, 3?], number>;
+//=> true
+```
+
+```
+// @exactOptionalPropertyTypes: false
+import type {AllExtend} from 'type-fest';
+
+type A = AllExtend<[1?, 2?, 3?], number>;
+//=> boolean
+
+type B = AllExtend<[1?, 2?, 3?], number | undefined>;
+//=> true
+```
+
+@see {@link AllExtendOptions}
+
+@category Utilities
+@category Array
+*/
+type AllExtend<TArray extends UnknownArray, Type, Options extends AllExtendOptions = {}> = _AllExtend<CollapseRestElement<TArray>, Type, ApplyDefaultOptions<AllExtendOptions, DefaultAllExtendOptions, Options>>;
+type _AllExtend<TArray extends UnknownArray, Type, Options extends Required<AllExtendOptions>> = IfNotAnyOrNever<TArray, TArray extends readonly [infer First, ...infer Rest] ? IsNever<First> extends true ? Or<Or<IsNever<Type>, IsAny<Type>>, Not<Options['strictNever']>> extends true // If target `Type` is also `never`, or is `any`, or `strictNever` is disabled, recurse further.
+? _AllExtend<Rest, Type, Options> : false : First extends Type ? _AllExtend<Rest, Type, Options> : false : true, false, false>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/and-all.d.ts
+/**
+Returns a boolean for whether all of the given elements are `true`.
+
+Use-cases:
+- Check if all conditions in a list of booleans are met.
+
+@example
+```
+import type {AndAll} from 'type-fest';
+
+type TTT = AndAll<[true, true, true]>;
+//=> true
+
+type TTF = AndAll<[true, true, false]>;
+//=> false
+
+type TFT = AndAll<[true, false, true]>;
+//=> false
+```
+
+Note: When `boolean` is passed as an element, it is distributed into separate cases, and the final result is a union of those cases.
+For example, `AndAll<[true, boolean]>` expands to `AndAll<[true, true]> | AndAll<[true, false]>`, which simplifies to `true | false` (i.e., `boolean`).
+
+@example
+```
+import type {AndAll} from 'type-fest';
+
+type A = AndAll<[true, boolean]>;
+//=> boolean
+
+type B = AndAll<[false, boolean]>;
+//=> false
+```
+
+Note: If any of the elements is `never`, the result becomes `false`.
+
+@example
+```
+import type {AndAll} from 'type-fest';
+
+type A = AndAll<[true, true, never]>;
+//=> false
+
+type B = AndAll<[false, never, never]>;
+//=> false
+
+type C = AndAll<[never, never, never]>;
+//=> false
+
+type D = AndAll<[boolean, true, never]>;
+//=> false
+```
+
+Note: If `any` is passed as an element, it is treated as `boolean` and the result is computed accordingly.
+
+@example
+```
+import type {AndAll} from 'type-fest';
+
+type A = AndAll<[false, any]>;
+//=> false
+
+type B = AndAll<[true, any]>;
+//=> boolean
+```
+
+Note: `AndAll<[]>` evaluates to `true` due to the concept of [vacuous truth](https://en.wikipedia.org/wiki/Logical_conjunction#:~:text=In%20keeping%20with%20the%20concept%20of%20vacuous%20truth%2C%20when%20conjunction%20is%20defined%20as%20an%20operator%20or%20function%20of%20arbitrary%20arity%2C%20the%20empty%20conjunction%20(AND%2Ding%20over%20an%20empty%20set%20of%20operands)%20is%20often%20defined%20as%20having%20the%20result%20true.), i.e., there are no `false` elements in an empty tuple.
+
+@see {@link And}
+@see {@link OrAll}
+*/
+type AndAll<T extends readonly boolean[]> = AllExtend<T, true>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/and.d.ts
 /**
- * Interaction events that can trigger a validation check for a field.
- */
-type ValidationTriggers = 'blur' | 'change' | 'input' | 'mount' | 'focus';
+Returns a boolean for whether two given types are both true.
+
+Use-case: Constructing complex conditional types where multiple conditions must be satisfied.
+
+@example
+```
+import type {And} from 'type-fest';
+
+type TT = And<true, true>;
+//=> true
+
+type TF = And<true, false>;
+//=> false
+
+type FT = And<false, true>;
+//=> false
+
+type FF = And<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<true, boolean>` expands to `And<true, true> | And<true, false>`, which simplifies to `true | false` (i.e., `boolean`).
+
+@example
+```
+import type {And} from 'type-fest';
+
+type A = And<true, boolean>;
+//=> boolean
+
+type B = And<boolean, true>;
+//=> boolean
+
+type C = And<false, boolean>;
+//=> false
+
+type D = And<boolean, false>;
+//=> false
+
+type E = And<boolean, boolean>;
+//=> boolean
+```
+
+Note: If either of the types is `never`, the result becomes `false`.
+
+@example
+```
+import type {And} from 'type-fest';
+
+type A = And<true, never>;
+//=> false
+
+type B = And<never, true>;
+//=> false
+
+type C = And<false, never>;
+//=> false
+
+type D = And<never, false>;
+//=> false
+
+type E = And<boolean, never>;
+//=> false
+
+type F = And<never, boolean>;
+//=> false
+
+type G = And<never, never>;
+//=> false
+```
+
+@see {@link AndAll}
+@see {@link Or}
+@see {@link Xor}
+*/
+type And<A extends boolean, B extends boolean> = AndAll<[A, B]>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/greater-than.d.ts
 /**
- * Represents a validation schema for object-based data structures.
- * Complies with the Standard Schema specification.
- */
-type ObjectSchema = StandardSchemaV1 & {
-  '~standard': StandardSchemaV1['~standard'] & {
-    types?: {
-      input: object;
-    };
-  };
-};
+Returns a boolean for whether a given number is greater than another number.
+
+@example
+```
+import type {GreaterThan} from 'type-fest';
+
+type A = GreaterThan<1, -5>;
+//=> true
+
+type B = GreaterThan<1, 1>;
+//=> false
+
+type C = GreaterThan<1, 5>;
+//=> false
+```
+
+Note: If either argument is the non-literal `number` type, the result is `boolean`.
+
+@example
+```
+import type {GreaterThan} from 'type-fest';
+
+type A = GreaterThan<number, 1>;
+//=> boolean
+
+type B = GreaterThan<1, number>;
+//=> boolean
+
+type C = GreaterThan<number, number>;
+//=> boolean
+```
+
+@example
+```
+import type {GreaterThan} from 'type-fest';
+
+// Use `GreaterThan` to constrain a function parameter to positive numbers.
+declare function setPositive<N extends number>(value: GreaterThan<N, 0> extends true ? N : never): void;
+
+setPositive(1); // ✅ Allowed
+setPositive(2); // ✅ Allowed
+
+// @ts-expect-error
+setPositive(0);
+
+// @ts-expect-error
+setPositive(-1);
+```
+*/
+type GreaterThan<A extends number, B extends number> = A extends number // For distributing `A`
+? B extends number // For distributing `B`
+? number extends A | B ? boolean : [IsEqual<A, PositiveInfinity>, IsEqual<A, NegativeInfinity>, IsEqual<B, PositiveInfinity>, IsEqual<B, NegativeInfinity>] extends infer R extends [boolean, boolean, boolean, boolean] ? Or<And<IsEqual<R[0], true>, IsEqual<R[2], false>>, And<IsEqual<R[3], true>, IsEqual<R[1], false>>> extends true ? true : Or<And<IsEqual<R[1], true>, IsEqual<R[3], false>>, And<IsEqual<R[2], true>, IsEqual<R[0], false>>> extends true ? false : true extends R[number] ? false : [IsNegative<A>, IsNegative<B>] extends infer R extends [boolean, boolean] ? [true, false] extends R ? false : [false, true] extends R ? true : [false, false] extends R ? PositiveNumericStringGt<`${A}`, `${B}`> : PositiveNumericStringGt<`${NumberAbsolute<B>}`, `${NumberAbsolute<A>}`> : never : never : never // Should never happen
+: never;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/greater-than-or-equal.d.ts
 /**
- * Represents a validation schema for array-based data structures.
- * Complies with the Standard Schema specification.
- */
-type ArraySchema = StandardSchemaV1 & {
-  '~standard': StandardSchemaV1['~standard'] & {
-    types?: {
-      input: Array<any>;
-    };
-  };
-};
+Returns a boolean for whether a given number is greater than or equal to another number.
+
+@example
+```
+import type {GreaterThanOrEqual} from 'type-fest';
+
+type A = GreaterThanOrEqual<1, -5>;
+//=> true
+
+type B = GreaterThanOrEqual<1, 1>;
+//=> true
+
+type C = GreaterThanOrEqual<1, 5>;
+//=> false
+```
+
+Note: If either argument is the non-literal `number` type, the result is `boolean`.
+
+@example
+```
+import type {GreaterThanOrEqual} from 'type-fest';
+
+type A = GreaterThanOrEqual<number, 1>;
+//=> boolean
+
+type B = GreaterThanOrEqual<1, number>;
+//=> boolean
+
+type C = GreaterThanOrEqual<number, number>;
+//=> boolean
+```
+
+@example
+```
+import type {GreaterThanOrEqual} from 'type-fest';
+
+// Use `GreaterThanOrEqual` to constrain a function parameter to non-negative numbers.
+declare function setNonNegative<N extends number>(value: GreaterThanOrEqual<N, 0> extends true ? N : never): void;
+
+setNonNegative(0); // ✅ Allowed
+setNonNegative(1); // ✅ Allowed
+
+// @ts-expect-error
+setNonNegative(-1);
+
+// @ts-expect-error
+setNonNegative(-2);
+```
+*/
+type GreaterThanOrEqual<A extends number, B extends number> = number extends A | B ? boolean : A extends number // For distributing `A`
+? B extends number // For distributing `B`
+? A extends B ? true : GreaterThan<A, B> : never // Should never happen
+: never;
 //#endregion
-//#region src/types/utils.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/less-than.d.ts
 /**
- * Constructs a type where all properties of the input type are optional recursively.
- * @template TData The base data structure to transform.
- */
-type DeepPartial<TData> = PartialDeep<TData, {
-  recurseIntoArrays: true;
-  allowUndefinedInNonTupleArrays: true;
-}>;
+Returns a boolean for whether a given number is less than another number.
+
+@example
+```
+import type {LessThan} from 'type-fest';
+
+type A = LessThan<1, -5>;
+//=> false
+
+type B = LessThan<1, 1>;
+//=> false
+
+type C = LessThan<1, 5>;
+//=> true
+```
+
+Note: If either argument is the non-literal `number` type, the result is `boolean`.
+
+@example
+```
+import type {LessThan} from 'type-fest';
+
+type A = LessThan<number, 1>;
+//=> boolean
+
+type B = LessThan<1, number>;
+//=> boolean
+
+type C = LessThan<number, number>;
+//=> boolean
+```
+
+@example
+```
+import type {LessThan} from 'type-fest';
+
+// Use `LessThan` to constrain a function parameter to negative numbers.
+declare function setNegative<N extends number>(value: LessThan<N, 0> extends true ? N : never): void;
+
+setNegative(-1); // ✅ Allowed
+setNegative(-2); // ✅ Allowed
+
+// @ts-expect-error
+setNegative(0);
+
+// @ts-expect-error
+setNegative(1);
+```
+*/
+type LessThan<A extends number, B extends number> = GreaterThanOrEqual<A, B> extends infer Result ? Result extends true ? false : true : never;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/internal/tuple.d.ts
+// Should never happen
 /**
- * Constructs a type representing all possible dot-separated paths within an object.
- * @template TReference The object type for which to generate paths.
- */
-type Paths<TReference> = Paths$1<TReference, {
-  maxRecursionDepth: 10;
-  bracketNotation: true;
-  leavesOnly: false;
-}> | (string & {});
+Returns the maximum value from a tuple of integers.
+
+Note:
+- Float numbers are not supported.
+
+@example
+```
+type A = TupleMax<[1, 2, 5, 3]>;
+//=> 5
+
+type B = TupleMax<[1, 2, 5, 3, 99, -1]>;
+//=> 99
+```
+*/
+type TupleMax<A extends number[], Result extends number = NegativeInfinity> = number extends A[number] ? never : A extends [infer F extends number, ...infer R extends number[]] ? GreaterThan<F, Result> extends true ? TupleMax<R, F> : TupleMax<R, Result> : Result;
 //#endregion
-//#region src/types/not-form.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/partial-deep.d.ts
 /**
- * Configuration options for initializing a new form instance.
- * @template TSchema The validation schema type derived from ObjectSchema.
- */
-type UseNotFormOptions<TSchema extends ObjectSchema> = {
-  /** Unique form identifier (autogenerated if omitted) */
-  id?: string;
-  /** The validation schema used to parse and validate form data */
-  schema: MaybeRefOrGetter<TSchema>;
-  /** Initial form data values */
-  initialState?: DeepPartial<StandardSchemaV1.InferInput<TSchema>>;
-  /** List of validation issues to display initially */
-  initialErrors?: StandardSchemaV1.Issue[];
-  /** Validation behavioral strategy (lazy or eager) */
-  mode?: ValidationMode;
-  /** Events that trigger individual field validation */
-  validateOn?: ValidationTriggers[];
-  /**
-   * Custom validation logic that runs after schema validation.
-   * @param data The validated data from the schema.
-   * @returns Success boolean, issues array, or void.
-   */
-  onValidate?: (data: StandardSchemaV1.InferOutput<TSchema>) => boolean | void | StandardSchemaV1.Issue[] | Promise<boolean | void | StandardSchemaV1.Issue[]>;
-  /** Callback triggered when the form is reset */
-  onReset?: () => void;
+@see {@link PartialDeep}
+*/
+type PartialDeepOptions = {
   /**
-   * Callback triggered when form validation fails.
-   * @param errors The list of identified issues.
-   */
-  onError?: (errors: StandardSchemaV1.Issue[]) => void;
+  Whether to affect the individual elements of arrays and tuples.
+  	@default false
+  */
+  readonly recurseIntoArrays?: boolean;
   /**
-   * Callback triggered when form validation passes and form is submitted.
-   * @param data The validated data from the schema.
-   */
-  onSubmit?: (data: StandardSchemaV1.InferOutput<TSchema>) => void | Promise<void>;
+  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 false
+  	@example
+  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: true}>;
+  	partialSettings.languages = [undefined]; // OK
+  ```
+  */
+  readonly allowUndefinedInNonTupleArrays?: boolean;
 };
-/**
- * The core state and methods provided by a form instance.
- * @template TSchema The validation schema type derived from ObjectSchema.
- */
-type NotFormContext<TSchema extends ObjectSchema> = {
-  /** Unique form identifier */
-  id: string;
-  /** Deeply reactive object of field values */
-  state: Ref<StandardSchemaV1.InferInput<TSchema>>;
-  /**
-   * Updates the form state.
-   * @param _state The new state to apply.
-   * @param _validate Re-validate after update (default: true).
-   */
-  setState: (_state: DeepPartial<StandardSchemaV1.InferInput<TSchema>>, _validate?: boolean) => void;
-  /** Baseline form data at moment of initialization */
-  initialState: StandardSchemaV1.InferInput<TSchema>;
-  /** Reactive array of active validation issues */
-  errors: Ref<StandardSchemaV1.Issue[]>;
-  /**
-   * Directly sets the form errors.
-   * @param _errors The issues to apply.
-   */
-  setErrors: (_errors: StandardSchemaV1.Issue[]) => void;
-  /** Removes all active validation issues */
-  clearErrors: () => void;
-  /**
-   * Retrieves validation issues for a specific field.
-   * @param field The path to the field.
-   * @returns Array of issues for that field.
-   */
-  getFieldErrors: (field: Paths<StandardSchemaV1.InferInput<TSchema>>) => StandardSchemaV1.Issue[];
-  /** List of issues provided during initialization */
-  initialErrors: StandardSchemaV1.Issue[];
-  /** Computed reference to the active validation schema */
-  schema: ComputedRef<TSchema>;
-  /** Strategy for how/when validation occurs */
-  mode: ValidationMode;
-  /** Interaction events configured to trigger validation */
-  validateOn: ValidationTriggers[];
-  /**
-   * Validates entire form.
-   * @returns Promise resolving to validation results.
-   */
-  validate: () => Promise<StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;
-  /**
-   * Validates a single specified field.
-   * @param field The path to the field.
-   * @returns Promise resolving to validation results.
-   */
-  validateField: (field: Paths<StandardSchemaV1.InferInput<TSchema>>) => Promise<StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;
-  /**
-   * Reverts state and errors to initial or custom baseline.
-   * @param _state Optional partial state baseline.
-   * @param _errors Optional issues list baseline.
-   * @param _validate Re-validate after resetting (default: false).
-   */
-  reset: (_state?: DeepPartial<StandardSchemaV1.InferInput<TSchema>>, _errors?: StandardSchemaV1.Issue[], _validate?: boolean) => void;
-  /** Reactive status of async validation process */
-  isValidating: Ref<boolean>;
-  /** Reactive status of form submission */
-  isSubmitting: Ref<boolean>;
-  /** Computed status of form validity */
-  isValid: ComputedRef<boolean>;
-  /** Computed status of field interactions */
-  isTouched: ComputedRef<boolean>;
-  /**
-   * Marks a field as interacted with.
-   * @param field The path to the field.
-   */
-  touchField: (field: Paths<StandardSchemaV1.InferInput<TSchema>>) => void;
-  /** Marks all fields in the form as touched */
-  touchAllFields: () => void;
-  /** Reactive set of touched field paths */
-  touchedFields: Ref<Set<Paths<StandardSchemaV1.InferInput<TSchema>>>>;
-  /** Computed status of form modifications */
-  isDirty: ComputedRef<boolean>;
-  /** Reactive set of dirty field paths */
-  dirtyFields: Ref<Set<Paths<StandardSchemaV1.InferInput<TSchema>>>>;
-  /**
-   * Programmatically marks a field as dirty.
-   * @param field The path to the field.
-   */
-  dirtyField: (field: Paths<StandardSchemaV1.InferInput<TSchema>>) => void;
-  /** Marks all fields in the form as dirty */
-  dirtyAllFields: () => void;
-  /**
-   * Validates and then triggers form submission.
-   * @param event The original form submission event.
-   */
-  submit: (event: Event) => Promise<void>;
+type DefaultPartialDeepOptions = {
+  recurseIntoArrays: false;
+  allowUndefinedInNonTupleArrays: false;
 };
 /**
- * Properties accepted by the NotForm component.
- * @template TSchema The validation schema type derived from ObjectSchema.
- */
-type NotFormProps<TSchema extends ObjectSchema> = Pick<NotFormContext<TSchema>, 'id'> & {
-  /** Render `NotForm` as it nearest child - use to make it renderless and override `as` option */
-  asChild?: boolean;
-  /** HTML Tag `NotForm` should render as - default is `form`. */
-  as?: string;
+Create a type from another type with all keys and nested keys set to optional.
+
+Use-cases:
+- Merging a default settings/config object with another object, the second object would be a deep partial of the default object.
+- Mocking and testing complex entities, where populating an entire object with its keys would be redundant in terms of the mock or test.
+
+@example
+```
+import type {PartialDeep} from 'type-fest';
+
+let settings = {
+	textEditor: {
+		fontSize: 14,
+		fontColor: '#000000',
+		fontWeight: 400,
+	},
+	autocomplete: false,
+	autosave: true,
 };
-/**
- * Slots provided by the NotForm component.
- * @template TSchema The validation schema type derived from ObjectSchema.
- */
-type NotFormSlots<TSchema extends ObjectSchema> = {
-  /** The default slot receives the form context as its scope */
-  default: (props: NotFormContext<TSchema> & {
-    attributes?: ReturnType<typeof useAttrs>;
-  }) => VNodeChild;
+
+const applySavedSettings = (savedSettings: PartialDeep<typeof settings>) => (
+	{...settings, ...savedSettings, textEditor: {...settings.textEditor, ...savedSettings.textEditor}}
+);
+
+settings = applySavedSettings({textEditor: {fontWeight: 500}});
+```
+
+By default, this does not affect elements in array and tuple types. You can change this by passing `{recurseIntoArrays: true}` as the second type argument:
+
+```
+import type {PartialDeep} from 'type-fest';
+
+type Shape = {
+	dimensions: [number, number];
+};
+
+const partialShape: PartialDeep<Shape, {recurseIntoArrays: true}> = {
+	dimensions: [], // OK
 };
+
+partialShape.dimensions = [15]; // OK
+```
+
+@see {@link PartialDeepOptions}
+
+@category Object
+@category Array
+@category Set
+@category Map
+*/
+type PartialDeep<T, Options extends PartialDeepOptions = {}> = _PartialDeep<T, ApplyDefaultOptions<PartialDeepOptions, DefaultPartialDeepOptions, Options>>;
+type _PartialDeep<T, Options extends Required<PartialDeepOptions>> = T extends BuiltIns | ((new (...arguments_: any[]) => unknown)) ? T : T extends Map<infer KeyType, infer ValueType> ? PartialMapDeep<KeyType, ValueType, Options> : T extends Set<infer ItemType> ? PartialSetDeep<ItemType, Options> : T extends ReadonlyMap<infer KeyType, infer ValueType> ? PartialReadonlyMapDeep<KeyType, ValueType, Options> : T extends ReadonlySet<infer ItemType> ? PartialReadonlySetDeep<ItemType, Options> : T extends ((...arguments_: any[]) => unknown) ? IsNever<keyof T> extends true ? T // For functions with no properties
+: HasMultipleCallSignatures<T> extends true ? T : ((...arguments_: Parameters<T>) => ReturnType<T>) & PartialObjectDeep<T, Options> : T extends object ? T extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
+? Options['recurseIntoArrays'] extends true ? ItemType[] extends T // Test for arrays (non-tuples) specifically
+? readonly ItemType[] extends T // Differentiate readonly and mutable arrays
+? ReadonlyArray<_PartialDeep<Options['allowUndefinedInNonTupleArrays'] extends false ? ItemType : ItemType | undefined, Options>> : Array<_PartialDeep<Options['allowUndefinedInNonTupleArrays'] extends false ? ItemType : ItemType | undefined, Options>> : PartialObjectDeep<T, Options> // Tuples behave properly
+: T // If they don't opt into array testing, just use the original type
+: PartialObjectDeep<T, Options> : unknown;
 /**
- * Expected return type for the useNotForm composable.
- * @template TSchema The validation schema type derived from ObjectSchema.
- */
-type UseNotFormReturn<TSchema extends ObjectSchema> = NotFormContext<TSchema>;
+Same as `PartialDeep`, but accepts only `Map`s and as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialMapDeep<KeyType, ValueType, Options extends Required<PartialDeepOptions>> = {} & Map<_PartialDeep<KeyType, Options>, _PartialDeep<ValueType, Options>>;
+/**
+Same as `PartialDeep`, but accepts only `Set`s as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialSetDeep<T, Options extends Required<PartialDeepOptions>> = {} & Set<_PartialDeep<T, Options>>;
+/**
+Same as `PartialDeep`, but accepts only `ReadonlyMap`s as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialReadonlyMapDeep<KeyType, ValueType, Options extends Required<PartialDeepOptions>> = {} & ReadonlyMap<_PartialDeep<KeyType, Options>, _PartialDeep<ValueType, Options>>;
+/**
+Same as `PartialDeep`, but accepts only `ReadonlySet`s as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialReadonlySetDeep<T, Options extends Required<PartialDeepOptions>> = {} & ReadonlySet<_PartialDeep<T, Options>>;
+/**
+Same as `PartialDeep`, but accepts only `object`s as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialObjectDeep<ObjectType extends object, Options extends Required<PartialDeepOptions>> = { [KeyType in keyof ObjectType]?: _PartialDeep<ObjectType[KeyType], Options> };
 //#endregion
-//#region src/types/not-field.d.ts
-/** Configuration properties for the NotField component */
-type NotFieldProps = {
-  /** The unique name/path identifying the field within the form state */
-  name: string;
-};
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/subtract.d.ts
 /**
- * State and methods provided to the NotField component's scope.
- */
-type NotFieldContext = {
-  /** The name/path of the field */
-  name: string;
-  /** Array of validation error messages currently active for this field */
-  errors: string[];
-  /** Indicates if the field has been interacted with (focus lost) */
-  isTouched: boolean;
-  /** Indicates if the field's current value differs from its initial value */
-  isDirty: boolean;
-  /** Indicates if the field currently passes all validation rules */
-  isValid: boolean;
+Returns the difference between two numbers.
+
+Note:
+- A or B can only support `-999` ~ `999`.
+
+@example
+```
+import type {Subtract, PositiveInfinity} from 'type-fest';
+
+type A = Subtract<333, 222>;
+//=> 111
+
+type B = Subtract<111, -222>;
+//=> 333
+
+type C = Subtract<-111, 222>;
+//=> -333
+
+type D = Subtract<18, 96>;
+//=> -78
+
+type E = Subtract<PositiveInfinity, 9999>;
+//=> Infinity
+
+type F = Subtract<PositiveInfinity, PositiveInfinity>;
+//=> number
+```
+
+@category Numeric
+*/
+// TODO: Support big integer.
+type Subtract<A extends number, B extends number> = // Handle cases when A or B is the actual "number" type
+number extends A | B ? number // Handle cases when A and B are both +/- infinity
+: A extends B & (PositiveInfinity | NegativeInfinity) ? number // Handle cases when A is - infinity or B is + infinity
+: A extends NegativeInfinity ? NegativeInfinity : B extends PositiveInfinity ? NegativeInfinity // Handle cases when A is + infinity or B is - infinity
+: A extends PositiveInfinity ? PositiveInfinity : B extends NegativeInfinity ? PositiveInfinity // Handle case when numbers are equal to each other
+: A extends B ? 0 // Handle cases when A or B is 0
+: A extends 0 ? ReverseSign<B> : B extends 0 ? A // Handle remaining regular cases
+: SubtractPostChecks<A, B>;
+/**
+Subtracts two numbers A and B, such that they are not equal and neither of them are 0, +/- infinity or the `number` type
+*/
+type SubtractPostChecks<A extends number, B extends number, AreNegative = [IsNegative<A>, IsNegative<B>]> = AreNegative extends [false, false] ? SubtractPositives<A, B> : AreNegative extends [true, true] // When both numbers are negative we subtract the absolute values and then reverse the sign
+? ReverseSign<SubtractPositives<NumberAbsolute<A>, NumberAbsolute<B>>> // When the signs are different we can add the absolute values and then reverse the sign if A < B
+: [...TupleOf<NumberAbsolute<A>>, ...TupleOf<NumberAbsolute<B>>] extends infer R extends unknown[] ? LessThan<A, B> extends true ? ReverseSign<R['length']> : R['length'] : never;
+/**
+Subtracts two positive numbers.
+*/
+type SubtractPositives<A extends number, B extends number> = LessThan<A, B> extends true // When A < B we can reverse the result of B - A
+? ReverseSign<SubtractIfAGreaterThanB<B, A>> : SubtractIfAGreaterThanB<A, B>;
+/**
+Subtracts two positive numbers A and B such that A > B.
+*/
+type SubtractIfAGreaterThanB<A extends number, B extends number> = // This is where we always want to end up and do the actual subtraction
+TupleOf<A> extends [...TupleOf<B>, ...infer R] ? R['length'] : never;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/sum.d.ts
+/**
+Returns the sum of two numbers.
+
+Note:
+- A or B can only support `-999` ~ `999`.
+
+@example
+```
+import type {Sum, PositiveInfinity, NegativeInfinity} from 'type-fest';
+
+type A = Sum<111, 222>;
+//=> 333
+
+type B = Sum<-111, 222>;
+//=> 111
+
+type C = Sum<111, -222>;
+//=> -111
+
+type D = Sum<PositiveInfinity, -9999>;
+//=> Infinity
+
+type E = Sum<PositiveInfinity, NegativeInfinity>;
+//=> number
+```
+
+@category Numeric
+*/
+// TODO: Support big integer.
+type Sum<A extends number, B extends number> = // Handle cases when A or B is the actual "number" type
+number extends A | B ? number // Handle cases when A and B are both +/- infinity
+: A extends B & (PositiveInfinity | NegativeInfinity) ? A // A or B could be used here as they are equal
+// Handle cases when A and B are opposite infinities
+: A | B extends PositiveInfinity | NegativeInfinity ? number // Handle cases when A is +/- infinity
+: A extends PositiveInfinity | NegativeInfinity ? A // Handle cases when B is +/- infinity
+: B extends PositiveInfinity | NegativeInfinity ? B // Handle cases when A or B is 0 or it's the same number with different signs
+: A extends 0 ? B : B extends 0 ? A : A extends ReverseSign<B> ? 0 // Handle remaining regular cases
+: SumPostChecks<A, B>;
+/**
+Adds two numbers A and B, such that they are not equal with different signs and neither of them are 0, +/- infinity or the `number` type
+*/
+type SumPostChecks<A extends number, B extends number, AreNegative = [IsNegative<A>, IsNegative<B>]> = AreNegative extends [false, false] // When both numbers are positive we can add them together
+? SumPositives<A, B> : AreNegative extends [true, true] // When both numbers are negative we add the absolute values and then reverse the sign
+? ReverseSign<SumPositives<NumberAbsolute<A>, NumberAbsolute<B>>> // When the signs are different we can subtract the absolute values, remove the sign
+// and then reverse the sign if the larger absolute value is negative
+: NumberAbsolute<Subtract<NumberAbsolute<A>, NumberAbsolute<B>>> extends infer Result extends number ? TupleMax<[NumberAbsolute<A>, NumberAbsolute<B>]> extends infer Max_ extends number ? Max_ extends A | B // The larger absolute value is positive, so the result is positive
+? Result // The larger absolute value is negative, so the result is negative
+: ReverseSign<Result> : never : never;
+/**
+Adds two positive numbers.
+*/
+type SumPositives<A extends number, B extends number> = [...TupleOf<A>, ...TupleOf<B>]['length'] extends infer Result extends number ? Result : never;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/paths.d.ts
+/**
+Paths options.
+
+@see {@link Paths}
+*/
+type PathsOptions = {
+  /**
+  The maximum depth to recurse when searching for paths. Range: 0 ~ 10.
+  	@default 5
+  */
+  maxRecursionDepth?: number;
+  /**
+  Use bracket notation for array indices and numeric object keys.
+  	@default false
+  	@example
+  ```
+  import type {Paths} from 'type-fest';
+  	type ArrayExample = {
+  	array: ['foo'];
+  };
+  	type A = Paths<ArrayExample, {bracketNotation: false}>;
+  //=> 'array' | 'array.0'
+  	type B = Paths<ArrayExample, {bracketNotation: true}>;
+  //=> 'array' | 'array[0]'
+  ```
+  	@example
+  ```
+  import type {Paths} from 'type-fest';
+  	type NumberKeyExample = {
+  	1: ['foo'];
+  };
+  	type A = Paths<NumberKeyExample, {bracketNotation: false}>;
+  //=> 1 | '1' | '1.0'
+  	type B = Paths<NumberKeyExample, {bracketNotation: true}>;
+  //=> '[1]' | '[1][0]'
+  ```
+  */
+  bracketNotation?: boolean;
   /**
-   * Triggers a manual validation check for only this field.
-   * @returns Resolve with the validation result object.
-   */
-  validate: () => Promise<StandardSchemaV1.Result<ObjectSchema>>;
-  /** Collection of event handlers for common field interactions. */
-  methods: {
-    /** Logic to execute when the field loses focus */
-    onBlur: () => void;
-    /** Logic to execute when the field's value is committed */
-    onChange: () => void;
-    /** Logic to execute when the field receives user input */
-    onInput: () => void;
-    /** Logic to execute when the field gains focus */
-    onFocus: () => void;
+  Only include leaf paths in the output.
+  	@default false
+  	@example
+  ```
+  import type {Paths} from 'type-fest';
+  	type Post = {
+  	id: number;
+  	author: {
+  		id: number;
+  		name: {
+  			first: string;
+  			last: string;
+  		};
+  	};
   };
+  	type AllPaths = Paths<Post, {leavesOnly: false}>;
+  //=> 'id' | 'author' | 'author.id' | 'author.name' | 'author.name.first' | 'author.name.last'
+  	type LeafPaths = Paths<Post, {leavesOnly: true}>;
+  //=> 'id' | 'author.id' | 'author.name.first' | 'author.name.last'
+  ```
+  	@example
+  ```
+  import type {Paths} from 'type-fest';
+  	type ArrayExample = {
+  	array: Array<{foo: string}>;
+  	tuple: [string, {bar: string}];
+  };
+  	type AllPaths = Paths<ArrayExample, {leavesOnly: false}>;
+  //=> 'array' | 'tuple' | `array.${number}` | `array.${number}.foo` | 'tuple.0' | 'tuple.1' | 'tuple.1.bar'
+  	type LeafPaths = Paths<ArrayExample, {leavesOnly: true}>;
+  //=> `array.${number}.foo` | 'tuple.0' | 'tuple.1.bar'
+  ```
+  */
+  leavesOnly?: boolean;
+  /**
+  Only include paths at the specified depth. By default all paths up to {@link PathsOptions.maxRecursionDepth | `maxRecursionDepth`} are included.
+  	Note: Depth starts at `0` for root properties.
+  	@default number
+  	@example
+  ```
+  import type {Paths} from 'type-fest';
+  	type Post = {
+  	id: number;
+  	author: {
+  		id: number;
+  		name: {
+  			first: string;
+  			last: string;
+  		};
+  	};
+  };
+  	type DepthZero = Paths<Post, {depth: 0}>;
+  //=> 'id' | 'author'
+  	type DepthOne = Paths<Post, {depth: 1}>;
+  //=> 'author.id' | 'author.name'
+  	type DepthTwo = Paths<Post, {depth: 2}>;
+  //=> 'author.name.first' | 'author.name.last'
+  	type LeavesAtDepthOne = Paths<Post, {leavesOnly: true; depth: 1}>;
+  //=> 'author.id'
+  ```
+  */
+  depth?: number;
+};
+type DefaultPathsOptions = {
+  maxRecursionDepth: 5;
+  bracketNotation: false;
+  leavesOnly: false;
+  depth: number;
 };
 /**
- * Slots provided by the NotField component.
- */
-type NotFieldSlots = {
-  /** The default slot receives the field context for use within templates */
-  default: (props: NotFieldContext) => VNodeChild;
+Generate a union of all possible paths to properties in the given object.
+
+It also works with arrays.
+
+Use-case: You want a type-safe way to access deeply nested properties in an object.
+
+@example
+```
+import type {Paths} from 'type-fest';
+
+type Project = {
+	filename: string;
+	listA: string[];
+	listB: [{filename: string}];
+	folder: {
+		subfolder: {
+			filename: string;
+		};
+	};
 };
+
+type ProjectPaths = Paths<Project>;
+//=> 'filename' | 'listA' | 'listB' | 'folder' | `listA.${number}` | 'listB.0' | 'listB.0.filename' | 'folder.subfolder' | 'folder.subfolder.filename'
+
+declare function open<Path extends ProjectPaths>(path: Path): void;
+
+open('filename'); // Pass
+open('folder.subfolder'); // Pass
+open('folder.subfolder.filename'); // Pass
+// @ts-expect-error
+open('foo'); // TypeError
+
+// Also works with arrays
+open('listA.1'); // Pass
+open('listB.0'); // Pass
+// @ts-expect-error
+open('listB.1'); // TypeError. Because listB only has one element.
+```
+
+@category Object
+@category Array
+*/
+type Paths$1<T, Options extends PathsOptions = {}> = _Paths<T, ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, Options>>;
+type _Paths<T, Options extends Required<PathsOptions>, CurrentDepth extends number = 0> = T extends NonRecursiveType | Exclude<MapsSetsOrArrays, UnknownArray> ? never : IsAny<T> extends true ? never : T extends object ? InternalPaths<Required<T>, Options, CurrentDepth> : never;
+type InternalPaths<T, Options extends Required<PathsOptions>, CurrentDepth extends number> = { [Key in keyof T]: Key extends string | number // Limit `Key` to `string | number`
+? (And<Options['bracketNotation'], IsNumberLike<Key>> extends true ? `[${Key}]` : CurrentDepth extends 0 // Return both `Key` and `ToString<Key>` because for number keys, like `1`, both `1` and `'1'` are valid keys.
+? Key | ToString<Key> : `.${(Key | ToString<Key>)}`) extends infer TransformedKey extends string | number ? ((Options['leavesOnly'] extends true ? Options['maxRecursionDepth'] extends CurrentDepth ? TransformedKey : IsNever<T[Key]> extends true ? TransformedKey : T[Key] extends infer Value // For distributing `T[Key]`
+? (Value extends readonly [] | NonRecursiveType | Exclude<MapsSetsOrArrays, UnknownArray> ? TransformedKey : IsNever<keyof Value> extends true // Check for empty object & `unknown`, because `keyof unknown` is `never`.
+? TransformedKey : never) : never // Should never happen
+: TransformedKey) extends infer _TransformedKey // If `depth` is provided, the condition becomes truthy only when it matches `CurrentDepth`.
+// Otherwise, since `depth` defaults to `number`, the condition is always truthy, returning paths at all depths.
+? CurrentDepth extends Options['depth'] ? _TransformedKey : never : never) // Recursively generate paths for the current key
+| (GreaterThan<Options['maxRecursionDepth'], CurrentDepth> extends true // Limit the depth to prevent infinite recursion
+? `${TransformedKey}${_Paths<T[Key], Options, Sum<CurrentDepth, 1>> & (string | number)}` : never) : never : never }[keyof T & (T extends UnknownArray ? number : unknown)];
 //#endregion
-//#region src/types/not-message.d.ts
+//#region src/types/shared.d.ts
 /**
- * Configuration properties for the NotMessage component.
- * @template TSchema The validation schema type derived from ObjectSchema.
+ * Validation execution strategy.
+ * - `lazy`: Validates on blur or submission.
+ * - `eager`: Validates on blur, then on every change if an error exists.
  */
-type NotMessageProps = {
-  /** The name/path of the field whose error message should be displayed */
-  name: string;
-  /** HTML Tag `NotMessage` should render as - default is `span`. */
-  as?: string;
+type ValidationMode = 'lazy' | 'eager';
+/** Interaction events that can trigger a validation check for a field. */
+type ValidationTriggers = {
+  /** Trigger validation when the field is blurred. */onBlur?: boolean; /** Trigger validation when the field value changes. */
+  onChange?: boolean; /** Trigger validation when the field value is input. */
+  onInput?: boolean; /** Trigger validation when the field is mounted. */
+  onMount?: boolean; /** Trigger validation when the field is focused. */
+  onFocus?: boolean;
 };
 /**
- * State provided to the NotMessage component's scope.
+ * Constructs a type where all properties of the input type are optional recursively.
+ * @template TData The base data structure to transform.
  */
-type NotMessageContext = {
-  /** The first active validation error message for the specified field */
-  message: NotFieldContext['errors'][number];
-};
+type DeepPartial<TData> = PartialDeep<TData, {
+  recurseIntoArrays: true;
+  allowUndefinedInNonTupleArrays: true;
+}>;
 /**
- * Slots provided by the NotMessage component.
+ * Constructs a type representing all possible dot-separated paths within an object.
+ * @template TReference The object type for which to generate paths.
  */
-type NotMessageSlots = {
-  /** The default slot receives the error message context for custom rendering */
-  default: (props: NotMessageContext & {
-    attributes?: ReturnType<typeof useAttrs>;
-  }) => VNodeChild;
-};
-//#endregion
-//#region src/components/not-form.vue.d.ts
-declare const __VLS_export$3: <TSchema extends ObjectSchema>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$2<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-  props: vue0.PublicProps & __VLS_PrettifyLocal$2<NotFormProps<TSchema>> & (typeof globalThis extends {
-    __VLS_PROPS_FALLBACK: infer P;
-  } ? P : {});
-  expose: (exposed: {}) => void;
-  attrs: any;
-  slots: NotFormSlots<TSchema>;
-  emit: {};
-}>) => vue0.VNode & {
-  __ctx?: Awaited<typeof __VLS_setup>;
-};
-declare const _default$2: typeof __VLS_export$3;
-type __VLS_PrettifyLocal$2<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {};
-//#endregion
-//#region src/components/not-field.vue.d.ts
-/**
- * Slots provided by the NotField component.
+type Paths<TReference> = Paths$1<TReference, {
+  maxRecursionDepth: 10;
+  bracketNotation: true;
+  leavesOnly: false;
+}> | (string & {});
+/**
+ * Represents a validation schema for object-based data structures.
+ * Complies with the Standard Schema specification.
  */
-type __VLS_Slots = NotFieldSlots;
-declare const __VLS_base: vue0.DefineComponent<NotFieldProps, {}, {}, {}, {}, vue0.ComponentOptionsMixin, vue0.ComponentOptionsMixin, {}, string, vue0.PublicProps, Readonly<NotFieldProps> & Readonly<{}>, {}, {}, {}, {}, string, vue0.ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export$2: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
-declare const _default$1: typeof __VLS_export$2;
-type __VLS_WithSlots<T, S> = T & {
-  new (): {
-    $slots: S;
+type ObjectSchema = StandardSchemaV1 & {
+  '~standard': StandardSchemaV1['~standard'] & {
+    types?: {
+      input: object;
+    };
   };
 };
-//#endregion
-//#region src/components/not-message.vue.d.ts
-declare const __VLS_export$1: <TSchema extends ObjectSchema>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$1<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-  props: vue0.PublicProps & __VLS_PrettifyLocal$1<NotMessageProps> & (typeof globalThis extends {
-    __VLS_PROPS_FALLBACK: infer P;
-  } ? P : {});
-  expose: (exposed: {}) => void;
-  attrs: any;
-  slots: NotMessageSlots;
-  emit: {};
-}>) => vue0.VNode & {
-  __ctx?: Awaited<typeof __VLS_setup>;
-};
-declare const _default$3: typeof __VLS_export$1;
-type __VLS_PrettifyLocal$1<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {};
-//#endregion
-//#region src/types/not-array-field.d.ts
 /**
- * Properties accepted by the NotArrayField component.
- * @template TSchema The schema of the array field.
+ * Represents a validation schema for array-based data structures.
+ * Complies with the Standard Schema specification.
  */
-type NotArrayFieldProps<TSchema extends ArraySchema> = {
-  /** The unique name/path identifying the array field in the form state */
-  name: string;
-  /** The specific schema instance used to validate the array items */
-  schema: TSchema;
+type ArraySchema = StandardSchemaV1 & {
+  '~standard': StandardSchemaV1['~standard'] & {
+    types?: {
+      input: Array<any>;
+    };
+  };
 };
-/**
- * The core state and methods provided by an NotArrayField instance.
- * @template TSchema The schema of the array field.
- */
-type NotArrayFieldContext<TSchema extends ArraySchema> = {
-  /** The unique name/path identifying the array field in the form state */
-  name: string;
-  /** Array-level validation errors for the field path */
-  errors: string[];
-  /**
-   * Array of individual field contexts for each item in the collection.
-   * Useful for mapping components to array elements.
-   */
-  fields: Array<{
-    /** A unique identifier for the field (defaults to index) */
-    key: string | number;
-    /** The 0-based position of the field within the array */
-    index: number;
-    /** The current value of the field at this index */
-    value: StandardSchemaV1.InferInput<TSchema>[number];
-    /** True if this is first item in the collection */
-    first: boolean;
-    /** True if this is the last item in the collection */
-    last: boolean;
-  }>;
-  /** Adds a new item to the end of the collection */
-  append: (data: StandardSchemaV1.InferInput<TSchema>[number]) => void;
-  /** Adds a new item to the beginning of the collection */
-  prepend: (data: StandardSchemaV1.InferInput<TSchema>[number]) => void;
-  /**
-   * Removes the item at the specified index.
-   * @param index The index to remove.
-   */
-  remove: (index: number) => void;
-  /**
-   * Inserts a new item at a specific position.
-   * @param index The insertion index.
-   * @param data Initial data for the new item.
-   */
-  insert: (index: number, data: StandardSchemaV1.InferInput<TSchema>[number]) => void;
-  /**
-   * Replaces data at a specific index.
-   * @param index The target index.
-   * @param data New data to apply.
-   */
-  update: (index: number, data: StandardSchemaV1.InferInput<TSchema>[number]) => void;
+//#endregion
+//#region src/types/use-not-form.d.ts
+type UseNotFormOptions<TSchema extends ObjectSchema> = {
+  /** The validation schema used to parse and validate form data */schema: MaybeRefOrGetter<TSchema>;
 };
-/**
- * Slots provided by the NotArrayField component.
- * @template TSchema The schema of the array field.
- */
-type NotArrayFieldSlots<TSchema extends ArraySchema> = {
-  /** The default slot receives the array field context as its scope */
-  default: (props: NotArrayFieldContext<TSchema>) => VNodeChild;
-};
-//#endregion
-//#region src/components/not-array-field.vue.d.ts
-declare const __VLS_export: <TArraySchema extends ArraySchema, TObjectSchema extends ObjectSchema = ObjectSchema>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-  props: vue0.PublicProps & __VLS_PrettifyLocal<NotArrayFieldProps<TArraySchema>> & (typeof globalThis extends {
-    __VLS_PROPS_FALLBACK: infer P;
-  } ? P : {});
-  expose: (exposed: {}) => void;
-  attrs: any;
-  slots: NotArrayFieldSlots<TArraySchema>;
-  emit: {};
-}>) => vue0.VNode & {
-  __ctx?: Awaited<typeof __VLS_setup>;
-};
-declare const _default: typeof __VLS_export;
-type __VLS_PrettifyLocal<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {};
-//#endregion
-//#region src/composables/use-not-form.d.ts
-/**
- * Initializes a form instance with validation logic, reactive state, and lifecycle methods.
- * @template TSchema The validation schema type derived from ObjectSchema.
- * @param options Configuration object for the form behavior and initial state.
- * @returns The gathered form context object.
- */
-declare function useNotForm<TSchema extends ObjectSchema>(options: UseNotFormOptions<TSchema>): UseNotFormReturn<TSchema>;
 //#endregion
-export { ArraySchema, DeepPartial, _default as NotArrayField, _default$1 as NotField, NotFieldContext, NotFieldProps, NotFieldSlots, _default$2 as NotForm, NotFormContext, NotFormProps, NotFormSlots, _default$3 as NotMessage, NotMessageContext, NotMessageProps, NotMessageSlots, ObjectSchema, Paths, UseNotFormOptions, UseNotFormReturn, ValidationMode, ValidationTriggers, useNotForm };
+export { ArraySchema, DeepPartial, ObjectSchema, Paths, UseNotFormOptions, ValidationMode, ValidationTriggers };