@eslint-react/shared 1.8.0-beta.2 → 1.8.0-beta.3

package/dist/index.d.mts

@@ -1,7 +1,4 @@
 import { ESLintUtils } from '@typescript-eslint/utils';
-import * as valibot from 'valibot';
-import { InferOutput } from 'valibot';
-import * as micro_memoize from 'micro-memoize';
 
 /**
  * -----------------------------------------------------------------------------
@@ -67,41 +64,1460 @@ declare const HOST_SVG_COMPONENT_TYPES: readonly ["a", "animate", "animateMotion
  */
 declare const createRuleForPlugin: (pluginName: string) => <Options extends readonly unknown[], MessageIds extends string>({ name, meta, ...rule }: Readonly<ESLintUtils.RuleWithMetaAndName<Options, MessageIds, unknown>>) => ESLintUtils.RuleModule<MessageIds, Options, unknown, ESLintUtils.RuleListener>;
 
+/**
+ * Array issue type.
+ */
+interface ArrayIssue extends BaseIssue<unknown> {
+    /**
+     * The issue kind.
+     */
+    readonly kind: 'schema';
+    /**
+     * The issue type.
+     */
+    readonly type: 'array';
+    /**
+     * The expected property.
+     */
+    readonly expected: 'Array';
+}
+
+/**
+ * Array schema type.
+ */
+interface ArraySchema<TItem extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TMessage extends ErrorMessage<ArrayIssue> | undefined> extends BaseSchema<InferInput<TItem>[], InferOutput<TItem>[], ArrayIssue | InferIssue<TItem>> {
+    /**
+     * The schema type.
+     */
+    readonly type: 'array';
+    /**
+     * The schema reference.
+     */
+    readonly reference: typeof array;
+    /**
+     * The expected property.
+     */
+    readonly expects: 'Array';
+    /**
+     * The array item schema.
+     */
+    readonly item: TItem;
+    /**
+     * The error message.
+     */
+    readonly message: TMessage;
+}
+/**
+ * Creates an array schema.
+ *
+ * @param item The item schema.
+ *
+ * @returns An array schema.
+ */
+declare function array<const TItem extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(item: TItem): ArraySchema<TItem, undefined>;
+/**
+ * Creates an array schema.
+ *
+ * @param item The item schema.
+ * @param message The error message.
+ *
+ * @returns An array schema.
+ */
+declare function array<const TItem extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, const TMessage extends ErrorMessage<ArrayIssue> | undefined>(item: TItem, message: TMessage): ArraySchema<TItem, TMessage>;
+
+/**
+ * Boolean issue type.
+ */
+interface BooleanIssue extends BaseIssue<unknown> {
+    /**
+     * The issue kind.
+     */
+    readonly kind: 'schema';
+    /**
+     * The issue type.
+     */
+    readonly type: 'boolean';
+    /**
+     * The expected property.
+     */
+    readonly expected: 'boolean';
+}
+/**
+ * Boolean schema type.
+ */
+interface BooleanSchema<TMessage extends ErrorMessage<BooleanIssue> | undefined> extends BaseSchema<boolean, boolean, BooleanIssue> {
+    /**
+     * The schema type.
+     */
+    readonly type: 'boolean';
+    /**
+     * The schema reference.
+     */
+    readonly reference: typeof boolean;
+    /**
+     * The expected property.
+     */
+    readonly expects: 'boolean';
+    /**
+     * The error message.
+     */
+    readonly message: TMessage;
+}
+/**
+ * Creates a boolean schema.
+ *
+ * @returns A boolean schema.
+ */
+declare function boolean(): BooleanSchema<undefined>;
+/**
+ * Creates a boolean schema.
+ *
+ * @param message The error message.
+ *
+ * @returns A boolean schema.
+ */
+declare function boolean<const TMessage extends ErrorMessage<BooleanIssue> | undefined>(message: TMessage): BooleanSchema<TMessage>;
+
+/**
+ * Lazy schema type.
+ */
+interface LazySchema<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>> extends BaseSchema<InferInput<TWrapped>, InferOutput<TWrapped>, InferIssue<TWrapped>> {
+    /**
+     * The schema type.
+     */
+    readonly type: 'lazy';
+    /**
+     * The schema reference.
+     */
+    readonly reference: typeof lazy;
+    /**
+     * The expected property.
+     */
+    readonly expects: 'unknown';
+    /**
+     * The schema getter.
+     */
+    readonly getter: (input: unknown) => TWrapped;
+}
+/**
+ * Creates a lazy schema.
+ *
+ * @param getter The schema getter.
+ *
+ * @returns A lazy schema.
+ */
+declare function lazy<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(getter: (input: unknown) => TWrapped): LazySchema<TWrapped>;
+
+/**
+ * Lazy schema async type.
+ */
+interface LazySchemaAsync<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>> extends BaseSchemaAsync<InferInput<TWrapped>, InferOutput<TWrapped>, InferIssue<TWrapped>> {
+    /**
+     * The schema type.
+     */
+    readonly type: 'lazy';
+    /**
+     * The schema reference.
+     */
+    readonly reference: typeof lazyAsync;
+    /**
+     * The expected property.
+     */
+    readonly expects: 'unknown';
+    /**
+     * The schema getter.
+     */
+    readonly getter: (input: unknown) => MaybePromise<TWrapped>;
+}
+/**
+ * Creates a lazy schema.
+ *
+ * @param getter The schema getter.
+ *
+ * @returns A lazy schema.
+ */
+declare function lazyAsync<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>>(getter: (input: unknown) => MaybePromise<TWrapped>): LazySchemaAsync<TWrapped>;
+
+/**
+ * Union issue type.
+ */
+interface UnionIssue<TSubIssue extends BaseIssue<unknown>> extends BaseIssue<unknown> {
+    /**
+     * The issue kind.
+     */
+    readonly kind: 'schema';
+    /**
+     * The issue type.
+     */
+    readonly type: 'union';
+    /**
+     * The expected property.
+     */
+    readonly expected: string;
+    /**
+     * The sub issues.
+     */
+    readonly issues?: [TSubIssue, ...TSubIssue[]];
+}
+
+/**
+ * Union options type.
+ */
+type UnionOptions = MaybeReadonly<BaseSchema<unknown, unknown, BaseIssue<unknown>>[]>;
+/**
+ * Union schema type.
+ */
+interface UnionSchema<TOptions extends UnionOptions, TMessage extends ErrorMessage<UnionIssue<InferIssue<TOptions[number]>>> | undefined> extends BaseSchema<InferInput<TOptions[number]>, InferOutput<TOptions[number]>, UnionIssue<InferIssue<TOptions[number]>> | InferIssue<TOptions[number]>> {
+    /**
+     * The schema type.
+     */
+    readonly type: 'union';
+    /**
+     * The schema reference.
+     */
+    readonly reference: typeof union;
+    /**
+     * The union options.
+     */
+    readonly options: TOptions;
+    /**
+     * The error message.
+     */
+    readonly message: TMessage;
+}
+/**
+ * Creates an union schema.
+ *
+ * @param options The union options.
+ *
+ * @returns An union schema.
+ */
+declare function union<const TOptions extends UnionOptions>(options: TOptions): UnionSchema<TOptions, undefined>;
+/**
+ * Creates an union schema.
+ *
+ * @param options The union options.
+ * @param message The error message.
+ *
+ * @returns An union schema.
+ */
+declare function union<const TOptions extends UnionOptions, const TMessage extends ErrorMessage<UnionIssue<InferIssue<TOptions[number]>>> | undefined>(options: TOptions, message: TMessage): UnionSchema<TOptions, TMessage>;
+
+/**
+ * Union options async type.
+ */
+type UnionOptionsAsync = MaybeReadonly<(BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>)[]>;
+/**
+ * Union schema async type.
+ */
+interface UnionSchemaAsync<TOptions extends UnionOptionsAsync, TMessage extends ErrorMessage<UnionIssue<InferIssue<TOptions[number]>>> | undefined> extends BaseSchemaAsync<InferInput<TOptions[number]>, InferOutput<TOptions[number]>, UnionIssue<InferIssue<TOptions[number]>> | InferIssue<TOptions[number]>> {
+    /**
+     * The schema type.
+     */
+    readonly type: 'union';
+    /**
+     * The schema reference.
+     */
+    readonly reference: typeof unionAsync;
+    /**
+     * The union options.
+     */
+    readonly options: TOptions;
+    /**
+     * The error message.
+     */
+    readonly message: TMessage;
+}
+/**
+ * Creates an union schema.
+ *
+ * @param options The union options.
+ *
+ * @returns An union schema.
+ */
+declare function unionAsync<const TOptions extends UnionOptionsAsync>(options: TOptions): UnionSchemaAsync<TOptions, undefined>;
+/**
+ * Creates an union schema.
+ *
+ * @param options The union options.
+ * @param message The error message.
+ *
+ * @returns An union schema.
+ */
+declare function unionAsync<const TOptions extends UnionOptionsAsync, const TMessage extends ErrorMessage<UnionIssue<InferIssue<TOptions[number]>>> | undefined>(options: TOptions, message: TMessage): UnionSchemaAsync<TOptions, TMessage>;
+
+/**
+ * Non nullable issue type.
+ */
+interface NonNullableIssue extends BaseIssue<unknown> {
+    /**
+     * The issue kind.
+     */
+    readonly kind: 'schema';
+    /**
+     * The issue type.
+     */
+    readonly type: 'non_nullable';
+    /**
+     * The expected property.
+     */
+    readonly expected: '!null';
+}
+/**
+ * Infer non nullable input type.
+ */
+type InferNonNullableInput<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>> = NonNullable$1<InferInput<TWrapped>>;
+/**
+ * Infer non nullable output type.
+ */
+type InferNonNullableOutput<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>> = NonNullable$1<InferOutput<TWrapped>>;
+/**
+ * Infer non nullable issue type.
+ */
+type InferNonNullableIssue<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>> = TWrapped extends UnionSchema<UnionOptions, ErrorMessage<UnionIssue<BaseIssue<unknown>>> | undefined> | UnionSchemaAsync<UnionOptionsAsync, ErrorMessage<UnionIssue<BaseIssue<unknown>>> | undefined> ? Exclude<InferIssue<TWrapped>, {
+    type: 'null' | 'union';
+}> | UnionIssue<InferNonNullableIssue<TWrapped['options'][number]>> : Exclude<InferIssue<TWrapped>, {
+    type: 'null';
+}>;
+
+/**
+ * Non nullable schema type.
+ */
+interface NonNullableSchema<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TMessage extends ErrorMessage<NonNullableIssue> | undefined> extends BaseSchema<InferNonNullableInput<TWrapped>, InferNonNullableOutput<TWrapped>, NonNullableIssue | InferNonNullableIssue<TWrapped>> {
+    /**
+     * The schema type.
+     */
+    readonly type: 'non_nullable';
+    /**
+     * The schema reference.
+     */
+    readonly reference: typeof nonNullable;
+    /**
+     * The expected property.
+     */
+    readonly expects: '!null';
+    /**
+     * The wrapped schema.
+     */
+    readonly wrapped: TWrapped;
+    /**
+     * The error message.
+     */
+    readonly message: TMessage;
+}
+/**
+ * Creates a non nullable schema.
+ *
+ * @param wrapped The wrapped schema.
+ *
+ * @returns A non nullable schema.
+ */
+declare function nonNullable<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped): NonNullableSchema<TWrapped, undefined>;
+/**
+ * Creates a non nullable schema.
+ *
+ * @param wrapped The wrapped schema.
+ * @param message The error message.
+ *
+ * @returns A non nullable schema.
+ */
+declare function nonNullable<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, const TMessage extends ErrorMessage<NonNullableIssue> | undefined>(wrapped: TWrapped, message: TMessage): NonNullableSchema<TWrapped, TMessage>;
+
+/**
+ * Non nullable schema async type.
+ */
+interface NonNullableSchemaAsync<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TMessage extends ErrorMessage<NonNullableIssue> | undefined> extends BaseSchemaAsync<InferNonNullableInput<TWrapped>, InferNonNullableOutput<TWrapped>, NonNullableIssue | InferNonNullableIssue<TWrapped>> {
+    /**
+     * The schema type.
+     */
+    readonly type: 'non_nullable';
+    /**
+     * The schema reference.
+     */
+    readonly reference: typeof nonNullableAsync;
+    /**
+     * The expected property.
+     */
+    readonly expects: '!null';
+    /**
+     * The wrapped schema.
+     */
+    readonly wrapped: TWrapped;
+    /**
+     * The error message.
+     */
+    readonly message: TMessage;
+}
+/**
+ * Creates a non nullable schema.
+ *
+ * @param wrapped The wrapped schema.
+ *
+ * @returns A non nullable schema.
+ */
+declare function nonNullableAsync<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped): NonNullableSchemaAsync<TWrapped, undefined>;
+/**
+ * Creates a non nullable schema.
+ *
+ * @param wrapped The wrapped schema.
+ * @param message The error message.
+ *
+ * @returns A non nullable schema.
+ */
+declare function nonNullableAsync<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, const TMessage extends ErrorMessage<NonNullableIssue> | undefined>(wrapped: TWrapped, message: TMessage): NonNullableSchemaAsync<TWrapped, TMessage>;
+
+/**
+ * Infer nullish output type.
+ */
+type InferNullishOutput<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TDefault extends DefaultAsync<TWrapped, null | undefined>> = [TDefault] extends [never] ? InferOutput<TWrapped> | null | undefined : NonNullish<InferOutput<TWrapped>> | Extract<DefaultValue<TDefault>, null | undefined>;
+
+/**
+ * Nullish schema type.
+ */
+interface NullishSchema<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TDefault extends Default<TWrapped, null | undefined>> extends BaseSchema<InferInput<TWrapped> | null | undefined, InferNullishOutput<TWrapped, TDefault>, InferIssue<TWrapped>> {
+    /**
+     * The schema type.
+     */
+    readonly type: 'nullish';
+    /**
+     * The schema reference.
+     */
+    readonly reference: typeof nullish;
+    /**
+     * The expected property.
+     */
+    readonly expects: `${TWrapped['expects']} | null | undefined`;
+    /**
+     * The wrapped schema.
+     */
+    readonly wrapped: TWrapped;
+    /**
+     * The default value.
+     */
+    readonly default: TDefault;
+}
+/**
+ * Creates a nullish schema.
+ *
+ * @param wrapped The wrapped schema.
+ *
+ * @returns A nullish schema.
+ */
+declare function nullish<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped): NullishSchema<TWrapped, never>;
+/**
+ * Creates a nullish schema.
+ *
+ * @param wrapped The wrapped schema.
+ * @param default_ The default value.
+ *
+ * @returns A nullish schema.
+ */
+declare function nullish<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, const TDefault extends Default<TWrapped, null | undefined>>(wrapped: TWrapped, default_: TDefault): NullishSchema<TWrapped, TDefault>;
+
+/**
+ * Nullish schema async type.
+ */
+interface NullishSchemaAsync<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TDefault extends DefaultAsync<TWrapped, null | undefined>> extends BaseSchemaAsync<InferInput<TWrapped> | null | undefined, InferNullishOutput<TWrapped, TDefault>, InferIssue<TWrapped>> {
+    /**
+     * The schema type.
+     */
+    readonly type: 'nullish';
+    /**
+     * The schema reference.
+     */
+    readonly reference: typeof nullishAsync;
+    /**
+     * The expected property.
+     */
+    readonly expects: `${TWrapped['expects']} | null | undefined`;
+    /**
+     * The wrapped schema.
+     */
+    readonly wrapped: TWrapped;
+    /**
+     * The default value.
+     */
+    readonly default: TDefault;
+}
+/**
+ * Creates a nullish schema.
+ *
+ * @param wrapped The wrapped schema.
+ *
+ * @returns A nullish schema.
+ */
+declare function nullishAsync<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped): NullishSchemaAsync<TWrapped, never>;
+/**
+ * Creates a nullish schema.
+ *
+ * @param wrapped The wrapped schema.
+ * @param default_ The default value.
+ *
+ * @returns A nullish schema.
+ */
+declare function nullishAsync<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, const TDefault extends DefaultAsync<TWrapped, null | undefined>>(wrapped: TWrapped, default_: TDefault): NullishSchemaAsync<TWrapped, TDefault>;
+
+/**
+ * Object issue type.
+ */
+interface ObjectIssue extends BaseIssue<unknown> {
+    /**
+     * The issue kind.
+     */
+    readonly kind: 'schema';
+    /**
+     * The issue type.
+     */
+    readonly type: 'object';
+    /**
+     * The expected property.
+     */
+    readonly expected: 'Object';
+}
+
+/**
+ * Object schema type.
+ */
+interface ObjectSchema<TEntries extends ObjectEntries, TMessage extends ErrorMessage<ObjectIssue> | undefined> extends BaseSchema<InferObjectInput<TEntries>, InferObjectOutput<TEntries>, ObjectIssue | InferObjectIssue<TEntries>> {
+    /**
+     * The schema type.
+     */
+    readonly type: 'object';
+    /**
+     * The schema reference.
+     */
+    readonly reference: typeof object;
+    /**
+     * The expected property.
+     */
+    readonly expects: 'Object';
+    /**
+     * The entries schema.
+     */
+    readonly entries: TEntries;
+    /**
+     * The error message.
+     */
+    readonly message: TMessage;
+}
+/**
+ * Creates an object schema.
+ *
+ * Hint: This schema removes unknown entries. The output will only include the
+ * entries you specify. To include unknown entries, use `looseObject`. To
+ * return an issue for unknown entries, use `strictObject`. To include and
+ * validate unknown entries, use `objectWithRest`.
+ *
+ * @param entries The entries schema.
+ *
+ * @returns An object schema.
+ */
+declare function object<const TEntries extends ObjectEntries>(entries: TEntries): ObjectSchema<TEntries, undefined>;
+/**
+ * Creates an object schema.
+ *
+ * Hint: This schema removes unknown entries. The output will only include the
+ * entries you specify. To include unknown entries, use `looseObject`. To
+ * return an issue for unknown entries, use `strictObject`. To include and
+ * validate unknown entries, use `objectWithRest`.
+ *
+ * @param entries The entries schema.
+ * @param message The error message.
+ *
+ * @returns An object schema.
+ */
+declare function object<const TEntries extends ObjectEntries, const TMessage extends ErrorMessage<ObjectIssue> | undefined>(entries: TEntries, message: TMessage): ObjectSchema<TEntries, TMessage>;
+
+/**
+ * Infer optional output type.
+ */
+type InferOptionalOutput<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TDefault extends DefaultAsync<TWrapped, undefined>> = [TDefault] extends [never] ? InferOutput<TWrapped> | undefined : NonOptional<InferOutput<TWrapped>> | Extract<DefaultValue<TDefault>, undefined>;
+
+/**
+ * Optional schema type.
+ */
+interface OptionalSchema<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TDefault extends Default<TWrapped, undefined>> extends BaseSchema<InferInput<TWrapped> | undefined, InferOptionalOutput<TWrapped, TDefault>, InferIssue<TWrapped>> {
+    /**
+     * The schema type.
+     */
+    readonly type: 'optional';
+    /**
+     * The schema reference.
+     */
+    readonly reference: typeof optional;
+    /**
+     * The expected property.
+     */
+    readonly expects: `${TWrapped['expects']} | undefined`;
+    /**
+     * The wrapped schema.
+     */
+    readonly wrapped: TWrapped;
+    /**
+     * The default value.
+     */
+    readonly default: TDefault;
+}
+/**
+ * Creates a optional schema.
+ *
+ * @param wrapped The wrapped schema.
+ *
+ * @returns A optional schema.
+ */
+declare function optional<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped): OptionalSchema<TWrapped, never>;
+/**
+ * Creates a optional schema.
+ *
+ * @param wrapped The wrapped schema.
+ * @param default_ The default value.
+ *
+ * @returns A optional schema.
+ */
+declare function optional<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, const TDefault extends Default<TWrapped, undefined>>(wrapped: TWrapped, default_: TDefault): OptionalSchema<TWrapped, TDefault>;
+
+/**
+ * Optional schema async type.
+ */
+interface OptionalSchemaAsync<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TDefault extends DefaultAsync<TWrapped, undefined>> extends BaseSchemaAsync<InferInput<TWrapped> | undefined, InferOptionalOutput<TWrapped, TDefault>, InferIssue<TWrapped>> {
+    /**
+     * The schema type.
+     */
+    readonly type: 'optional';
+    /**
+     * The schema reference.
+     */
+    readonly reference: typeof optionalAsync;
+    /**
+     * The expected property.
+     */
+    readonly expects: `${TWrapped['expects']} | undefined`;
+    /**
+     * The wrapped schema.
+     */
+    readonly wrapped: TWrapped;
+    /**
+     * The default value.
+     */
+    readonly default: TDefault;
+}
+/**
+ * Creates an optional schema.
+ *
+ * @param wrapped The wrapped schema.
+ *
+ * @returns An optional schema.
+ */
+declare function optionalAsync<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped): OptionalSchemaAsync<TWrapped, never>;
+/**
+ * Creates an optional schema.
+ *
+ * @param wrapped The wrapped schema.
+ * @param default_ The default value.
+ *
+ * @returns An optional schema.
+ */
+declare function optionalAsync<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, const TDefault extends DefaultAsync<TWrapped, undefined>>(wrapped: TWrapped, default_: TDefault): OptionalSchemaAsync<TWrapped, TDefault>;
+
+/**
+ * Schema with pipe type.
+ */
+type SchemaWithPipe<TPipe extends [
+    BaseSchema<unknown, unknown, BaseIssue<unknown>>,
+    ...PipeItem<unknown, unknown, BaseIssue<unknown>>[]
+]> = Omit<FirstTupleItem<TPipe>, '_run' | '_types'> & {
+    /**
+     * The pipe items.
+     */
+    readonly pipe: TPipe;
+    /**
+     * Parses unknown input.
+     *
+     * @param dataset The input dataset.
+     * @param config The configuration.
+     *
+     * @returns The output dataset.
+     *
+     * @internal
+     */
+    _run(dataset: Dataset<unknown, never>, config: Config<InferIssue<FirstTupleItem<TPipe>>>): Dataset<InferOutput<LastTupleItem<TPipe>>, InferIssue<TPipe[number]>>;
+    /**
+     * Input, output and issue type.
+     *
+     * @internal
+     */
+    readonly _types?: {
+        readonly input: InferInput<FirstTupleItem<TPipe>>;
+        readonly output: InferOutput<LastTupleItem<TPipe>>;
+        readonly issue: InferIssue<TPipe[number]>;
+    };
+};
+
+/**
+ * Schema with pipe async type.
+ */
+type SchemaWithPipeAsync<TPipe extends [
+    (BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>),
+    ...(PipeItem<unknown, unknown, BaseIssue<unknown>> | PipeItemAsync<unknown, unknown, BaseIssue<unknown>>)[]
+]> = Omit<FirstTupleItem<TPipe>, 'async' | '_run' | '_types'> & {
+    /**
+     * The pipe items.
+     */
+    readonly pipe: TPipe;
+    /**
+     * Whether it's async.
+     */
+    readonly async: true;
+    /**
+     * Parses unknown input.
+     *
+     * @param dataset The input dataset.
+     * @param config The configuration.
+     *
+     * @returns The output dataset.
+     *
+     * @internal
+     */
+    _run(dataset: Dataset<unknown, never>, config: Config<InferIssue<FirstTupleItem<TPipe>>>): Promise<Dataset<InferOutput<LastTupleItem<TPipe>>, InferIssue<TPipe[number]>>>;
+    /**
+     * Input, output and issue type.
+     *
+     * @internal
+     */
+    readonly _types?: {
+        readonly input: InferInput<FirstTupleItem<TPipe>>;
+        readonly output: InferOutput<LastTupleItem<TPipe>>;
+        readonly issue: InferIssue<TPipe[number]>;
+    };
+};
+
+/**
+ * String issue type.
+ */
+interface StringIssue extends BaseIssue<unknown> {
+    /**
+     * The issue kind.
+     */
+    readonly kind: 'schema';
+    /**
+     * The issue type.
+     */
+    readonly type: 'string';
+    /**
+     * The expected property.
+     */
+    readonly expected: 'string';
+}
+/**
+ * String schema type.
+ */
+interface StringSchema<TMessage extends ErrorMessage<StringIssue> | undefined> extends BaseSchema<string, string, StringIssue> {
+    /**
+     * The schema type.
+     */
+    readonly type: 'string';
+    /**
+     * The schema reference.
+     */
+    readonly reference: typeof string;
+    /**
+     * The expected property.
+     */
+    readonly expects: 'string';
+    /**
+     * The error message.
+     */
+    readonly message: TMessage;
+}
+/**
+ * Creates a string schema.
+ *
+ * @returns A string schema.
+ */
+declare function string(): StringSchema<undefined>;
+/**
+ * Creates a string schema.
+ *
+ * @param message The error message.
+ *
+ * @returns A string schema.
+ */
+declare function string<const TMessage extends ErrorMessage<StringIssue> | undefined>(message: TMessage): StringSchema<TMessage>;
+
+/**
+ * Base metadata type.
+ */
+interface BaseMetadata<TInput> {
+    /**
+     * The object kind.
+     */
+    readonly kind: 'metadata';
+    /**
+     * The metadata type.
+     */
+    readonly type: string;
+    /**
+     * The metadata reference.
+     */
+    readonly reference: (...args: any[]) => BaseMetadata<unknown>;
+    /**
+     * Input, output and issue type.
+     *
+     * @internal
+     */
+    readonly _types?: {
+        readonly input: TInput;
+        readonly output: TInput;
+        readonly issue: never;
+    };
+}
+
+/**
+ * Typed dataset type.
+ */
+interface TypedDataset<TValue, TIssue extends BaseIssue<unknown>> {
+    /**
+     * Whether is's typed.
+     */
+    typed: true;
+    /**
+     * The dataset value.
+     */
+    value: TValue;
+    /**
+     * The dataset issues.
+     */
+    issues?: [TIssue, ...TIssue[]];
+}
+/**
+ * Untyped dataset type.
+ */
+interface UntypedDataset<TIssue extends BaseIssue<unknown>> {
+    /**
+     * Whether is's typed.
+     */
+    typed: false;
+    /**
+     * The dataset value.
+     */
+    value: unknown;
+    /**
+     * The dataset issues.
+     */
+    issues?: [TIssue, ...TIssue[]];
+}
+/**
+ * Dataset type.
+ */
+type Dataset<TValue, TIssue extends BaseIssue<unknown>> = TypedDataset<TValue, TIssue> | UntypedDataset<TIssue>;
+
+/**
+ * Base schema type.
+ */
+interface BaseSchema<TInput, TOutput, TIssue extends BaseIssue<unknown>> {
+    /**
+     * The object kind.
+     */
+    readonly kind: 'schema';
+    /**
+     * The schema type.
+     */
+    readonly type: string;
+    /**
+     * The schema reference.
+     */
+    readonly reference: (...args: any[]) => BaseSchema<unknown, unknown, BaseIssue<unknown>>;
+    /**
+     * The expected property.
+     */
+    readonly expects: string;
+    /**
+     * Whether it's async.
+     */
+    readonly async: false;
+    /**
+     * Parses unknown input.
+     *
+     * @param dataset The input dataset.
+     * @param config The configuration.
+     *
+     * @returns The output dataset.
+     *
+     * @internal
+     */
+    _run(dataset: Dataset<unknown, never>, config: Config<TIssue>): Dataset<TOutput, TIssue>;
+    /**
+     * Input, output and issue type.
+     *
+     * @internal
+     */
+    readonly _types?: {
+        readonly input: TInput;
+        readonly output: TOutput;
+        readonly issue: TIssue;
+    };
+}
+/**
+ * Base schema async type.
+ */
+interface BaseSchemaAsync<TInput, TOutput, TIssue extends BaseIssue<unknown>> extends Omit<BaseSchema<TInput, TOutput, TIssue>, 'reference' | 'async' | '_run'> {
+    /**
+     * The schema reference.
+     */
+    readonly reference: (...args: any[]) => BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>;
+    /**
+     * Whether it's async.
+     */
+    readonly async: true;
+    /**
+     * Parses unknown input.
+     *
+     * @param dataset The input dataset.
+     * @param config The configuration.
+     *
+     * @returns The output dataset.
+     *
+     * @internal
+     */
+    _run(dataset: Dataset<unknown, never>, config: Config<TIssue>): Promise<Dataset<TOutput, TIssue>>;
+}
+
+/**
+ * Base transformation type.
+ */
+interface BaseTransformation<TInput, TOutput, TIssue extends BaseIssue<unknown>> {
+    /**
+     * The object kind.
+     */
+    readonly kind: 'transformation';
+    /**
+     * The transformation type.
+     */
+    readonly type: string;
+    /**
+     * The transformation reference.
+     */
+    readonly reference: (...args: any[]) => BaseTransformation<unknown, unknown, BaseIssue<unknown>>;
+    /**
+     * Whether it's async.
+     */
+    readonly async: false;
+    /**
+     * Transforms known input.
+     *
+     * @param dataset The input dataset.
+     * @param config The configuration.
+     *
+     * @returns The output dataset.
+     *
+     * @internal
+     */
+    _run(dataset: TypedDataset<TInput, never>, config: Config<TIssue>): Dataset<TOutput, TIssue>;
+    /**
+     * Input, output and issue type.
+     *
+     * @internal
+     */
+    readonly _types?: {
+        readonly input: TInput;
+        readonly output: TOutput;
+        readonly issue: TIssue;
+    };
+}
+/**
+ * Base transformation async type.
+ */
+interface BaseTransformationAsync<TInput, TOutput, TIssue extends BaseIssue<unknown>> extends Omit<BaseTransformation<TInput, TOutput, TIssue>, 'reference' | 'async' | '_run'> {
+    /**
+     * The transformation reference.
+     */
+    readonly reference: (...args: any[]) => BaseTransformation<unknown, unknown, BaseIssue<unknown>> | BaseTransformationAsync<unknown, unknown, BaseIssue<unknown>>;
+    /**
+     * Whether it's async.
+     */
+    readonly async: true;
+    /**
+     * Transforms known input.
+     *
+     * @param dataset The input dataset.
+     * @param config The configuration.
+     *
+     * @returns The output dataset.
+     *
+     * @internal
+     */
+    _run(dataset: TypedDataset<TInput, never>, config: Config<TIssue>): Promise<Dataset<TOutput, TIssue>>;
+}
+
+/**
+ * Base validation type.
+ */
+interface BaseValidation<TInput, TOutput, TIssue extends BaseIssue<unknown>> {
+    /**
+     * The object kind.
+     */
+    readonly kind: 'validation';
+    /**
+     * The validation type.
+     */
+    readonly type: string;
+    /**
+     * The validation reference.
+     */
+    readonly reference: (...args: any[]) => BaseValidation<unknown, unknown, BaseIssue<unknown>>;
+    /**
+     * The expected property.
+     */
+    readonly expects: string | null;
+    /**
+     * Whether it's async.
+     */
+    readonly async: false;
+    /**
+     * Validates known input.
+     *
+     * @param dataset The input dataset.
+     * @param config The configuration.
+     *
+     * @returns The output dataset.
+     *
+     * @internal
+     */
+    _run(dataset: Dataset<TInput, BaseIssue<unknown>>, config: Config<TIssue>): Dataset<TOutput, BaseIssue<unknown> | TIssue>;
+    /**
+     * Input, output and issue type.
+     *
+     * @internal
+     */
+    readonly _types?: {
+        readonly input: TInput;
+        readonly output: TOutput;
+        readonly issue: TIssue;
+    };
+}
+/**
+ * Base validation async type.
+ */
+interface BaseValidationAsync<TInput, TOutput, TIssue extends BaseIssue<unknown>> extends Omit<BaseValidation<TInput, TOutput, TIssue>, 'reference' | 'async' | '_run'> {
+    /**
+     * The validation reference.
+     */
+    readonly reference: (...args: any[]) => BaseValidation<unknown, unknown, BaseIssue<unknown>> | BaseValidationAsync<unknown, unknown, BaseIssue<unknown>>;
+    /**
+     * Whether it's async.
+     */
+    readonly async: true;
+    /**
+     * Validates known input.
+     *
+     * @param dataset The input dataset.
+     * @param config The configuration.
+     *
+     * @returns The output dataset.
+     *
+     * @internal
+     */
+    _run(dataset: Dataset<TInput, BaseIssue<unknown>>, config: Config<TIssue>): Promise<Dataset<TOutput, BaseIssue<unknown> | TIssue>>;
+}
+
+/**
+ * Infer input type.
+ */
+type InferInput<TItem extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>> | BaseValidation<unknown, unknown, BaseIssue<unknown>> | BaseValidationAsync<unknown, unknown, BaseIssue<unknown>> | BaseTransformation<unknown, unknown, BaseIssue<unknown>> | BaseTransformationAsync<unknown, unknown, BaseIssue<unknown>> | BaseMetadata<unknown>> = NonNullable<TItem['_types']>['input'];
+/**
+ * Infer output type.
+ */
+type InferOutput<TItem extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>> | BaseValidation<unknown, unknown, BaseIssue<unknown>> | BaseValidationAsync<unknown, unknown, BaseIssue<unknown>> | BaseTransformation<unknown, unknown, BaseIssue<unknown>> | BaseTransformationAsync<unknown, unknown, BaseIssue<unknown>> | BaseMetadata<unknown>> = NonNullable<TItem['_types']>['output'];
+/**
+ * Infer issue type.
+ */
+type InferIssue<TItem extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>> | BaseValidation<unknown, unknown, BaseIssue<unknown>> | BaseValidationAsync<unknown, unknown, BaseIssue<unknown>> | BaseTransformation<unknown, unknown, BaseIssue<unknown>> | BaseTransformationAsync<unknown, unknown, BaseIssue<unknown>> | BaseMetadata<unknown>> = NonNullable<TItem['_types']>['issue'];
+
+/**
+ * Extracts `null` from a type.
+ */
+type NonNullable$1<TValue> = TValue extends null ? never : TValue;
+/**
+ * Extracts `null` and `undefined` from a type.
+ */
+type NonNullish<TValue> = TValue extends null | undefined ? never : TValue;
+/**
+ * Extracts `undefined` from a type.
+ */
+type NonOptional<TValue> = TValue extends undefined ? never : TValue;
+/**
+ * Constructs a type that is maybe readonly.
+ */
+type MaybeReadonly<TValue> = TValue | Readonly<TValue>;
+/**
+ * Constructs a type that is maybe a promise.
+ */
+type MaybePromise<TValue> = TValue | Promise<TValue>;
+/**
+ * Prettifies a type for better readability.
+ *
+ * Hint: This type has no effect and is only used so that TypeScript displays
+ * the final type in the preview instead of the utility types used.
+ */
+type Prettify<TObject> = {
+    [TKey in keyof TObject]: TObject[TKey];
+} & {};
+/**
+ * Marks specific keys as optional.
+ */
+type MarkOptional<TObject, TKeys extends keyof TObject> = Omit<TObject, TKeys> & Partial<Pick<TObject, TKeys>>;
+/**
+ * Extracts first tuple item.
+ */
+type FirstTupleItem<TTuple extends [unknown, ...unknown[]]> = TTuple[0];
+/**
+ * Extracts last tuple item.
+ */
+type LastTupleItem<TTuple extends [unknown, ...unknown[]]> = TTuple[TTuple extends [unknown, ...infer TRest] ? TRest['length'] : never];
+
+/**
+ * Error message type.
+ */
+type ErrorMessage<TIssue extends BaseIssue<unknown>> = ((issue: TIssue) => string) | string;
+/**
+ * Default type.
+ */
+type Default<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TInput extends null | undefined> = MaybeReadonly<InferInput<TWrapped> | TInput> | ((dataset?: Dataset<TInput, never>, config?: Config<InferIssue<TWrapped>>) => MaybeReadonly<InferInput<TWrapped> | TInput>);
+/**
+ * Default async type.
+ */
+type DefaultAsync<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TInput extends null | undefined> = MaybeReadonly<InferInput<TWrapped> | TInput> | ((dataset?: Dataset<TInput, never>, config?: Config<InferIssue<TWrapped>>) => MaybePromise<MaybeReadonly<InferInput<TWrapped> | TInput>>);
+/**
+ * Default value type.
+ */
+type DefaultValue<TDefault extends Default<BaseSchema<unknown, unknown, BaseIssue<unknown>>, null | undefined> | DefaultAsync<BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, null | undefined>> = TDefault extends DefaultAsync<infer TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, infer TInput> ? TDefault extends (dataset?: Dataset<TInput, never>, config?: Config<InferIssue<TWrapped>>) => MaybePromise<InferInput<TWrapped> | TInput> ? Awaited<ReturnType<TDefault>> : TDefault : never;
+/**
+ * Question mark schema type.
+ *
+ * TODO: Document that for simplicity and bundle size, we currently do not
+ * distinguish between `undefined` and missing keys when using `optional` and
+ * `nullish`.
+ */
+type QuestionMarkSchema = NullishSchema<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown> | OptionalSchema<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown> | LazySchema<QuestionMarkSchema> | NonNullableSchema<QuestionMarkSchema, ErrorMessage<NonNullableIssue> | undefined>;
+/**
+ * Question mark schema async type.
+ */
+type QuestionMarkSchemaAsync = NullishSchemaAsync<BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, unknown> | OptionalSchemaAsync<BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, unknown> | LazySchemaAsync<QuestionMarkSchema | QuestionMarkSchemaAsync> | NonNullableSchemaAsync<QuestionMarkSchema | QuestionMarkSchemaAsync, ErrorMessage<NonNullableIssue> | undefined>;
+
+/**
+ * Pipe action type.
+ */
+type PipeAction<TInput, TOutput, TIssue extends BaseIssue<unknown>> = BaseValidation<TInput, TOutput, TIssue> | BaseTransformation<TInput, TOutput, TIssue> | BaseMetadata<TInput>;
+/**
+ * Pipe action async type.
+ */
+type PipeActionAsync<TInput, TOutput, TIssue extends BaseIssue<unknown>> = BaseValidationAsync<TInput, TOutput, TIssue> | BaseTransformationAsync<TInput, TOutput, TIssue>;
+/**
+ * Pipe item type.
+ */
+type PipeItem<TInput, TOutput, TIssue extends BaseIssue<unknown>> = BaseSchema<TInput, TOutput, TIssue> | PipeAction<TInput, TOutput, TIssue>;
+/**
+ * Pipe item async type.
+ */
+type PipeItemAsync<TInput, TOutput, TIssue extends BaseIssue<unknown>> = BaseSchemaAsync<TInput, TOutput, TIssue> | PipeActionAsync<TInput, TOutput, TIssue>;
+
+/**
+ * Object entries type.
+ */
+interface ObjectEntries {
+    [key: string]: BaseSchema<unknown, unknown, BaseIssue<unknown>>;
+}
+/**
+ * Object entries async type.
+ */
+interface ObjectEntriesAsync {
+    [key: string]: BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>;
+}
+/**
+ * Infer entries input type.
+ */
+type InferEntriesInput<TEntries extends ObjectEntries | ObjectEntriesAsync> = {
+    -readonly [TKey in keyof TEntries]: InferInput<TEntries[TKey]>;
+};
+/**
+ * Infer entries output type.
+ */
+type InferEntriesOutput<TEntries extends ObjectEntries | ObjectEntriesAsync> = {
+    -readonly [TKey in keyof TEntries]: InferOutput<TEntries[TKey]>;
+};
+/**
+ * Optional keys type.
+ */
+type OptionalKeys<TEntries extends ObjectEntries | ObjectEntriesAsync, TObject extends InferEntriesInput<TEntries> | InferEntriesOutput<TEntries>> = {
+    [TKey in keyof TEntries]: TEntries[TKey] extends QuestionMarkSchema | QuestionMarkSchemaAsync ? undefined extends TObject[TKey] ? TKey : never : never;
+}[keyof TEntries];
+/**
+ * With question marks type.
+ */
+type WithQuestionMarks<TEntries extends ObjectEntries | ObjectEntriesAsync, TObject extends InferEntriesInput<TEntries> | InferEntriesOutput<TEntries>> = MarkOptional<TObject, OptionalKeys<TEntries, TObject>>;
+/**
+ * Readonly keys type.
+ */
+type ReadonlyKeys<TEntries extends ObjectEntries | ObjectEntriesAsync> = {
+    [TKey in keyof TEntries]: TEntries[TKey] extends SchemaWithPipe<[
+        BaseSchema<unknown, unknown, BaseIssue<unknown>>,
+        ...PipeItem<unknown, unknown, BaseIssue<unknown>>[]
+    ]> | SchemaWithPipeAsync<[
+        (BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>),
+        ...(PipeItem<unknown, unknown, BaseIssue<unknown>> | PipeItemAsync<unknown, unknown, BaseIssue<unknown>>)[]
+    ]> ? 'readonly' extends TEntries[TKey]['pipe'][number]['type'] ? TKey : never : never;
+}[keyof TEntries];
+/**
+ * With readonly type.
+ */
+type WithReadonly<TEntries extends ObjectEntries | ObjectEntriesAsync, TObject extends WithQuestionMarks<TEntries, InferEntriesOutput<TEntries>>> = Readonly<TObject> & Pick<TObject, Exclude<keyof TObject, ReadonlyKeys<TEntries>>>;
+/**
+ * Infer object input type.
+ */
+type InferObjectInput<TEntries extends ObjectEntries | ObjectEntriesAsync> = Prettify<WithQuestionMarks<TEntries, InferEntriesInput<TEntries>>>;
+/**
+ * Infer object output type.
+ */
+type InferObjectOutput<TEntries extends ObjectEntries | ObjectEntriesAsync> = Prettify<WithReadonly<TEntries, WithQuestionMarks<TEntries, InferEntriesOutput<TEntries>>>>;
+/**
+ * Infer object issue type.
+ */
+type InferObjectIssue<TEntries extends ObjectEntries | ObjectEntriesAsync> = InferIssue<TEntries[keyof TEntries]>;
+
+/**
+ * Array path item type.
+ */
+interface ArrayPathItem {
+    /**
+     * The path item type.
+     */
+    readonly type: 'array';
+    /**
+     * The path item origin.
+     */
+    readonly origin: 'value';
+    /**
+     * The path item input.
+     */
+    readonly input: MaybeReadonly<unknown[]>;
+    /**
+     * The path item key.
+     */
+    readonly key: number;
+    /**
+     * The path item value.
+     */
+    readonly value: unknown;
+}
+/**
+ * Map path item type.
+ */
+interface MapPathItem {
+    /**
+     * The path item type.
+     */
+    readonly type: 'map';
+    /**
+     * The path item origin.
+     */
+    readonly origin: 'key' | 'value';
+    /**
+     * The path item input.
+     */
+    readonly input: Map<unknown, unknown>;
+    /**
+     * The path item key.
+     */
+    readonly key: unknown;
+    /**
+     * The path item value.
+     */
+    readonly value: unknown;
+}
+/**
+ * Object path item type.
+ */
+interface ObjectPathItem {
+    /**
+     * The path item type.
+     */
+    readonly type: 'object';
+    /**
+     * The path item origin.
+     */
+    readonly origin: 'key' | 'value';
+    /**
+     * The path item input.
+     */
+    readonly input: Record<string, unknown>;
+    /**
+     * The path item key.
+     */
+    readonly key: string;
+    /**
+     * The path item value.
+     */
+    readonly value: unknown;
+}
+/**
+ * Set path item type.
+ */
+interface SetPathItem {
+    /**
+     * The path item type.
+     */
+    readonly type: 'set';
+    /**
+     * The path item origin.
+     */
+    readonly origin: 'value';
+    /**
+     * The path item input.
+     */
+    readonly input: Set<unknown>;
+    /**
+     * The path item key.
+     */
+    readonly key: null;
+    /**
+     * The path item key.
+     */
+    readonly value: unknown;
+}
+/**
+ * Unknown path item type.
+ */
+interface UnknownPathItem {
+    /**
+     * The path item type.
+     */
+    readonly type: 'unknown';
+    /**
+     * The path item origin.
+     */
+    readonly origin: 'key' | 'value';
+    /**
+     * The path item input.
+     */
+    readonly input: unknown;
+    /**
+     * The path item key.
+     */
+    readonly key: unknown;
+    /**
+     * The path item value.
+     */
+    readonly value: unknown;
+}
+/**
+ * Issue path item type.
+ *
+ * TODO: Document that the input of the path may be different from the input of
+ * the issue.
+ */
+type IssuePathItem = ArrayPathItem | MapPathItem | ObjectPathItem | SetPathItem | UnknownPathItem;
+/**
+ * Base issue type.
+ */
+interface BaseIssue<TInput> extends Config<BaseIssue<TInput>> {
+    /**
+     * The issue kind.
+     */
+    readonly kind: 'schema' | 'validation' | 'transformation';
+    /**
+     * The issue type.
+     */
+    readonly type: string;
+    /**
+     * The raw input data.
+     */
+    readonly input: TInput;
+    /**
+     * The expected property.
+     */
+    readonly expected: string | null;
+    /**
+     * The received property.
+     */
+    readonly received: string;
+    /**
+     * The error message.
+     */
+    readonly message: string;
+    /**
+     * The input requirement.
+     */
+    readonly requirement?: unknown;
+    /**
+     * The issue path.
+     *
+     * TODO: Investigate if it is possible to make the path type safe based on the
+     * input.
+     */
+    readonly path?: [IssuePathItem, ...IssuePathItem[]];
+    /**
+     * The sub issues.
+     */
+    readonly issues?: [BaseIssue<TInput>, ...BaseIssue<TInput>[]];
+}
+
+/**
+ * Config type.
+ */
+interface Config<TIssue extends BaseIssue<unknown>> {
+    /**
+     * The selected language.
+     */
+    readonly lang?: string;
+    /**
+     * The error message.
+     */
+    readonly message?: ErrorMessage<TIssue>;
+    /**
+     * Whether it was abort early.
+     */
+    readonly abortEarly?: boolean;
+    /**
+     * Whether the pipe was abort early.
+     */
+    readonly abortPipeEarly?: boolean;
+}
+
 /**
  * @internal
  * @description
  * This allows the rule to know some key information before checking for user-defined hooks.
  * For example, the position of the `deps` argument for the user-defined `useCustomEffect` hook that represents the built-in `useEffect` hook.
  */
-declare const CustomHookSchema: valibot.ObjectSchema<{}, undefined>;
+declare const CustomHookSchema: ObjectSchema<{}, undefined>;
 /**
  * @internal
  */
-declare const CustomAttributeSchema: valibot.ObjectSchema<{
+declare const CustomAttributeSchema: ObjectSchema<{
     /**
      * The name of the attribute in the user-defined component.
      * @example
      * "to"
      */
-    readonly name: valibot.StringSchema<undefined>;
+    readonly name: StringSchema<undefined>;
     /**
      * The name of the attribute in the built-in component.
      * @example
      * "href"
      */
-    readonly as: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
+    readonly as: OptionalSchema<StringSchema<undefined>, never>;
     /**
      * Whether the attribute is controlled or not in the user-defined component.
      * @example
      * `true`
      */
-    readonly controlled: valibot.OptionalSchema<valibot.BooleanSchema<undefined>, never>;
+    readonly controlled: OptionalSchema<BooleanSchema<undefined>, never>;
     /**
      * The default value of the attribute in the user-defined component.
      * @example
      * `"/"`
      */
-    readonly defaultValue: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
+    readonly defaultValue: OptionalSchema<StringSchema<undefined>, never>;
 }, undefined>;
 /**
  * @internal
@@ -111,317 +1527,416 @@ declare const CustomAttributeSchema: valibot.ObjectSchema<{
  * Which attribute is used as the `href` prop for the user-defined `Link` component that represents the built-in `a` element.
  * Which attributes are used as `children` props for a user-defined `Button` component to receive children of that component.
  */
-declare const CustomComponentSchema: valibot.ObjectSchema<{
+declare const CustomComponentSchema: ObjectSchema<{
     /**
      * The name of the user-defined component.
      * @example
      * "Link"
      */
-    readonly name: valibot.StringSchema<undefined>;
+    readonly name: StringSchema<undefined>;
     /**
      * The ESQuery selector to select the component precisely.
      * @example
      * `JSXElement:has(JSXAttribute[name.name='component'][value.value='a'])`
      */
-    readonly selector: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
+    readonly selector: OptionalSchema<StringSchema<undefined>, never>;
     /**
      * The name of the built-in component that the user-defined component represents.
      * @example
      * "a"
      */
-    readonly as: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
+    readonly as: OptionalSchema<StringSchema<undefined>, never>;
     /**
      * Pre-defined attributes that are used in the user-defined component.
      * @example
      * `Link` component has a `to` attribute that represents the `href` attribute in the built-in `a` element with a default value of `"/"`.
      */
-    readonly attributes: valibot.OptionalSchema<valibot.ArraySchema<valibot.ObjectSchema<{
+    readonly attributes: OptionalSchema<ArraySchema<ObjectSchema<{
         /**
          * The name of the attribute in the user-defined component.
          * @example
          * "to"
          */
-        readonly name: valibot.StringSchema<undefined>;
+        readonly name: StringSchema<undefined>;
         /**
          * The name of the attribute in the built-in component.
          * @example
          * "href"
          */
-        readonly as: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
+        readonly as: OptionalSchema<StringSchema<undefined>, never>;
         /**
          * Whether the attribute is controlled or not in the user-defined component.
          * @example
          * `true`
          */
-        readonly controlled: valibot.OptionalSchema<valibot.BooleanSchema<undefined>, never>;
+        readonly controlled: OptionalSchema<BooleanSchema<undefined>, never>;
         /**
          * The default value of the attribute in the user-defined component.
          * @example
          * `"/"`
          */
-        readonly defaultValue: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
+        readonly defaultValue: OptionalSchema<StringSchema<undefined>, never>;
     }, undefined>, undefined>, readonly []>;
 }, undefined>;
 /**
  * @internal
  */
-declare const ESLintReactSettingsSchema: valibot.ObjectSchema<{
-    readonly importSource: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
-    readonly jsxPragma: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
-    readonly jsxPragmaFrag: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
-    readonly polymorphicPropName: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
-    readonly strict: valibot.OptionalSchema<valibot.BooleanSchema<undefined>, never>;
-    readonly version: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
-    readonly additionalComponents: valibot.OptionalSchema<valibot.ArraySchema<valibot.ObjectSchema<{
+declare const ESLintReactSettingsSchema: ObjectSchema<{
+    readonly importSource: OptionalSchema<StringSchema<undefined>, never>;
+    readonly jsxPragma: OptionalSchema<StringSchema<undefined>, never>;
+    readonly jsxPragmaFrag: OptionalSchema<StringSchema<undefined>, never>;
+    readonly polymorphicPropName: OptionalSchema<StringSchema<undefined>, never>;
+    readonly strict: OptionalSchema<BooleanSchema<undefined>, never>;
+    readonly version: OptionalSchema<StringSchema<undefined>, never>;
+    readonly additionalComponents: OptionalSchema<ArraySchema<ObjectSchema<{
         /**
          * The name of the user-defined component.
          * @example
          * "Link"
          */
-        readonly name: valibot.StringSchema<undefined>;
+        readonly name: StringSchema<undefined>;
         /**
          * The ESQuery selector to select the component precisely.
          * @example
          * `JSXElement:has(JSXAttribute[name.name='component'][value.value='a'])`
          */
-        readonly selector: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
+        readonly selector: OptionalSchema<StringSchema<undefined>, never>;
         /**
          * The name of the built-in component that the user-defined component represents.
          * @example
          * "a"
          */
-        readonly as: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
+        readonly as: OptionalSchema<StringSchema<undefined>, never>;
         /**
          * Pre-defined attributes that are used in the user-defined component.
          * @example
          * `Link` component has a `to` attribute that represents the `href` attribute in the built-in `a` element with a default value of `"/"`.
          */
-        readonly attributes: valibot.OptionalSchema<valibot.ArraySchema<valibot.ObjectSchema<{
+        readonly attributes: OptionalSchema<ArraySchema<ObjectSchema<{
             /**
              * The name of the attribute in the user-defined component.
              * @example
              * "to"
              */
-            readonly name: valibot.StringSchema<undefined>;
+            readonly name: StringSchema<undefined>;
             /**
              * The name of the attribute in the built-in component.
              * @example
              * "href"
              */
-            readonly as: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
+            readonly as: OptionalSchema<StringSchema<undefined>, never>;
             /**
              * Whether the attribute is controlled or not in the user-defined component.
              * @example
              * `true`
              */
-            readonly controlled: valibot.OptionalSchema<valibot.BooleanSchema<undefined>, never>;
+            readonly controlled: OptionalSchema<BooleanSchema<undefined>, never>;
             /**
              * The default value of the attribute in the user-defined component.
              * @example
              * `"/"`
              */
-            readonly defaultValue: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
+            readonly defaultValue: OptionalSchema<StringSchema<undefined>, never>;
         }, undefined>, undefined>, readonly []>;
     }, undefined>, undefined>, never>;
-    readonly additionalHooks: valibot.OptionalSchema<valibot.ObjectSchema<{
-        readonly use: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-        readonly useActionState: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-        readonly useCallback: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-        readonly useContext: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-        readonly useDebugValue: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-        readonly useDeferredValue: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-        readonly useEffect: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-        readonly useId: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-        readonly useImperativeHandle: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-        readonly useInsertionEffect: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-        readonly useLayoutEffect: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-        readonly useMemo: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-        readonly useOptimistic: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-        readonly useReducer: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-        readonly useRef: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-        readonly useState: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-        readonly useSyncExternalStore: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-        readonly useTransition: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
+    readonly additionalHooks: OptionalSchema<ObjectSchema<{
+        readonly use: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+        readonly useActionState: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+        readonly useCallback: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+        readonly useContext: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+        readonly useDebugValue: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+        readonly useDeferredValue: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+        readonly useEffect: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+        readonly useId: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+        readonly useImperativeHandle: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+        readonly useInsertionEffect: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+        readonly useLayoutEffect: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+        readonly useMemo: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+        readonly useOptimistic: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+        readonly useReducer: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+        readonly useRef: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+        readonly useState: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+        readonly useSyncExternalStore: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+        readonly useTransition: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
     }, undefined>, never>;
 }, undefined>;
 /**
  * @internal
  */
-declare const ESLintSettingsSchema: valibot.OptionalSchema<valibot.ObjectSchema<{
-    readonly "react-x": valibot.OptionalSchema<valibot.ObjectSchema<{
-        readonly importSource: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
-        readonly jsxPragma: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
-        readonly jsxPragmaFrag: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
-        readonly polymorphicPropName: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
-        readonly strict: valibot.OptionalSchema<valibot.BooleanSchema<undefined>, never>;
-        readonly version: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
-        readonly additionalComponents: valibot.OptionalSchema<valibot.ArraySchema<valibot.ObjectSchema<{
+declare const ESLintSettingsSchema: OptionalSchema<ObjectSchema<{
+    readonly "react-x": OptionalSchema<ObjectSchema<{
+        readonly importSource: OptionalSchema<StringSchema<undefined>, never>;
+        readonly jsxPragma: OptionalSchema<StringSchema<undefined>, never>;
+        readonly jsxPragmaFrag: OptionalSchema<StringSchema<undefined>, never>;
+        readonly polymorphicPropName: OptionalSchema<StringSchema<undefined>, never>;
+        readonly strict: OptionalSchema<BooleanSchema<undefined>, never>;
+        readonly version: OptionalSchema<StringSchema<undefined>, never>;
+        readonly additionalComponents: OptionalSchema<ArraySchema<ObjectSchema<{
             /**
              * The name of the user-defined component.
              * @example
              * "Link"
              */
-            readonly name: valibot.StringSchema<undefined>;
+            readonly name: StringSchema<undefined>;
             /**
              * The ESQuery selector to select the component precisely.
              * @example
              * `JSXElement:has(JSXAttribute[name.name='component'][value.value='a'])`
              */
-            readonly selector: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
+            readonly selector: OptionalSchema<StringSchema<undefined>, never>;
             /**
              * The name of the built-in component that the user-defined component represents.
              * @example
              * "a"
              */
-            readonly as: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
+            readonly as: OptionalSchema<StringSchema<undefined>, never>;
             /**
              * Pre-defined attributes that are used in the user-defined component.
              * @example
              * `Link` component has a `to` attribute that represents the `href` attribute in the built-in `a` element with a default value of `"/"`.
              */
-            readonly attributes: valibot.OptionalSchema<valibot.ArraySchema<valibot.ObjectSchema<{
+            readonly attributes: OptionalSchema<ArraySchema<ObjectSchema<{
                 /**
                  * The name of the attribute in the user-defined component.
                  * @example
                  * "to"
                  */
-                readonly name: valibot.StringSchema<undefined>;
+                readonly name: StringSchema<undefined>;
                 /**
                  * The name of the attribute in the built-in component.
                  * @example
                  * "href"
                  */
-                readonly as: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
+                readonly as: OptionalSchema<StringSchema<undefined>, never>;
                 /**
                  * Whether the attribute is controlled or not in the user-defined component.
                  * @example
                  * `true`
                  */
-                readonly controlled: valibot.OptionalSchema<valibot.BooleanSchema<undefined>, never>;
+                readonly controlled: OptionalSchema<BooleanSchema<undefined>, never>;
                 /**
                  * The default value of the attribute in the user-defined component.
                  * @example
                  * `"/"`
                  */
-                readonly defaultValue: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
+                readonly defaultValue: OptionalSchema<StringSchema<undefined>, never>;
             }, undefined>, undefined>, readonly []>;
         }, undefined>, undefined>, never>;
-        readonly additionalHooks: valibot.OptionalSchema<valibot.ObjectSchema<{
-            readonly use: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-            readonly useActionState: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-            readonly useCallback: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-            readonly useContext: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-            readonly useDebugValue: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-            readonly useDeferredValue: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-            readonly useEffect: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-            readonly useId: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-            readonly useImperativeHandle: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-            readonly useInsertionEffect: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-            readonly useLayoutEffect: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-            readonly useMemo: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-            readonly useOptimistic: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-            readonly useReducer: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-            readonly useRef: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-            readonly useState: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-            readonly useSyncExternalStore: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-            readonly useTransition: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
+        readonly additionalHooks: OptionalSchema<ObjectSchema<{
+            readonly use: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+            readonly useActionState: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+            readonly useCallback: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+            readonly useContext: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+            readonly useDebugValue: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+            readonly useDeferredValue: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+            readonly useEffect: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+            readonly useId: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+            readonly useImperativeHandle: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+            readonly useInsertionEffect: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+            readonly useLayoutEffect: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+            readonly useMemo: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+            readonly useOptimistic: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+            readonly useReducer: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+            readonly useRef: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+            readonly useState: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+            readonly useSyncExternalStore: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+            readonly useTransition: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
         }, undefined>, never>;
     }, undefined>, never>;
     /**
      * @internal
      * @deprecated
      */
-    readonly reactOptions: valibot.OptionalSchema<valibot.ObjectSchema<{
-        readonly importSource: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
-        readonly jsxPragma: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
-        readonly jsxPragmaFrag: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
-        readonly polymorphicPropName: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
-        readonly strict: valibot.OptionalSchema<valibot.BooleanSchema<undefined>, never>;
-        readonly version: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
-        readonly additionalComponents: valibot.OptionalSchema<valibot.ArraySchema<valibot.ObjectSchema<{
+    readonly reactOptions: OptionalSchema<ObjectSchema<{
+        readonly importSource: OptionalSchema<StringSchema<undefined>, never>;
+        readonly jsxPragma: OptionalSchema<StringSchema<undefined>, never>;
+        readonly jsxPragmaFrag: OptionalSchema<StringSchema<undefined>, never>;
+        readonly polymorphicPropName: OptionalSchema<StringSchema<undefined>, never>;
+        readonly strict: OptionalSchema<BooleanSchema<undefined>, never>;
+        readonly version: OptionalSchema<StringSchema<undefined>, never>;
+        readonly additionalComponents: OptionalSchema<ArraySchema<ObjectSchema<{
             /**
              * The name of the user-defined component.
              * @example
              * "Link"
              */
-            readonly name: valibot.StringSchema<undefined>;
+            readonly name: StringSchema<undefined>;
             /**
              * The ESQuery selector to select the component precisely.
              * @example
              * `JSXElement:has(JSXAttribute[name.name='component'][value.value='a'])`
              */
-            readonly selector: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
+            readonly selector: OptionalSchema<StringSchema<undefined>, never>;
             /**
              * The name of the built-in component that the user-defined component represents.
              * @example
              * "a"
              */
-            readonly as: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
+            readonly as: OptionalSchema<StringSchema<undefined>, never>;
             /**
              * Pre-defined attributes that are used in the user-defined component.
              * @example
              * `Link` component has a `to` attribute that represents the `href` attribute in the built-in `a` element with a default value of `"/"`.
              */
-            readonly attributes: valibot.OptionalSchema<valibot.ArraySchema<valibot.ObjectSchema<{
+            readonly attributes: OptionalSchema<ArraySchema<ObjectSchema<{
                 /**
                  * The name of the attribute in the user-defined component.
                  * @example
                  * "to"
                  */
-                readonly name: valibot.StringSchema<undefined>;
+                readonly name: StringSchema<undefined>;
                 /**
                  * The name of the attribute in the built-in component.
                  * @example
                  * "href"
                  */
-                readonly as: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
+                readonly as: OptionalSchema<StringSchema<undefined>, never>;
                 /**
                  * Whether the attribute is controlled or not in the user-defined component.
                  * @example
                  * `true`
                  */
-                readonly controlled: valibot.OptionalSchema<valibot.BooleanSchema<undefined>, never>;
+                readonly controlled: OptionalSchema<BooleanSchema<undefined>, never>;
                 /**
                  * The default value of the attribute in the user-defined component.
                  * @example
                  * `"/"`
                  */
-                readonly defaultValue: valibot.OptionalSchema<valibot.StringSchema<undefined>, never>;
+                readonly defaultValue: OptionalSchema<StringSchema<undefined>, never>;
             }, undefined>, undefined>, readonly []>;
         }, undefined>, undefined>, never>;
-        readonly additionalHooks: valibot.OptionalSchema<valibot.ObjectSchema<{
-            readonly use: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-            readonly useActionState: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-            readonly useCallback: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-            readonly useContext: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-            readonly useDebugValue: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-            readonly useDeferredValue: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-            readonly useEffect: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-            readonly useId: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-            readonly useImperativeHandle: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-            readonly useInsertionEffect: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-            readonly useLayoutEffect: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-            readonly useMemo: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-            readonly useOptimistic: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-            readonly useReducer: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-            readonly useRef: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-            readonly useState: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-            readonly useSyncExternalStore: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
-            readonly useTransition: valibot.OptionalSchema<valibot.ArraySchema<valibot.StringSchema<undefined>, undefined>, never>;
+        readonly additionalHooks: OptionalSchema<ObjectSchema<{
+            readonly use: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+            readonly useActionState: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+            readonly useCallback: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+            readonly useContext: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+            readonly useDebugValue: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+            readonly useDeferredValue: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+            readonly useEffect: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+            readonly useId: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+            readonly useImperativeHandle: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+            readonly useInsertionEffect: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+            readonly useLayoutEffect: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+            readonly useMemo: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+            readonly useOptimistic: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+            readonly useReducer: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+            readonly useRef: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+            readonly useState: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+            readonly useSyncExternalStore: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
+            readonly useTransition: OptionalSchema<ArraySchema<StringSchema<undefined>, undefined>, never>;
         }, undefined>, never>;
     }, undefined>, never>;
 }, undefined>, {}>;
-interface CustomHook extends InferOutput<typeof CustomHookSchema> {
+type CustomHook = InferOutput<typeof CustomHookSchema>;
+type CustomAttribute = InferOutput<typeof CustomAttributeSchema>;
+type CustomComponent = InferOutput<typeof CustomComponentSchema>;
+type ESLintReactSettings = InferOutput<typeof ESLintReactSettingsSchema>;
+type ESLintSettings = InferOutput<typeof ESLintSettingsSchema>;
+
+interface Dictionary<Type> {
+  [key: string]: Type;
+  [index: number]: Type;
 }
-interface CustomAttribute extends InferOutput<typeof CustomAttributeSchema> {
+
+type AnyFn = (...args: any[]) => any;
+
+type Key = any[];
+type RawKey = Key | IArguments;
+type Value = any;
+
+interface CacheSnapshot {
+  keys: Key[];
+  size: number;
+  values: Value[];
 }
-interface CustomComponent extends InferOutput<typeof CustomComponentSchema> {
+
+declare class Cache<Fn extends AnyFn> {
+  readonly canTransformKey: boolean;
+  readonly getKeyIndex: KeyIndexGetter;
+  readonly options: NormalizedOptions<Fn>;
+  readonly shouldCloneArguments: boolean;
+  readonly shouldUpdateOnAdd: boolean;
+  readonly shouldUpdateOnChange: boolean;
+  readonly shouldUpdateOnHit: boolean;
+
+  /**
+   * The prevents call arguments which have cached results.
+   */
+  keys: Key[];
+  /**
+   * The results of previous cached calls.
+   */
+  values: Value[];
+
+  constructor(options: NormalizedOptions<Fn>);
+
+  /**
+   * The number of cached [key,value] results.
+   */
+  get size(): number;
+
+  /**
+   * A copy of the cache at a moment in time. This is useful
+   * to compare changes over time, since the cache mutates
+   * internally for performance reasons.
+   */
+  get snapshot(): CacheSnapshot;
+
+  /**
+   * Order the array based on a Least-Recently-Used basis.
+   */
+  orderByLru(key: Key, value: Value, startingIndex: number): void;
+
+  /**
+   * Update the promise method to auto-remove from cache if rejected, and
+   * if resolved then fire cache hit / changed.
+   */
+  updateAsyncCache(memoized: Memoized<Fn>): void;
 }
-interface ESLintReactSettings extends InferOutput<typeof ESLintReactSettingsSchema> {
+
+type EqualityComparator = (object1: any, object2: any) => boolean;
+
+type MatchingKeyComparator = (key1: Key, key2: RawKey) => boolean;
+
+type CacheModifiedHandler<Fn extends AnyFn> = (
+  cache: Cache<Fn>,
+  options: NormalizedOptions<Fn>,
+  memoized: Memoized<Fn>,
+) => void;
+
+type KeyTransformer = (args: Key) => Key;
+
+type KeyIndexGetter = (keyToMatch: RawKey) => number;
+
+interface StandardOptions<Fn extends AnyFn> {
+  isEqual?: EqualityComparator;
+  isMatchingKey?: MatchingKeyComparator;
+  isPromise?: boolean;
+  maxSize?: number;
+  onCacheAdd?: CacheModifiedHandler<Fn>;
+  onCacheChange?: CacheModifiedHandler<Fn>;
+  onCacheHit?: CacheModifiedHandler<Fn>;
+  transformKey?: KeyTransformer;
 }
-interface ESLintSettings extends InferOutput<typeof ESLintSettingsSchema> {
+
+interface Options<Fn extends AnyFn>
+  extends StandardOptions<Fn>,
+    Dictionary<any> {}
+
+interface NormalizedOptions<Fn extends AnyFn> extends Options<Fn> {
+  isEqual: EqualityComparator;
+  isPromise: boolean;
+  maxSize: number;
 }
 
+type Memoized<Fn extends AnyFn> = Fn &
+  Dictionary<any> & {
+    cache: Cache<Fn>;
+    fn: Fn;
+    isMemoized: true;
+    options: NormalizedOptions<Fn>;
+  };
+
 /**
  * This is an expanded version of `CustomComponent` with all shorthand properties expanded.
  * @internal
@@ -453,7 +1968,7 @@ declare function decodeSettings(data: unknown): ESLintReactSettings;
  * @returns The expanded settings.
  * @internal
  */
-declare const expandSettings: micro_memoize.Memoized<(settings: ESLintReactSettings) => ESLintReactSettingsExpanded>;
+declare const expandSettings: Memoized<(settings: ESLintReactSettings) => ESLintReactSettingsExpanded>;
 /**
  * The default ESLint settings for "react-x".
  */