avo-cli 4.2.0.beta.4 → 4.2.0.beta.5

data/payload/node_modules/ink/node_modules/type-fest/source/rename-keys.d.ts

@@ -0,0 +1,163 @@
+import type {IsLiteral} from './is-literal.d.ts';
+import type {ReadonlyKeysOf} from './readonly-keys-of.d.ts';
+import type {RequiredKeysOf} from './required-keys-of.d.ts';
+import type {OptionalKeysOf} from './optional-keys-of.d.ts';
+import type {OmitIndexSignature} from './omit-index-signature.d.ts';
+import type {SetRequired} from './set-required.d.ts';
+import type {SetReadonly} from './set-readonly.d.ts';
+import type {IfNotAnyOrNever, IsExactOptionalPropertyTypesEnabled} from './internal/type.d.ts';
+
+/**
+Rename keys in an object type according to a map of old-to-new names.
+
+@example
+```
+import type {RenameKeys} from 'type-fest';
+
+type User = {
+	id: string;
+	firstName: string;
+	createdAt: Date;
+};
+
+type Renamed = RenameKeys<User, {firstName: 'first_name'; createdAt: 'created_at'}>;
+//=> {id: string; first_name: string; created_at: Date}
+```
+
+@example
+```
+import type {RenameKeys} from 'type-fest';
+
+type SearchInput = {
+	textQuery: string;
+	voiceQuery: Blob;
+	imageQuery: File;
+};
+
+type Normalized = RenameKeys<SearchInput, {textQuery: 'query'; voiceQuery: 'query'; imageQuery: 'query'}>;
+//=> {query: string | Blob | File}
+```
+
+Note: When multiple source keys map to the same target, the target's value type is the union of the contributors' value types. The target is optional only when every contributor is optional, and is `readonly` when any contributor is `readonly`. With `exactOptionalPropertyTypes` disabled, the value type of a mixed-optionality merge also includes `undefined`.
+
+@example
+```
+import type {RenameKeys} from 'type-fest';
+
+// All colliding keys are required, so the target is required.
+type A = RenameKeys<{a: 1; b: 2}, {a: 'x'; b: 'x'}>;
+//=> {x: 1 | 2}
+
+// All colliding keys are optional, so the target is optional.
+type B = RenameKeys<{a?: 1; b?: 2}, {a: 'x'; b: 'x'}>;
+//=> {x?: 1 | 2}
+
+// One of the colliding keys is required, so the target is required.
+type C = RenameKeys<{a: 1; b?: 2}, {a: 'x'; b: 'x'}>;
+//=> {x: 1 | 2}
+
+// One of the colliding keys is `readonly`, so the target is `readonly`.
+type D = RenameKeys<{readonly a: 1; b: 2}, {a: 'x'; b: 'x'}>;
+//=> {readonly x: 1 | 2}
+```
+
+@example
+```
+// @exactOptionalPropertyTypes: false
+import type {RenameKeys} from 'type-fest';
+
+// With `exactOptionalPropertyTypes` disabled, a mixed-optionality merge includes `undefined`.
+type E = RenameKeys<{a?: 1; b: 2}, {a: 'x'; b: 'x'}>;
+//=> {x: 1 | 2 | undefined}
+```
+
+Note: A union target distributes, producing one output key per member.
+
+@example
+```
+import type {RenameKeys} from 'type-fest';
+
+type A = RenameKeys<{a: string}, {a: 'b' | 'c'}>;
+//=> {b: string; c: string}
+```
+
+Note: An entry whose value is not a literal `PropertyKey` (such as `string`) is also ignored, leaving that key's name unchanged.
+
+@example
+```
+import type {RenameKeys} from 'type-fest';
+
+type A = RenameKeys<{a: 1}, {a: string}>;
+//=> {a: 1}
+
+type B = RenameKeys<{a: 1; b: 2}, {a: 'x'; b: symbol}>;
+//=> {x: 1; b: 2}
+```
+
+Note: A rename map entry whose key is not a property of the source type is ignored.
+
+@example
+```
+import type {RenameKeys} from 'type-fest';
+
+type A = RenameKeys<{a: 1; b: 2}, {a: 'x'; c: 'y'}>;
+//=> {x: 1; b: 2}
+```
+
+@category Object
+*/
+export type RenameKeys<
+	BaseType extends object,
+	RenameMap extends Record<PropertyKey, PropertyKey>,
+> = IfNotAnyOrNever<BaseType, {
+	ifNot: BaseType extends unknown // For distributing `BaseType`
+		? RenameMap extends unknown // For distributing `RenameMap`
+			? RenameOnce<BaseType, NormalizeMap<RenameMap>>
+			: never
+		: never;
+}>;
+
+type RenameOnce<BaseType extends object, RenameMap extends Record<PropertyKey, PropertyKey>> =
+	RestoreMergedUndefined<BaseType, RenameMap,
+		ApplyReadonly<BaseType, RenameMap,
+			ApplyRequired<BaseType, RenameMap,
+				RenameNaive<BaseType, RenameMap>>>>;
+
+type RenameNaive<BaseType extends object, RenameMap extends Record<PropertyKey, PropertyKey>> = {
+	// Two keys mapping to one target produce a union value and keep only the first key's modifiers.
+	// Like for example, `{a?: 1; b: 2}` with `{a: 'x'; b: 'x'}` produces `{x?: 1 | 2}`, taking `a`'s optional.
+	[Key in keyof BaseType as TargetOf<Key, RenameMap>]: Required<BaseType>[Key];
+};
+
+// A merged target kept only one modifier in `RenameNaive`, so re-force these from every contributor.
+type ApplyRequired<BaseType extends object, RenameMap extends Record<PropertyKey, PropertyKey>, Renamed> =
+	SetRequired<Renamed, TargetOf<RequiredKeysOf<OmitIndexSignature<BaseType>>, RenameMap> & keyof Renamed>;
+
+type ApplyReadonly<BaseType extends object, RenameMap extends Record<PropertyKey, PropertyKey>, Renamed> =
+	SetReadonly<Renamed, TargetOf<ReadonlyKeysOf<OmitIndexSignature<BaseType>>, RenameMap> & keyof Renamed>;
+
+// `exactOptionalPropertyTypes` off keeps `undefined` on a target that merged a required and an optional source.
+// Source `{a?: 1; x: 2}` with `{a: 'x'}` gives `{x: 1 | 2 | undefined}`.
+type RestoreMergedUndefined<BaseType extends object, RenameMap extends Record<PropertyKey, PropertyKey>, Result> =
+	IsExactOptionalPropertyTypesEnabled extends true
+		? Result
+		: {
+			[Key in keyof Result]: Key extends MergedTargets<BaseType, RenameMap>
+				? Result[Key] | undefined
+				: Result[Key];
+		};
+
+type MergedTargets<BaseType extends object, RenameMap extends Record<PropertyKey, PropertyKey>> =
+	// Targets renamed from both a required and an optional key prefer the required modifier.
+	// Required `b` and optional `a` both rename to `x` in `{a?: 1; b: 2}` with `{a: 'x'; b: 'x'}`.
+	TargetOf<RequiredKeysOf<OmitIndexSignature<BaseType>>, RenameMap>
+	& TargetOf<OptionalKeysOf<OmitIndexSignature<BaseType>>, RenameMap>;
+
+type NormalizeMap<RenameMap extends Record<PropertyKey, PropertyKey>> = {
+	-readonly [Key in keyof RenameMap as true extends IsLiteral<RenameMap[Key]> ? Key : never]-?: RenameMap[Key];
+};
+
+type TargetOf<SourceKey extends PropertyKey, RenameMap extends Record<PropertyKey, PropertyKey>> =
+	SourceKey extends keyof RenameMap ? RenameMap[SourceKey] : SourceKey;
+
+export {};

data/payload/node_modules/ink/node_modules/type-fest/source/replace.d.ts

@@ -0,0 +1,87 @@
+import type {ApplyDefaultOptions} from './internal/index.d.ts';
+
+export type ReplaceOptions = {
+	all?: boolean;
+};
+
+type DefaultReplaceOptions = {
+	all: false;
+};
+
+/**
+Represents a string with some or all matches replaced by a replacement.
+
+Use-case:
+- `kebab-case-path` to `dotted.path.notation`
+- Changing date/time format: `01-08-2042` → `01/08/2042`
+- Manipulation of type properties, for example, removal of prefixes
+
+@example
+```
+import type {Replace} from 'type-fest';
+
+declare function replace<
+	Input extends string,
+	Search extends string,
+	Replacement extends string,
+>(
+	input: Input,
+	search: Search,
+	replacement: Replacement,
+): Replace<Input, Search, Replacement>;
+
+declare function replaceAll<
+	Input extends string,
+	Search extends string,
+	Replacement extends string,
+>(
+	input: Input,
+	search: Search,
+	replacement: Replacement,
+): Replace<Input, Search, Replacement, {all: true}>;
+
+// The return type is the exact string literal, not just `string`.
+
+replace('hello ?', '?', '🦄');
+//=> 'hello 🦄'
+
+replace('hello ??', '?', '❓');
+//=> 'hello ❓?'
+
+replaceAll('10:42:00', ':', '-');
+//=> '10-42-00'
+
+replaceAll('__userName__', '__', '');
+//=> 'userName'
+
+replaceAll('My Cool Title', ' ', '');
+//=> 'MyCoolTitle'
+```
+
+@category String
+@category Template literal
+*/
+export type Replace<
+	Input extends string,
+	Search extends string,
+	Replacement extends string,
+	Options extends ReplaceOptions = {},
+> = _Replace<Input, Search, Replacement, ApplyDefaultOptions<ReplaceOptions, DefaultReplaceOptions, Options>>;
+
+type _Replace<
+	Input extends string,
+	Search extends string,
+	Replacement extends string,
+	Options extends Required<ReplaceOptions>,
+	Accumulator extends string = '',
+> = Search extends string // For distributing `Search`
+	? Replacement extends string // For distributing `Replacement`
+		? Input extends `${infer Head}${Search}${infer Tail}`
+			? Options['all'] extends true
+				? _Replace<Tail, Search, Replacement, Options, `${Accumulator}${Head}${Replacement}`>
+				: `${Head}${Replacement}${Tail}`
+			: `${Accumulator}${Input}`
+		: never
+	: never;
+
+export {};

data/payload/node_modules/ink/node_modules/type-fest/source/require-all-or-none.d.ts

@@ -0,0 +1,54 @@
+import type {If} from './if.d.ts';
+import type {IfNotAnyOrNever, RequireNone} from './internal/index.d.ts';
+import type {IsAny} from './is-any.d.ts';
+import type {IsNever} from './is-never.d.ts';
+
+/**
+Requires all of the keys in the given object.
+*/
+type RequireAll<ObjectType, KeysType extends keyof ObjectType> = Required<Pick<ObjectType, KeysType>>;
+
+/**
+Create a type that requires all of the given keys or none of the given keys, while keeping the remaining keys as is.
+
+Use-cases:
+- Creating interfaces for components with mutually-inclusive keys.
+
+The caveat with `RequireAllOrNone` is that TypeScript doesn't always know at compile time every key that will exist at runtime. Therefore `RequireAllOrNone` can't do anything to prevent extra keys it doesn't know about.
+
+@example
+```
+import type {RequireAllOrNone} from 'type-fest';
+
+type Responder = {
+	text?: () => string;
+	json?: () => string;
+	secure: boolean;
+};
+
+const responder1: RequireAllOrNone<Responder, 'text' | 'json'> = {
+	secure: true,
+};
+
+const responder2: RequireAllOrNone<Responder, 'text' | 'json'> = {
+	text: () => '{"message": "hi"}',
+	json: () => '{"message": "ok"}',
+	secure: true,
+};
+```
+
+@category Object
+*/
+export type RequireAllOrNone<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> =
+	IfNotAnyOrNever<ObjectType, {
+		ifNot: If<IsNever<KeysType>,
+			ObjectType,
+			_RequireAllOrNone<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>>;
+	}>;
+
+type _RequireAllOrNone<ObjectType, KeysType extends keyof ObjectType> = (
+	| RequireAll<ObjectType, KeysType>
+	| RequireNone<KeysType>
+) & Omit<ObjectType, KeysType>; // The rest of the keys.
+
+export {};

data/payload/node_modules/ink/node_modules/type-fest/source/require-at-least-one.d.ts

@@ -0,0 +1,48 @@
+import type {Except} from './except.d.ts';
+import type {If} from './if.d.ts';
+import type {IfNotAnyOrNever} from './internal/index.d.ts';
+import type {IsAny} from './is-any.d.ts';
+import type {IsNever} from './is-never.d.ts';
+
+/**
+Create a type that requires at least one of the given keys, while keeping the remaining keys as is.
+
+@example
+```
+import type {RequireAtLeastOne} from 'type-fest';
+
+type Responder = {
+	text?: () => string;
+	json?: () => string;
+	secure?: boolean;
+};
+
+const responder: RequireAtLeastOne<Responder, 'text' | 'json'> = {
+	json: () => '{"message": "ok"}',
+	secure: true,
+};
+```
+
+@category Object
+*/
+export type RequireAtLeastOne<
+	ObjectType,
+	KeysType extends keyof ObjectType = keyof ObjectType,
+> =
+	IfNotAnyOrNever<ObjectType, {
+		ifNot: If<IsNever<KeysType>,
+			never,
+			_RequireAtLeastOne<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>>;
+	}>;
+
+type _RequireAtLeastOne<
+	ObjectType,
+	KeysType extends keyof ObjectType,
+> = {
+	// For each `Key` in `KeysType` make a mapped type:
+	[Key in KeysType]-?: Required<Pick<ObjectType, Key>> // 1. Make `Key`'s type required
+		& Partial<Pick<ObjectType, Exclude<KeysType, Key>>>; // 2. Make all other keys in `KeysType` optional
+}[KeysType]
+& Except<ObjectType, KeysType>; // 3. Add the remaining keys not in `KeysType`
+
+export {};

data/payload/node_modules/ink/node_modules/type-fest/source/require-exactly-one.d.ts

@@ -0,0 +1,48 @@
+import type {If} from './if.d.ts';
+import type {IfNotAnyOrNever} from './internal/index.d.ts';
+import type {IsAny} from './is-any.d.ts';
+import type {IsNever} from './is-never.d.ts';
+
+/**
+Create a type that requires exactly one of the given keys and disallows more, while keeping the remaining keys as is.
+
+Use-cases:
+- Creating interfaces for components that only need one of the keys to display properly.
+- Declaring generic keys in a single place for a single use-case that gets narrowed down via `RequireExactlyOne`.
+
+The caveat with `RequireExactlyOne` is that TypeScript doesn't always know at compile time every key that will exist at runtime. Therefore `RequireExactlyOne` can't do anything to prevent extra keys it doesn't know about.
+
+@example
+```
+import type {RequireExactlyOne} from 'type-fest';
+
+type Responder = {
+	text: () => string;
+	json: () => string;
+	secure: boolean;
+};
+
+const responder: RequireExactlyOne<Responder, 'text' | 'json'> = {
+	// Adding a `text` key here would cause a compile error.
+
+	json: () => '{"message": "ok"}',
+	secure: true,
+};
+```
+
+@category Object
+*/
+export type RequireExactlyOne<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> =
+	IfNotAnyOrNever<ObjectType, {
+		ifNot: If<IsNever<KeysType>,
+			never,
+			_RequireExactlyOne<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>>;
+	}>;
+
+type _RequireExactlyOne<ObjectType, KeysType extends keyof ObjectType> =
+	{[Key in KeysType]: (
+		Required<Pick<ObjectType, Key>>
+		& Partial<Record<Exclude<KeysType, Key>, never>>
+	)}[KeysType] & Omit<ObjectType, KeysType>;
+
+export {};

data/payload/node_modules/ink/node_modules/type-fest/source/require-one-or-none.d.ts

@@ -0,0 +1,49 @@
+import type {RequireExactlyOne} from './require-exactly-one.d.ts';
+import type {IfNotAnyOrNever, RequireNone} from './internal/index.d.ts';
+import type {If} from './if.d.ts';
+import type {IsAny} from './is-any.d.ts';
+import type {IsNever} from './is-never.d.ts';
+
+/**
+Create a type that requires exactly one of the given keys or none of the given keys, while keeping the remaining keys as is.
+
+@example
+```
+import type {RequireOneOrNone} from 'type-fest';
+
+type Responder = RequireOneOrNone<{
+	text: () => string;
+	json: () => string;
+	secure: boolean;
+}, 'text' | 'json'>;
+
+const responder1: Responder = {
+	secure: true,
+};
+
+const responder2: Responder = {
+	text: () => '{"message": "hi"}',
+	secure: true,
+};
+
+const responder3: Responder = {
+	json: () => '{"message": "ok"}',
+	secure: true,
+};
+```
+
+@category Object
+*/
+export type RequireOneOrNone<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> =
+	IfNotAnyOrNever<ObjectType, {
+		ifNot: If<IsNever<KeysType>,
+			ObjectType,
+			_RequireOneOrNone<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>>;
+	}>;
+
+type _RequireOneOrNone<ObjectType, KeysType extends keyof ObjectType> = (
+	| RequireExactlyOne<ObjectType, KeysType>
+	| RequireNone<KeysType>
+) & Omit<ObjectType, KeysType>; // Ignore unspecified keys.
+
+export {};

data/payload/node_modules/ink/node_modules/type-fest/source/required-deep.d.ts

@@ -0,0 +1,78 @@
+import type {BuiltIns, HasMultipleCallSignatures} from './internal/index.d.ts';
+import type {IsNever} from './is-never.d.ts';
+import type {Simplify} from './simplify.d.ts';
+
+/**
+Create a deeply required version of another type.
+
+Use-cases:
+- Creating optional configuration interfaces where the underlying implementation still requires all options to be fully specified.
+- Modeling the resulting type after a deep merge with a set of defaults.
+
+Use [`Required<T>`](https://www.typescriptlang.org/docs/handbook/utility-types.html#requiredtype) if you only need one level deep.
+
+@example
+```
+import type {RequiredDeep} from 'type-fest';
+
+type Settings = {
+	textEditor?: {
+		fontSize?: number;
+		fontColor?: string;
+		fontWeight?: number | undefined;
+	};
+	autocomplete?: boolean;
+	autosave?: boolean | undefined;
+};
+
+type RequiredSettings = RequiredDeep<Settings>;
+//=> {
+// 	textEditor: {
+// 		fontSize: number;
+// 		fontColor: string;
+// 		fontWeight: number | undefined;
+// 	};
+// 	autocomplete: boolean;
+// 	autosave: boolean | undefined;
+// }
+```
+
+Note that types containing overloaded functions are not made deeply required due to a [TypeScript limitation](https://github.com/microsoft/TypeScript/issues/29732).
+
+@category Utilities
+@category Object
+@category Array
+@category Set
+@category Map
+*/
+export type RequiredDeep<T> = T extends BuiltIns
+	? T
+	: T extends Map<infer KeyType, infer ValueType>
+		? Map<RequiredDeep<KeyType>, RequiredDeep<ValueType>>
+		: T extends Set<infer ItemType>
+			? Set<RequiredDeep<ItemType>>
+			: T extends ReadonlyMap<infer KeyType, infer ValueType>
+				? ReadonlyMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>>
+				: T extends ReadonlySet<infer ItemType>
+					? ReadonlySet<RequiredDeep<ItemType>>
+					: T extends WeakMap<infer KeyType, infer ValueType>
+						? WeakMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>>
+						: T extends WeakSet<infer ItemType>
+							? WeakSet<RequiredDeep<ItemType>>
+							: T extends Promise<infer ValueType>
+								? Promise<RequiredDeep<ValueType>>
+								: T extends (...arguments_: any[]) => unknown
+									? IsNever<keyof T> extends true
+										? T
+										: HasMultipleCallSignatures<T> extends true
+											? T
+											: ((...arguments_: Parameters<T>) => ReturnType<T>) & RequiredObjectDeep<T>
+									: T extends object
+										? Simplify<RequiredObjectDeep<T>> // `Simplify` to prevent `RequiredObjectDeep` from appearing in the resulting type
+										: unknown;
+
+type RequiredObjectDeep<ObjectType extends object> = {
+	[KeyType in keyof ObjectType]-?: RequiredDeep<ObjectType[KeyType]>
+};
+
+export {};

data/payload/node_modules/ink/node_modules/type-fest/source/required-keys-of.d.ts

@@ -0,0 +1,38 @@
+import type {OptionalKeysOf} from './optional-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
+*/
+export type RequiredKeysOf<Type extends object> =
+	Type extends unknown // For distributing `Type`
+		? Exclude<keyof Type, OptionalKeysOf<Type>>
+		: never; // Should never happen
+
+export {};

data/payload/node_modules/ink/node_modules/type-fest/source/schema.d.ts

@@ -0,0 +1,127 @@
+import type {ApplyDefaultOptions} from './internal/object.d.ts';
+import type {IfNotAnyOrNever, NonRecursiveType} from './internal/type.d.ts';
+import type {IsAny} from './is-any.d.ts';
+import type {IsUnknown} from './is-unknown.d.ts';
+import type {OptionalKeysOf} from './optional-keys-of.d.ts';
+import type {Simplify} from './simplify.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
+
+/**
+@see {@link Schema}
+*/
+export type SchemaOptions = {
+	/**
+	By default, this affects elements in array and tuple types. You can change this by passing `{recurseIntoArrays: false}` as the third type argument:
+	- If `recurseIntoArrays` is set to `true` (default), array elements will be recursively processed as well.
+	- If `recurseIntoArrays` is set to `false`, arrays will not be recursively processed, and the entire array will be replaced with the given value type.
+
+	@example
+	```
+	import type {Schema} from 'type-fest';
+
+	type Participants = {
+		attendees: string[];
+		speakers: string[];
+	};
+
+	type ParticipantsWithMetadata = Schema<Participants, {id: number; name: string}, {recurseIntoArrays: true}>;
+	//=> {
+	// 	attendees: {
+	// 		id: number;
+	// 		name: string;
+	// 	}[];
+	// 	speakers: {
+	// 		id: number;
+	// 		name: string;
+	// 	}[];
+	// }
+
+	type ParticipantsCount = Schema<Participants, number, {recurseIntoArrays: false}>;
+	//=> {attendees: number; speakers: number}
+	```
+
+	@default true
+	*/
+	recurseIntoArrays?: boolean;
+};
+
+type DefaultSchemaOptions = {
+	recurseIntoArrays: true;
+};
+
+/**
+Create a deep version of another object type where property values are recursively replaced into a given value type.
+
+Use-cases:
+- Form validation: Define how each field should be validated.
+- Form settings: Define configuration for input fields.
+- Parsing: Define types that specify special behavior for specific fields.
+
+@example
+```
+import type {Schema} from 'type-fest';
+
+type User = {
+	id: string;
+	name: {
+		firstname: string;
+		lastname: string;
+	};
+	created: Date;
+	active: boolean;
+	passwordHash: string;
+	location: [latitude: number, longitude: number];
+};
+
+type UserMask = Schema<User, 'mask' | 'hide' | 'show'>;
+
+const userMaskSettings: UserMask = {
+	id: 'show',
+	name: {
+		firstname: 'show',
+		lastname: 'mask',
+	},
+	created: 'show',
+	active: 'show',
+	passwordHash: 'hide',
+	location: ['hide', 'hide'],
+};
+```
+
+@see {@link SchemaOptions}
+
+@category Object
+*/
+export type Schema<Type, Value, Options extends SchemaOptions = {}> =
+	IfNotAnyOrNever<Type, {
+		ifNot: _Schema<Type, Value, ApplyDefaultOptions<SchemaOptions, DefaultSchemaOptions, Options>>;
+		ifAny: Value;
+		ifNever: Value;
+	}>;
+
+type _Schema<Type, Value, Options extends Required<SchemaOptions>> =
+	IsAny<Type> extends true
+		? Value
+		: IsUnknown<Type> extends true
+			? Value
+			: Type extends NonRecursiveType | Map<unknown, unknown> | Set<unknown> | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown>
+				? Value
+				: Type extends UnknownArray
+					? Options['recurseIntoArrays'] extends false
+						? Value
+						: SchemaHelper<Type, Value, Options>
+					: SchemaHelper<Type, Value, Options>;
+
+/**
+Internal helper for {@link _Schema}.
+
+Recursively transforms the value of each property in objects and arrays.
+*/
+type SchemaHelper<Type, Value, Options extends Required<SchemaOptions>> = Simplify<{
+	[Key in keyof Type]: _Schema<
+		Key extends OptionalKeysOf<Type & object> ? Exclude<Type[Key], undefined> : Type[Key], // Remove `| undefined` when accessing optional properties
+		Value,
+		Options>
+}>;
+
+export {};