@eslint-react/shared 1.15.0-next.9 → 1.15.1-beta.2

package/dist/index.d.mts

@@ -52,508 +52,364 @@ declare const REACT_BUILD_IN_HOOKS: readonly ["useActionState", "useCallback", "
 declare const createRuleForPlugin: (pluginName: string) => <Options extends readonly unknown[], MessageIds extends string>({ meta, name, ...rule }: Readonly<ESLintUtils.RuleWithMetaAndName<Options, MessageIds, unknown>>) => ESLintUtils.RuleModule<MessageIds, Options, unknown, ESLintUtils.RuleListener>;
 
 /**
- * Array issue type.
+ * Schema with pipe type.
  */
-interface ArrayIssue extends BaseIssue<unknown> {
+type SchemaWithPipe<TPipe extends [
+    BaseSchema<unknown, unknown, BaseIssue<unknown>>,
+    ...PipeItem<any, unknown, BaseIssue<unknown>>[]
+]> = Omit<FirstTupleItem<TPipe>, '~types' | '~validate'> & {
     /**
-     * The issue kind.
+     * The pipe items.
      */
-    readonly kind: 'schema';
+    readonly pipe: TPipe;
     /**
-     * The issue type.
+     * The input, output and issue type.
+     *
+     * @internal
      */
-    readonly type: 'array';
+    readonly '~types'?: {
+        readonly input: InferInput<FirstTupleItem<TPipe>>;
+        readonly output: InferOutput<LastTupleItem<TPipe>>;
+        readonly issue: InferIssue<TPipe[number]>;
+    } | undefined;
     /**
-     * The expected property.
+     * Parses unknown input values.
+     *
+     * @param dataset The input dataset.
+     * @param config The configuration.
+     *
+     * @returns The output dataset.
+     *
+     * @internal
      */
-    readonly expected: 'Array';
-}
+    readonly '~validate': (dataset: UnknownDataset, config?: Config<BaseIssue<unknown>>) => OutputDataset<InferOutput<LastTupleItem<TPipe>>, InferIssue<TPipe[number]>>;
+};
 
 /**
- * Array schema type.
+ * Schema with pipe async type.
  */
-interface ArraySchema<TItem extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TMessage extends ErrorMessage<ArrayIssue> | undefined> extends BaseSchema<InferInput<TItem>[], InferOutput<TItem>[], ArrayIssue | InferIssue<TItem>> {
+type SchemaWithPipeAsync<TPipe extends [
+    (BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>),
+    ...(PipeItem<any, unknown, BaseIssue<unknown>> | PipeItemAsync<any, unknown, BaseIssue<unknown>>)[]
+]> = Omit<FirstTupleItem<TPipe>, 'async' | '~types' | '~validate'> & {
     /**
-     * The schema type.
+     * The pipe items.
      */
-    readonly type: 'array';
+    readonly pipe: TPipe;
     /**
-     * The schema reference.
+     * Whether it's async.
      */
-    readonly reference: typeof array;
+    readonly async: true;
     /**
-     * The expected property.
+     * The input, output and issue type.
+     *
+     * @internal
      */
-    readonly expects: 'Array';
+    readonly '~types'?: {
+        readonly input: InferInput<FirstTupleItem<TPipe>>;
+        readonly output: InferOutput<LastTupleItem<TPipe>>;
+        readonly issue: InferIssue<TPipe[number]>;
+    } | undefined;
     /**
-     * The array item schema.
+     * Parses unknown input values.
+     *
+     * @param dataset The input dataset.
+     * @param config The configuration.
+     *
+     * @returns The output dataset.
+     *
+     * @internal
      */
-    readonly item: TItem;
+    readonly '~validate': (dataset: UnknownDataset, config?: Config<BaseIssue<unknown>>) => Promise<OutputDataset<InferOutput<LastTupleItem<TPipe>>, InferIssue<TPipe[number]>>>;
+};
+
+/**
+ * Base metadata type.
+ */
+interface BaseMetadata<TInput> {
     /**
-     * The error message.
+     * The object kind.
      */
-    readonly message: TMessage;
+    readonly kind: 'metadata';
+    /**
+     * The metadata type.
+     */
+    readonly type: string;
+    /**
+     * The metadata reference.
+     */
+    readonly reference: (...args: any[]) => BaseMetadata<any>;
+    /**
+     * The input, output and issue type.
+     *
+     * @internal
+     */
+    readonly '~types'?: {
+        readonly input: TInput;
+        readonly output: TInput;
+        readonly issue: never;
+    } | undefined;
 }
-/**
- * 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.
+ * Unknown dataset type.
  */
-interface BooleanIssue extends BaseIssue<unknown> {
+interface UnknownDataset {
     /**
-     * The issue kind.
+     * Whether is's typed.
      */
-    readonly kind: 'schema';
+    typed?: false;
     /**
-     * The issue type.
+     * The dataset value.
      */
-    readonly type: 'boolean';
+    value: unknown;
     /**
-     * The expected property.
+     * The dataset issues.
      */
-    readonly expected: 'boolean';
+    issues?: undefined;
 }
 /**
- * Boolean schema type.
+ * Success dataset type.
  */
-interface BooleanSchema<TMessage extends ErrorMessage<BooleanIssue> | undefined> extends BaseSchema<boolean, boolean, BooleanIssue> {
-    /**
-     * The schema type.
-     */
-    readonly type: 'boolean';
+interface SuccessDataset<TValue> {
     /**
-     * The schema reference.
+     * Whether is's typed.
      */
-    readonly reference: typeof boolean;
+    typed: true;
     /**
-     * The expected property.
+     * The dataset value.
      */
-    readonly expects: 'boolean';
+    value: TValue;
     /**
-     * The error message.
+     * The dataset issues.
      */
-    readonly message: TMessage;
+    issues?: undefined;
 }
 /**
- * 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>;
-
-/**
- * Class type.
- */
-type Class = new (...args: any[]) => any;
-/**
- * Instance issue type.
+ * Partial dataset type.
  */
-interface InstanceIssue extends BaseIssue<unknown> {
+interface PartialDataset<TValue, TIssue extends BaseIssue<unknown>> {
     /**
-     * The issue kind.
+     * Whether is's typed.
      */
-    readonly kind: 'schema';
+    typed: true;
     /**
-     * The issue type.
+     * The dataset value.
      */
-    readonly type: 'instance';
+    value: TValue;
     /**
-     * The expected property.
+     * The dataset issues.
      */
-    readonly expected: string;
+    issues: [TIssue, ...TIssue[]];
 }
 /**
- * Instance schema type.
+ * Failure dataset type.
  */
-interface InstanceSchema<TClass extends Class, TMessage extends ErrorMessage<InstanceIssue> | undefined> extends BaseSchema<InstanceType<TClass>, InstanceType<TClass>, InstanceIssue> {
-    /**
-     * The schema type.
-     */
-    readonly type: 'instance';
+interface FailureDataset<TIssue extends BaseIssue<unknown>> {
     /**
-     * The schema reference.
+     * Whether is's typed.
      */
-    readonly reference: typeof instance;
+    typed: false;
     /**
-     * The class of the instance.
+     * The dataset value.
      */
-    readonly class: TClass;
+    value: unknown;
     /**
-     * The error message.
+     * The dataset issues.
      */
-    readonly message: TMessage;
+    issues: [TIssue, ...TIssue[]];
 }
 /**
- * Creates an instance schema.
- *
- * @param class_ The class of the instance.
- *
- * @returns An instance schema.
- */
-declare function instance<TClass extends Class>(class_: TClass): InstanceSchema<TClass, undefined>;
-/**
- * Creates an instance schema.
- *
- * @param class_ The class of the instance.
- * @param message The error message.
- *
- * @returns An instance schema.
- */
-declare function instance<TClass extends Class, const TMessage extends ErrorMessage<InstanceIssue> | undefined>(class_: TClass, message: TMessage): InstanceSchema<TClass, TMessage>;
-
-/**
- * Infer nullish output type.
+ * Output dataset 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>;
+type OutputDataset<TValue, TIssue extends BaseIssue<unknown>> = SuccessDataset<TValue> | PartialDataset<TValue, TIssue> | FailureDataset<TIssue>;
 
 /**
- * Nullish schema type.
+ * Base 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>> {
+interface BaseSchema<TInput, TOutput, TIssue extends BaseIssue<unknown>> {
+    /**
+     * The object kind.
+     */
+    readonly kind: 'schema';
     /**
      * The schema type.
      */
-    readonly type: 'nullish';
+    readonly type: string;
     /**
      * The schema reference.
      */
-    readonly reference: typeof nullish;
+    readonly reference: (...args: any[]) => BaseSchema<unknown, unknown, BaseIssue<unknown>>;
     /**
      * The expected property.
      */
-    readonly expects: `(${TWrapped['expects']} | null | undefined)`;
+    readonly expects: string;
     /**
-     * The wrapped schema.
+     * Whether it's async.
      */
-    readonly wrapped: TWrapped;
+    readonly async: false;
     /**
-     * The default value.
+     * The Standard Schema version number.
+     *
+     * @internal
      */
-    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;
+    readonly '~standard': 1;
     /**
-     * The expected property.
+     * The vendor name of the schema.
+     *
+     * @internal
      */
-    readonly expects: `(${TWrapped['expects']} | null | undefined)`;
+    readonly '~vendor': 'valibot';
     /**
-     * The wrapped schema.
+     * The input, output and issue type.
+     *
+     * @internal
      */
-    readonly wrapped: TWrapped;
+    readonly '~types'?: {
+        readonly input: TInput;
+        readonly output: TOutput;
+        readonly issue: TIssue;
+    } | undefined;
     /**
-     * The default value.
+     * Parses unknown input values.
+     *
+     * @param dataset The input dataset.
+     * @param config The configuration.
+     *
+     * @returns The output dataset.
+     *
+     * @internal
      */
-    readonly default: TDefault;
+    readonly '~validate': (dataset: UnknownDataset, config?: Config<BaseIssue<unknown>>) => OutputDataset<TOutput, TIssue>;
 }
 /**
- * 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.
+ * Base schema async type.
  */
-interface ObjectIssue extends BaseIssue<unknown> {
+interface BaseSchemaAsync<TInput, TOutput, TIssue extends BaseIssue<unknown>> extends Omit<BaseSchema<TInput, TOutput, TIssue>, 'reference' | 'async' | '~validate'> {
     /**
-     * The issue kind.
+     * The schema reference.
      */
-    readonly kind: 'schema';
+    readonly reference: (...args: any[]) => BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>;
     /**
-     * The issue type.
+     * Whether it's async.
      */
-    readonly type: 'object';
+    readonly async: true;
     /**
-     * The expected property.
+     * Parses unknown input values.
+     *
+     * @param dataset The input dataset.
+     * @param config The configuration.
+     *
+     * @returns The output dataset.
+     *
+     * @internal
      */
-    readonly expected: 'Object';
+    readonly '~validate': (dataset: UnknownDataset, config?: Config<BaseIssue<unknown>>) => Promise<OutputDataset<TOutput, TIssue>>;
 }
 
 /**
- * Object schema type.
+ * Base transformation type.
  */
-interface ObjectSchema<TEntries extends ObjectEntries, TMessage extends ErrorMessage<ObjectIssue> | undefined> extends BaseSchema<InferObjectInput<TEntries>, InferObjectOutput<TEntries>, ObjectIssue | InferObjectIssue<TEntries>> {
+interface BaseTransformation<TInput, TOutput, TIssue extends BaseIssue<unknown>> {
     /**
-     * The schema type.
+     * The object kind.
      */
-    readonly type: 'object';
+    readonly kind: 'transformation';
     /**
-     * The schema reference.
+     * The transformation type.
      */
-    readonly reference: typeof object;
+    readonly type: string;
     /**
-     * The expected property.
+     * The transformation reference.
      */
-    readonly expects: 'Object';
+    readonly reference: (...args: any[]) => BaseTransformation<any, any, BaseIssue<unknown>>;
     /**
-     * The entries schema.
+     * Whether it's async.
      */
-    readonly entries: TEntries;
+    readonly async: false;
     /**
-     * The error message.
+     * The input, output and issue type.
+     *
+     * @internal
      */
-    readonly message: TMessage;
+    readonly '~types'?: {
+        readonly input: TInput;
+        readonly output: TOutput;
+        readonly issue: TIssue;
+    } | undefined;
+    /**
+     * Transforms known input values.
+     *
+     * @param dataset The input dataset.
+     * @param config The configuration.
+     *
+     * @returns The output dataset.
+     *
+     * @internal
+     */
+    readonly '~validate': (dataset: SuccessDataset<TInput>, config: Config<BaseIssue<unknown>>) => OutputDataset<TOutput, BaseIssue<unknown> | TIssue>;
 }
 /**
- * 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.
+ * Base transformation async 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;
+interface BaseTransformationAsync<TInput, TOutput, TIssue extends BaseIssue<unknown>> extends Omit<BaseTransformation<TInput, TOutput, TIssue>, 'reference' | 'async' | '~validate'> {
     /**
-     * The expected property.
+     * The transformation reference.
      */
-    readonly expects: `(${TWrapped['expects']} | undefined)`;
+    readonly reference: (...args: any[]) => BaseTransformation<any, any, BaseIssue<unknown>> | BaseTransformationAsync<any, any, BaseIssue<unknown>>;
     /**
-     * The wrapped schema.
+     * Whether it's async.
      */
-    readonly wrapped: TWrapped;
+    readonly async: true;
     /**
-     * The default value.
+     * Transforms known input values.
+     *
+     * @param dataset The input dataset.
+     * @param config The configuration.
+     *
+     * @returns The output dataset.
+     *
+     * @internal
      */
-    readonly default: TDefault;
+    readonly '~validate': (dataset: SuccessDataset<TInput>, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<TOutput, BaseIssue<unknown> | TIssue>>;
 }
-/**
- * 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.
+ * Base validation 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>> {
+interface BaseValidation<TInput, TOutput, TIssue extends BaseIssue<unknown>> {
     /**
-     * The schema type.
+     * The object kind.
      */
-    readonly type: 'optional';
+    readonly kind: 'validation';
     /**
-     * The schema reference.
+     * The validation type.
      */
-    readonly reference: typeof optionalAsync;
+    readonly type: string;
+    /**
+     * The validation reference.
+     */
+    readonly reference: (...args: any[]) => BaseValidation<any, any, BaseIssue<unknown>>;
     /**
      * The expected property.
      */
-    readonly expects: `(${TWrapped['expects']} | undefined)`;
+    readonly expects: string | null;
     /**
-     * The wrapped schema.
+     * Whether it's async.
      */
-    readonly wrapped: TWrapped;
+    readonly async: false;
     /**
-     * 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>;
-
-/**
- * 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>;
-
-/**
- * Schema with pipe type.
- */
-type SchemaWithPipe<TPipe extends [
-    BaseSchema<unknown, unknown, BaseIssue<unknown>>,
-    ...PipeItem<any, unknown, BaseIssue<unknown>>[]
-]> = Omit<FirstTupleItem<TPipe>, '~types' | '~validate'> & {
-    /**
-     * The pipe items.
-     */
-    readonly pipe: TPipe;
-    /**
-     * The input, output and issue type.
-     *
-     * @internal
+     * The input, output and issue type.
+     *
+     * @internal
      */
     readonly '~types'?: {
-        readonly input: InferInput<FirstTupleItem<TPipe>>;
-        readonly output: InferOutput<LastTupleItem<TPipe>>;
-        readonly issue: InferIssue<TPipe[number]>;
+        readonly input: TInput;
+        readonly output: TOutput;
+        readonly issue: TIssue;
     } | undefined;
     /**
-     * Parses unknown input values.
+     * Validates known input values.
      *
      * @param dataset The input dataset.
      * @param config The configuration.
@@ -562,36 +418,22 @@ type SchemaWithPipe<TPipe extends [
      *
      * @internal
      */
-    readonly '~validate': (dataset: UnknownDataset, config?: Config<BaseIssue<unknown>>) => OutputDataset<InferOutput<LastTupleItem<TPipe>>, InferIssue<TPipe[number]>>;
-};
-
+    readonly '~validate': (dataset: OutputDataset<TInput, BaseIssue<unknown>>, config: Config<BaseIssue<unknown>>) => OutputDataset<TOutput, BaseIssue<unknown> | TIssue>;
+}
 /**
- * Schema with pipe async type.
+ * Base validation async type.
  */
-type SchemaWithPipeAsync<TPipe extends [
-    (BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>),
-    ...(PipeItem<any, unknown, BaseIssue<unknown>> | PipeItemAsync<any, unknown, BaseIssue<unknown>>)[]
-]> = Omit<FirstTupleItem<TPipe>, 'async' | '~types' | '~validate'> & {
+interface BaseValidationAsync<TInput, TOutput, TIssue extends BaseIssue<unknown>> extends Omit<BaseValidation<TInput, TOutput, TIssue>, 'reference' | 'async' | '~validate'> {
     /**
-     * The pipe items.
+     * The validation reference.
      */
-    readonly pipe: TPipe;
+    readonly reference: (...args: any[]) => BaseValidation<any, any, BaseIssue<unknown>> | BaseValidationAsync<any, any, BaseIssue<unknown>>;
     /**
      * Whether it's async.
      */
     readonly async: true;
     /**
-     * The input, output and issue type.
-     *
-     * @internal
-     */
-    readonly '~types'?: {
-        readonly input: InferInput<FirstTupleItem<TPipe>>;
-        readonly output: InferOutput<LastTupleItem<TPipe>>;
-        readonly issue: InferIssue<TPipe[number]>;
-    } | undefined;
-    /**
-     * Parses unknown input values.
+     * Validates known input values.
      *
      * @param dataset The input dataset.
      * @param config The configuration.
@@ -600,702 +442,860 @@ type SchemaWithPipeAsync<TPipe extends [
      *
      * @internal
      */
-    readonly '~validate': (dataset: UnknownDataset, config?: Config<BaseIssue<unknown>>) => Promise<OutputDataset<InferOutput<LastTupleItem<TPipe>>, InferIssue<TPipe[number]>>>;
-};
+    readonly '~validate': (dataset: OutputDataset<TInput, BaseIssue<unknown>>, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<TOutput, BaseIssue<unknown> | TIssue>>;
+}
 
 /**
- * Base metadata type.
+ * Infer input type.
  */
-interface BaseMetadata<TInput> {
-    /**
-     * The object kind.
-     */
-    readonly kind: 'metadata';
-    /**
-     * The metadata type.
-     */
-    readonly type: string;
-    /**
-     * The metadata reference.
-     */
-    readonly reference: (...args: any[]) => BaseMetadata<any>;
-    /**
-     * The input, output and issue type.
-     *
-     * @internal
-     */
-    readonly '~types'?: {
-        readonly input: TInput;
-        readonly output: TInput;
-        readonly issue: never;
-    } | undefined;
-}
+type InferInput<TItem extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>> | BaseValidation<any, unknown, BaseIssue<unknown>> | BaseValidationAsync<any, unknown, BaseIssue<unknown>> | BaseTransformation<any, unknown, BaseIssue<unknown>> | BaseTransformationAsync<any, unknown, BaseIssue<unknown>> | BaseMetadata<any>> = NonNullable<TItem['~types']>['input'];
+/**
+ * Infer output type.
+ */
+type InferOutput<TItem extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>> | BaseValidation<any, unknown, BaseIssue<unknown>> | BaseValidationAsync<any, unknown, BaseIssue<unknown>> | BaseTransformation<any, unknown, BaseIssue<unknown>> | BaseTransformationAsync<any, unknown, BaseIssue<unknown>> | BaseMetadata<any>> = NonNullable<TItem['~types']>['output'];
+/**
+ * Infer issue type.
+ */
+type InferIssue<TItem extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>> | BaseValidation<any, unknown, BaseIssue<unknown>> | BaseValidationAsync<any, unknown, BaseIssue<unknown>> | BaseTransformation<any, unknown, BaseIssue<unknown>> | BaseTransformationAsync<any, unknown, BaseIssue<unknown>> | BaseMetadata<any>> = NonNullable<TItem['~types']>['issue'];
+/**
+ * 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];
 
 /**
- * Unknown dataset type.
+ * Error message type.
  */
-interface UnknownDataset {
-    /**
-     * Whether is's typed.
-     */
-    typed?: false;
-    /**
-     * The dataset value.
-     */
-    value: unknown;
-    /**
-     * The dataset issues.
-     */
-    issues?: undefined;
-}
+type ErrorMessage<TIssue extends BaseIssue<unknown>> = ((issue: TIssue) => string) | string;
 /**
- * Success dataset type.
+ * Default type.
  */
-interface SuccessDataset<TValue> {
-    /**
-     * Whether is's typed.
-     */
-    typed: true;
-    /**
-     * The dataset value.
-     */
-    value: TValue;
-    /**
-     * The dataset issues.
-     */
-    issues?: undefined;
-}
+type Default<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TInput extends null | undefined> = MaybeReadonly<InferInput<TWrapped> | TInput> | ((dataset?: UnknownDataset, config?: Config<InferIssue<TWrapped>>) => MaybeReadonly<InferInput<TWrapped> | TInput>);
 /**
- * Partial dataset type.
+ * Default async type.
  */
-interface PartialDataset<TValue, TIssue extends BaseIssue<unknown>> {
-    /**
-     * Whether is's typed.
-     */
-    typed: true;
-    /**
-     * The dataset value.
-     */
-    value: TValue;
-    /**
-     * The dataset issues.
-     */
-    issues: [TIssue, ...TIssue[]];
+type DefaultAsync<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TInput extends null | undefined> = MaybeReadonly<InferInput<TWrapped> | TInput> | ((dataset?: UnknownDataset, 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?: UnknownDataset, config?: Config<InferIssue<TWrapped>>) => MaybePromise<InferInput<TWrapped> | TInput> ? Awaited<ReturnType<TDefault>> : TDefault : never;
+
+/**
+ * Object entries type.
+ */
+interface ObjectEntries {
+    [key: string]: BaseSchema<unknown, unknown, BaseIssue<unknown>>;
 }
 /**
- * Failure dataset type.
+ * Object entries async type.
  */
-interface FailureDataset<TIssue extends BaseIssue<unknown>> {
-    /**
-     * Whether is's typed.
-     */
-    typed: false;
-    /**
-     * The dataset value.
-     */
-    value: unknown;
-    /**
-     * The dataset issues.
-     */
-    issues: [TIssue, ...TIssue[]];
+interface ObjectEntriesAsync {
+    [key: string]: BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>;
 }
 /**
- * Output dataset type.
+ * 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 OutputDataset<TValue, TIssue extends BaseIssue<unknown>> = SuccessDataset<TValue> | PartialDataset<TValue, TIssue> | FailureDataset<TIssue>;
+type QuestionMarkSchema = NullishSchema<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown> | NullishSchemaAsync<BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, unknown> | OptionalSchema<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown> | OptionalSchemaAsync<BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, unknown>;
+/**
+ * Has default type.
+ */
+type HasDefault<TSchema extends QuestionMarkSchema> = [
+    TSchema['default']
+] extends [never] ? false : true;
+/**
+ * Exact optional input type.
+ */
+type ExactOptionalInput<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>> = TSchema extends OptionalSchema<infer TWrapped, never> | OptionalSchemaAsync<infer TWrapped, never> ? ExactOptionalInput<TWrapped> : InferInput<TSchema>;
+/**
+ * Exact optional output type.
+ */
+type ExactOptionalOutput<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>> = TSchema extends OptionalSchema<infer TWrapped, never> | OptionalSchemaAsync<infer TWrapped, never> ? HasDefault<TSchema> extends true ? InferOutput<TSchema> : ExactOptionalOutput<TWrapped> : InferOutput<TSchema>;
+/**
+ * Infer entries input type.
+ */
+type InferEntriesInput<TEntries extends ObjectEntries | ObjectEntriesAsync> = {
+    -readonly [TKey in keyof TEntries]: ExactOptionalInput<TEntries[TKey]>;
+};
+/**
+ * Infer entries output type.
+ */
+type InferEntriesOutput<TEntries extends ObjectEntries | ObjectEntriesAsync> = {
+    -readonly [TKey in keyof TEntries]: ExactOptionalOutput<TEntries[TKey]>;
+};
+/**
+ * Optional input keys type.
+ */
+type OptionalInputKeys<TEntries extends ObjectEntries | ObjectEntriesAsync> = {
+    [TKey in keyof TEntries]: TEntries[TKey] extends QuestionMarkSchema ? TKey : never;
+}[keyof TEntries];
+/**
+ * Optional output keys type.
+ */
+type OptionalOutputKeys<TEntries extends ObjectEntries | ObjectEntriesAsync> = {
+    [TKey in keyof TEntries]: TEntries[TKey] extends QuestionMarkSchema ? undefined extends InferOutput<TEntries[TKey]> ? HasDefault<TEntries[TKey]> extends false ? TKey : never : never : never;
+}[keyof TEntries];
+/**
+ * Input with question marks type.
+ */
+type InputWithQuestionMarks<TEntries extends ObjectEntries | ObjectEntriesAsync, TObject extends InferEntriesInput<TEntries> | InferEntriesOutput<TEntries>> = MarkOptional<TObject, OptionalInputKeys<TEntries>>;
+/**
+ * Output with question marks type.
+ */
+type OutputWithQuestionMarks<TEntries extends ObjectEntries | ObjectEntriesAsync, TObject extends InferEntriesInput<TEntries> | InferEntriesOutput<TEntries>> = MarkOptional<TObject, OptionalOutputKeys<TEntries>>;
+/**
+ * Readonly output keys type.
+ */
+type ReadonlyOutputKeys<TEntries extends ObjectEntries | ObjectEntriesAsync> = {
+    [TKey in keyof TEntries]: TEntries[TKey] extends SchemaWithPipe<infer TPipe> | SchemaWithPipeAsync<infer TPipe> ? ReadonlyAction<any> extends TPipe[number] ? TKey : never : never;
+}[keyof TEntries];
+/**
+ * Output with readonly type.
+ */
+type OutputWithReadonly<TEntries extends ObjectEntries | ObjectEntriesAsync, TObject extends OutputWithQuestionMarks<TEntries, InferEntriesOutput<TEntries>>> = Readonly<TObject> & Pick<TObject, Exclude<keyof TObject, ReadonlyOutputKeys<TEntries>>>;
+/**
+ * Infer object input type.
+ */
+type InferObjectInput<TEntries extends ObjectEntries | ObjectEntriesAsync> = Prettify<InputWithQuestionMarks<TEntries, InferEntriesInput<TEntries>>>;
+/**
+ * Infer object output type.
+ */
+type InferObjectOutput<TEntries extends ObjectEntries | ObjectEntriesAsync> = Prettify<OutputWithReadonly<TEntries, OutputWithQuestionMarks<TEntries, InferEntriesOutput<TEntries>>>>;
+/**
+ * Infer object issue type.
+ */
+type InferObjectIssue<TEntries extends ObjectEntries | ObjectEntriesAsync> = InferIssue<TEntries[keyof TEntries]>;
 
 /**
- * Base schema type.
+ * Array path item type.
  */
-interface BaseSchema<TInput, TOutput, TIssue extends BaseIssue<unknown>> {
+interface ArrayPathItem {
     /**
-     * The object kind.
+     * The path item type.
      */
-    readonly kind: 'schema';
+    readonly type: 'array';
     /**
-     * The schema type.
+     * The path item origin.
      */
-    readonly type: string;
+    readonly origin: 'value';
     /**
-     * The schema reference.
+     * The path item input.
      */
-    readonly reference: (...args: any[]) => BaseSchema<unknown, unknown, BaseIssue<unknown>>;
+    readonly input: MaybeReadonly<unknown[]>;
     /**
-     * The expected property.
+     * The path item key.
      */
-    readonly expects: string;
+    readonly key: number;
     /**
-     * Whether it's async.
+     * The path item value.
      */
-    readonly async: false;
+    readonly value: unknown;
+}
+/**
+ * Map path item type.
+ */
+interface MapPathItem {
     /**
-     * The Standard Schema version number.
-     *
-     * @internal
+     * The path item type.
      */
-    readonly '~standard': 1;
+    readonly type: 'map';
     /**
-     * The vendor name of the schema.
-     *
-     * @internal
+     * The path item origin.
      */
-    readonly '~vendor': 'valibot';
+    readonly origin: 'key' | 'value';
     /**
-     * The input, output and issue type.
-     *
-     * @internal
+     * The path item input.
      */
-    readonly '~types'?: {
-        readonly input: TInput;
-        readonly output: TOutput;
-        readonly issue: TIssue;
-    } | undefined;
+    readonly input: Map<unknown, unknown>;
     /**
-     * Parses unknown input values.
-     *
-     * @param dataset The input dataset.
-     * @param config The configuration.
-     *
-     * @returns The output dataset.
-     *
-     * @internal
+     * The path item key.
      */
-    readonly '~validate': (dataset: UnknownDataset, config?: Config<BaseIssue<unknown>>) => OutputDataset<TOutput, TIssue>;
+    readonly key: unknown;
+    /**
+     * The path item value.
+     */
+    readonly value: unknown;
 }
 /**
- * Base schema async type.
+ * Object path item type.
  */
-interface BaseSchemaAsync<TInput, TOutput, TIssue extends BaseIssue<unknown>> extends Omit<BaseSchema<TInput, TOutput, TIssue>, 'reference' | 'async' | '~validate'> {
+interface ObjectPathItem {
+    /**
+     * The path item type.
+     */
+    readonly type: 'object';
+    /**
+     * The path item origin.
+     */
+    readonly origin: 'key' | 'value';
     /**
-     * The schema reference.
+     * The path item input.
      */
-    readonly reference: (...args: any[]) => BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>;
+    readonly input: Record<string, unknown>;
     /**
-     * Whether it's async.
+     * The path item key.
      */
-    readonly async: true;
+    readonly key: string;
     /**
-     * Parses unknown input values.
-     *
-     * @param dataset The input dataset.
-     * @param config The configuration.
-     *
-     * @returns The output dataset.
-     *
-     * @internal
+     * The path item value.
      */
-    readonly '~validate': (dataset: UnknownDataset, config?: Config<BaseIssue<unknown>>) => Promise<OutputDataset<TOutput, TIssue>>;
+    readonly value: unknown;
 }
-
 /**
- * Base transformation type.
+ * Set path item type.
  */
-interface BaseTransformation<TInput, TOutput, TIssue extends BaseIssue<unknown>> {
-    /**
-     * The object kind.
-     */
-    readonly kind: 'transformation';
+interface SetPathItem {
     /**
-     * The transformation type.
+     * The path item type.
      */
-    readonly type: string;
+    readonly type: 'set';
     /**
-     * The transformation reference.
+     * The path item origin.
      */
-    readonly reference: (...args: any[]) => BaseTransformation<any, any, BaseIssue<unknown>>;
+    readonly origin: 'value';
     /**
-     * Whether it's async.
+     * The path item input.
      */
-    readonly async: false;
+    readonly input: Set<unknown>;
     /**
-     * The input, output and issue type.
-     *
-     * @internal
+     * The path item key.
      */
-    readonly '~types'?: {
-        readonly input: TInput;
-        readonly output: TOutput;
-        readonly issue: TIssue;
-    } | undefined;
+    readonly key: null;
     /**
-     * Transforms known input values.
-     *
-     * @param dataset The input dataset.
-     * @param config The configuration.
-     *
-     * @returns The output dataset.
-     *
-     * @internal
+     * The path item key.
      */
-    readonly '~validate': (dataset: SuccessDataset<TInput>, config: Config<BaseIssue<unknown>>) => OutputDataset<TOutput, BaseIssue<unknown> | TIssue>;
+    readonly value: unknown;
 }
 /**
- * Base transformation async type.
+ * Unknown path item type.
  */
-interface BaseTransformationAsync<TInput, TOutput, TIssue extends BaseIssue<unknown>> extends Omit<BaseTransformation<TInput, TOutput, TIssue>, 'reference' | 'async' | '~validate'> {
+interface UnknownPathItem {
     /**
-     * The transformation reference.
+     * The path item type.
      */
-    readonly reference: (...args: any[]) => BaseTransformation<any, any, BaseIssue<unknown>> | BaseTransformationAsync<any, any, BaseIssue<unknown>>;
+    readonly type: 'unknown';
     /**
-     * Whether it's async.
+     * The path item origin.
      */
-    readonly async: true;
+    readonly origin: 'key' | 'value';
     /**
-     * Transforms known input values.
-     *
-     * @param dataset The input dataset.
-     * @param config The configuration.
-     *
-     * @returns The output dataset.
-     *
-     * @internal
+     * The path item input.
      */
-    readonly '~validate': (dataset: SuccessDataset<TInput>, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<TOutput, BaseIssue<unknown> | TIssue>>;
+    readonly input: unknown;
+    /**
+     * The path item key.
+     */
+    readonly key: unknown;
+    /**
+     * The path item value.
+     */
+    readonly value: unknown;
 }
-
 /**
- * Base validation type.
+ * Issue path item type.
+ *
+ * TODO: Document that the input of the path may be different from the input of
+ * the issue.
  */
-interface BaseValidation<TInput, TOutput, TIssue extends BaseIssue<unknown>> {
+type IssuePathItem = ArrayPathItem | MapPathItem | ObjectPathItem | SetPathItem | UnknownPathItem;
+/**
+ * Base issue type.
+ */
+interface BaseIssue<TInput> extends Config<BaseIssue<TInput>> {
     /**
-     * The object kind.
+     * The issue kind.
      */
-    readonly kind: 'validation';
+    readonly kind: 'schema' | 'validation' | 'transformation';
     /**
-     * The validation type.
+     * The issue type.
      */
     readonly type: string;
     /**
-     * The validation reference.
+     * The raw input data.
      */
-    readonly reference: (...args: any[]) => BaseValidation<any, any, BaseIssue<unknown>>;
+    readonly input: TInput;
     /**
      * The expected property.
      */
-    readonly expects: string | null;
+    readonly expected: string | null;
     /**
-     * Whether it's async.
+     * The received property.
      */
-    readonly async: false;
+    readonly received: string;
     /**
-     * The input, output and issue type.
-     *
-     * @internal
+     * The error message.
      */
-    readonly '~types'?: {
-        readonly input: TInput;
-        readonly output: TOutput;
-        readonly issue: TIssue;
-    } | undefined;
+    readonly message: string;
     /**
-     * Validates known input values.
-     *
-     * @param dataset The input dataset.
-     * @param config The configuration.
-     *
-     * @returns The output dataset.
+     * The input requirement.
+     */
+    readonly requirement?: unknown | undefined;
+    /**
+     * The issue path.
      *
-     * @internal
+     * TODO: Investigate if it is possible to make the path type safe based on the
+     * input.
      */
-    readonly '~validate': (dataset: OutputDataset<TInput, BaseIssue<unknown>>, config: Config<BaseIssue<unknown>>) => OutputDataset<TOutput, BaseIssue<unknown> | TIssue>;
+    readonly path?: [IssuePathItem, ...IssuePathItem[]] | undefined;
+    /**
+     * The sub issues.
+     */
+    readonly issues?: [BaseIssue<TInput>, ...BaseIssue<TInput>[]] | undefined;
 }
+
 /**
- * Base validation async type.
+ * Config type.
  */
-interface BaseValidationAsync<TInput, TOutput, TIssue extends BaseIssue<unknown>> extends Omit<BaseValidation<TInput, TOutput, TIssue>, 'reference' | 'async' | '~validate'> {
+interface Config<TIssue extends BaseIssue<unknown>> {
     /**
-     * The validation reference.
+     * The selected language.
      */
-    readonly reference: (...args: any[]) => BaseValidation<any, any, BaseIssue<unknown>> | BaseValidationAsync<any, any, BaseIssue<unknown>>;
+    readonly lang?: string | undefined;
     /**
-     * Whether it's async.
+     * The error message.
      */
-    readonly async: true;
+    readonly message?: ErrorMessage<TIssue> | undefined;
     /**
-     * Validates known input values.
-     *
-     * @param dataset The input dataset.
-     * @param config The configuration.
-     *
-     * @returns The output dataset.
-     *
-     * @internal
+     * Whether it was abort early.
      */
-    readonly '~validate': (dataset: OutputDataset<TInput, BaseIssue<unknown>>, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<TOutput, BaseIssue<unknown> | TIssue>>;
+    readonly abortEarly?: boolean | undefined;
+    /**
+     * Whether the pipe was abort early.
+     */
+    readonly abortPipeEarly?: boolean | undefined;
 }
 
 /**
- * Infer input type.
- */
-type InferInput<TItem extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>> | BaseValidation<any, unknown, BaseIssue<unknown>> | BaseValidationAsync<any, unknown, BaseIssue<unknown>> | BaseTransformation<any, unknown, BaseIssue<unknown>> | BaseTransformationAsync<any, unknown, BaseIssue<unknown>> | BaseMetadata<any>> = NonNullable<TItem['~types']>['input'];
-/**
- * Infer output type.
- */
-type InferOutput<TItem extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>> | BaseValidation<any, unknown, BaseIssue<unknown>> | BaseValidationAsync<any, unknown, BaseIssue<unknown>> | BaseTransformation<any, unknown, BaseIssue<unknown>> | BaseTransformationAsync<any, unknown, BaseIssue<unknown>> | BaseMetadata<any>> = NonNullable<TItem['~types']>['output'];
-/**
- * Infer issue type.
- */
-type InferIssue<TItem extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>> | BaseValidation<any, unknown, BaseIssue<unknown>> | BaseValidationAsync<any, unknown, BaseIssue<unknown>> | BaseTransformation<any, unknown, BaseIssue<unknown>> | BaseTransformationAsync<any, unknown, BaseIssue<unknown>> | BaseMetadata<any>> = NonNullable<TItem['~types']>['issue'];
-/**
- * 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.
+ * Pipe action type.
  */
-type ErrorMessage<TIssue extends BaseIssue<unknown>> = ((issue: TIssue) => string) | string;
+type PipeAction<TInput, TOutput, TIssue extends BaseIssue<unknown>> = BaseValidation<TInput, TOutput, TIssue> | BaseTransformation<TInput, TOutput, TIssue> | BaseMetadata<TInput>;
 /**
- * Default type.
+ * Pipe action async type.
  */
-type Default<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TInput extends null | undefined> = MaybeReadonly<InferInput<TWrapped> | TInput> | ((dataset?: UnknownDataset, config?: Config<InferIssue<TWrapped>>) => MaybeReadonly<InferInput<TWrapped> | TInput>);
+type PipeActionAsync<TInput, TOutput, TIssue extends BaseIssue<unknown>> = BaseValidationAsync<TInput, TOutput, TIssue> | BaseTransformationAsync<TInput, TOutput, TIssue>;
 /**
- * Default async type.
+ * Pipe item type.
  */
-type DefaultAsync<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TInput extends null | undefined> = MaybeReadonly<InferInput<TWrapped> | TInput> | ((dataset?: UnknownDataset, config?: Config<InferIssue<TWrapped>>) => MaybePromise<MaybeReadonly<InferInput<TWrapped> | TInput>>);
+type PipeItem<TInput, TOutput, TIssue extends BaseIssue<unknown>> = BaseSchema<TInput, TOutput, TIssue> | PipeAction<TInput, TOutput, TIssue>;
 /**
- * Default value type.
+ * Pipe item async 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?: UnknownDataset, config?: Config<InferIssue<TWrapped>>) => MaybePromise<InferInput<TWrapped> | TInput> ? Awaited<ReturnType<TDefault>> : TDefault : never;
+type PipeItemAsync<TInput, TOutput, TIssue extends BaseIssue<unknown>> = BaseSchemaAsync<TInput, TOutput, TIssue> | PipeActionAsync<TInput, TOutput, TIssue>;
 
 /**
- * Object entries type.
+ * Array issue type.
  */
-interface ObjectEntries {
-    [key: string]: BaseSchema<unknown, unknown, BaseIssue<unknown>>;
+interface ArrayIssue extends BaseIssue<unknown> {
+    /**
+     * The issue kind.
+     */
+    readonly kind: 'schema';
+    /**
+     * The issue type.
+     */
+    readonly type: 'array';
+    /**
+     * The expected property.
+     */
+    readonly expected: 'Array';
 }
+
 /**
- * Object entries async type.
+ * Array schema type.
  */
-interface ObjectEntriesAsync {
-    [key: string]: BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>;
+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;
 }
 /**
- * Question mark schema type.
+ * Creates an array schema.
  *
- * TODO: Document that for simplicity and bundle size, we currently do not
- * distinguish between `undefined` and missing keys when using `optional` and
- * `nullish`.
+ * @param item The item schema.
+ *
+ * @returns An array schema.
  */
-type QuestionMarkSchema = NullishSchema<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown> | NullishSchemaAsync<BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, unknown> | OptionalSchema<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown> | OptionalSchemaAsync<BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, unknown>;
+declare function array<const TItem extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(item: TItem): ArraySchema<TItem, undefined>;
 /**
- * Has default type.
+ * Creates an array schema.
+ *
+ * @param item The item schema.
+ * @param message The error message.
+ *
+ * @returns An array schema.
  */
-type HasDefault<TSchema extends QuestionMarkSchema> = [
-    TSchema['default']
-] extends [never] ? false : true;
+declare function array<const TItem extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, const TMessage extends ErrorMessage<ArrayIssue> | undefined>(item: TItem, message: TMessage): ArraySchema<TItem, TMessage>;
+
 /**
- * Exact optional input type.
+ * Boolean issue type.
  */
-type ExactOptionalInput<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>> = TSchema extends OptionalSchema<infer TWrapped, never> | OptionalSchemaAsync<infer TWrapped, never> ? ExactOptionalInput<TWrapped> : InferInput<TSchema>;
+interface BooleanIssue extends BaseIssue<unknown> {
+    /**
+     * The issue kind.
+     */
+    readonly kind: 'schema';
+    /**
+     * The issue type.
+     */
+    readonly type: 'boolean';
+    /**
+     * The expected property.
+     */
+    readonly expected: 'boolean';
+}
 /**
- * Exact optional output type.
+ * Boolean schema type.
  */
-type ExactOptionalOutput<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>> = TSchema extends OptionalSchema<infer TWrapped, never> | OptionalSchemaAsync<infer TWrapped, never> ? HasDefault<TSchema> extends true ? InferOutput<TSchema> : ExactOptionalOutput<TWrapped> : InferOutput<TSchema>;
+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;
+}
 /**
- * Infer entries input type.
+ * Creates a boolean schema.
+ *
+ * @returns A boolean schema.
  */
-type InferEntriesInput<TEntries extends ObjectEntries | ObjectEntriesAsync> = {
-    -readonly [TKey in keyof TEntries]: ExactOptionalInput<TEntries[TKey]>;
-};
+declare function boolean(): BooleanSchema<undefined>;
 /**
- * Infer entries output type.
+ * Creates a boolean schema.
+ *
+ * @param message The error message.
+ *
+ * @returns A boolean schema.
  */
-type InferEntriesOutput<TEntries extends ObjectEntries | ObjectEntriesAsync> = {
-    -readonly [TKey in keyof TEntries]: ExactOptionalOutput<TEntries[TKey]>;
-};
+declare function boolean<const TMessage extends ErrorMessage<BooleanIssue> | undefined>(message: TMessage): BooleanSchema<TMessage>;
+
 /**
- * Optional input keys type.
+ * Class type.
  */
-type OptionalInputKeys<TEntries extends ObjectEntries | ObjectEntriesAsync> = {
-    [TKey in keyof TEntries]: TEntries[TKey] extends QuestionMarkSchema ? TKey : never;
-}[keyof TEntries];
+type Class = new (...args: any[]) => any;
 /**
- * Optional output keys type.
+ * Instance issue type.
  */
-type OptionalOutputKeys<TEntries extends ObjectEntries | ObjectEntriesAsync> = {
-    [TKey in keyof TEntries]: TEntries[TKey] extends QuestionMarkSchema ? undefined extends InferOutput<TEntries[TKey]> ? HasDefault<TEntries[TKey]> extends false ? TKey : never : never : never;
-}[keyof TEntries];
+interface InstanceIssue extends BaseIssue<unknown> {
+    /**
+     * The issue kind.
+     */
+    readonly kind: 'schema';
+    /**
+     * The issue type.
+     */
+    readonly type: 'instance';
+    /**
+     * The expected property.
+     */
+    readonly expected: string;
+}
 /**
- * Input with question marks type.
+ * Instance schema type.
  */
-type InputWithQuestionMarks<TEntries extends ObjectEntries | ObjectEntriesAsync, TObject extends InferEntriesInput<TEntries> | InferEntriesOutput<TEntries>> = MarkOptional<TObject, OptionalInputKeys<TEntries>>;
+interface InstanceSchema<TClass extends Class, TMessage extends ErrorMessage<InstanceIssue> | undefined> extends BaseSchema<InstanceType<TClass>, InstanceType<TClass>, InstanceIssue> {
+    /**
+     * The schema type.
+     */
+    readonly type: 'instance';
+    /**
+     * The schema reference.
+     */
+    readonly reference: typeof instance;
+    /**
+     * The class of the instance.
+     */
+    readonly class: TClass;
+    /**
+     * The error message.
+     */
+    readonly message: TMessage;
+}
 /**
- * Output with question marks type.
+ * Creates an instance schema.
+ *
+ * @param class_ The class of the instance.
+ *
+ * @returns An instance schema.
  */
-type OutputWithQuestionMarks<TEntries extends ObjectEntries | ObjectEntriesAsync, TObject extends InferEntriesInput<TEntries> | InferEntriesOutput<TEntries>> = MarkOptional<TObject, OptionalOutputKeys<TEntries>>;
+declare function instance<TClass extends Class>(class_: TClass): InstanceSchema<TClass, undefined>;
 /**
- * Readonly output keys type.
+ * Creates an instance schema.
+ *
+ * @param class_ The class of the instance.
+ * @param message The error message.
+ *
+ * @returns An instance schema.
  */
-type ReadonlyOutputKeys<TEntries extends ObjectEntries | ObjectEntriesAsync> = {
-    [TKey in keyof TEntries]: TEntries[TKey] extends SchemaWithPipe<infer TPipe> | SchemaWithPipeAsync<infer TPipe> ? ReadonlyAction<any> extends TPipe[number] ? TKey : never : never;
-}[keyof TEntries];
+declare function instance<TClass extends Class, const TMessage extends ErrorMessage<InstanceIssue> | undefined>(class_: TClass, message: TMessage): InstanceSchema<TClass, TMessage>;
+
 /**
- * Output with readonly type.
+ * Infer nullish output type.
  */
-type OutputWithReadonly<TEntries extends ObjectEntries | ObjectEntriesAsync, TObject extends OutputWithQuestionMarks<TEntries, InferEntriesOutput<TEntries>>> = Readonly<TObject> & Pick<TObject, Exclude<keyof TObject, ReadonlyOutputKeys<TEntries>>>;
+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>;
+
 /**
- * Infer object input type.
+ * Nullish schema type.
  */
-type InferObjectInput<TEntries extends ObjectEntries | ObjectEntriesAsync> = Prettify<InputWithQuestionMarks<TEntries, InferEntriesInput<TEntries>>>;
+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;
+}
 /**
- * Infer object output type.
+ * Creates a nullish schema.
+ *
+ * @param wrapped The wrapped schema.
+ *
+ * @returns A nullish schema.
  */
-type InferObjectOutput<TEntries extends ObjectEntries | ObjectEntriesAsync> = Prettify<OutputWithReadonly<TEntries, OutputWithQuestionMarks<TEntries, InferEntriesOutput<TEntries>>>>;
+declare function nullish<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped): NullishSchema<TWrapped, never>;
 /**
- * Infer object issue type.
+ * Creates a nullish schema.
+ *
+ * @param wrapped The wrapped schema.
+ * @param default_ The default value.
+ *
+ * @returns A nullish schema.
  */
-type InferObjectIssue<TEntries extends ObjectEntries | ObjectEntriesAsync> = InferIssue<TEntries[keyof TEntries]>;
+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>;
 
 /**
- * Array path item type.
+ * Nullish schema async type.
  */
-interface ArrayPathItem {
+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 path item type.
+     * The schema type.
      */
-    readonly type: 'array';
+    readonly type: 'nullish';
     /**
-     * The path item origin.
+     * The schema reference.
      */
-    readonly origin: 'value';
+    readonly reference: typeof nullishAsync;
     /**
-     * The path item input.
+     * The expected property.
      */
-    readonly input: MaybeReadonly<unknown[]>;
+    readonly expects: `(${TWrapped['expects']} | null | undefined)`;
     /**
-     * The path item key.
+     * The wrapped schema.
      */
-    readonly key: number;
+    readonly wrapped: TWrapped;
     /**
-     * The path item value.
+     * The default value.
      */
-    readonly value: unknown;
+    readonly default: TDefault;
 }
 /**
- * Map path item type.
+ * 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.
  */
-interface MapPathItem {
-    /**
-     * The path item type.
-     */
-    readonly type: 'map';
-    /**
-     * The path item origin.
-     */
-    readonly origin: 'key' | 'value';
+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 path item input.
+     * The issue kind.
      */
-    readonly input: Map<unknown, unknown>;
+    readonly kind: 'schema';
     /**
-     * The path item key.
+     * The issue type.
      */
-    readonly key: unknown;
+    readonly type: 'object';
     /**
-     * The path item value.
+     * The expected property.
      */
-    readonly value: unknown;
+    readonly expected: 'Object';
 }
+
 /**
- * Object path item type.
+ * Object schema type.
  */
-interface ObjectPathItem {
+interface ObjectSchema<TEntries extends ObjectEntries, TMessage extends ErrorMessage<ObjectIssue> | undefined> extends BaseSchema<InferObjectInput<TEntries>, InferObjectOutput<TEntries>, ObjectIssue | InferObjectIssue<TEntries>> {
     /**
-     * The path item type.
+     * The schema type.
      */
     readonly type: 'object';
     /**
-     * The path item origin.
+     * The schema reference.
      */
-    readonly origin: 'key' | 'value';
+    readonly reference: typeof object;
     /**
-     * The path item input.
+     * The expected property.
      */
-    readonly input: Record<string, unknown>;
+    readonly expects: 'Object';
     /**
-     * The path item key.
+     * The entries schema.
      */
-    readonly key: string;
+    readonly entries: TEntries;
     /**
-     * The path item value.
+     * The error message.
      */
-    readonly value: unknown;
+    readonly message: TMessage;
 }
 /**
- * Set path item type.
+ * 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.
  */
-interface SetPathItem {
+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 path item type.
+     * The schema type.
      */
-    readonly type: 'set';
+    readonly type: 'optional';
     /**
-     * The path item origin.
+     * The schema reference.
      */
-    readonly origin: 'value';
+    readonly reference: typeof optional;
     /**
-     * The path item input.
+     * The expected property.
      */
-    readonly input: Set<unknown>;
+    readonly expects: `(${TWrapped['expects']} | undefined)`;
     /**
-     * The path item key.
+     * The wrapped schema.
      */
-    readonly key: null;
+    readonly wrapped: TWrapped;
     /**
-     * The path item key.
+     * The default value.
      */
-    readonly value: unknown;
+    readonly default: TDefault;
 }
 /**
- * Unknown path item type.
+ * Creates a optional schema.
+ *
+ * @param wrapped The wrapped schema.
+ *
+ * @returns A optional schema.
  */
-interface UnknownPathItem {
+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 path item type.
+     * The schema type.
      */
-    readonly type: 'unknown';
+    readonly type: 'optional';
     /**
-     * The path item origin.
+     * The schema reference.
      */
-    readonly origin: 'key' | 'value';
+    readonly reference: typeof optionalAsync;
     /**
-     * The path item input.
+     * The expected property.
      */
-    readonly input: unknown;
+    readonly expects: `(${TWrapped['expects']} | undefined)`;
     /**
-     * The path item key.
+     * The wrapped schema.
      */
-    readonly key: unknown;
+    readonly wrapped: TWrapped;
     /**
-     * The path item value.
+     * The default value.
      */
-    readonly value: unknown;
+    readonly default: TDefault;
 }
 /**
- * Issue path item type.
+ * Creates an optional schema.
  *
- * TODO: Document that the input of the path may be different from the input of
- * the issue.
+ * @param wrapped The wrapped schema.
+ *
+ * @returns An optional schema.
  */
-type IssuePathItem = ArrayPathItem | MapPathItem | ObjectPathItem | SetPathItem | UnknownPathItem;
+declare function optionalAsync<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped): OptionalSchemaAsync<TWrapped, never>;
 /**
- * Base issue type.
+ * Creates an optional schema.
+ *
+ * @param wrapped The wrapped schema.
+ * @param default_ The default value.
+ *
+ * @returns An optional schema.
  */
-interface BaseIssue<TInput> extends Config<BaseIssue<TInput>> {
+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>;
+
+/**
+ * String issue type.
+ */
+interface StringIssue extends BaseIssue<unknown> {
     /**
      * The issue kind.
      */
-    readonly kind: 'schema' | 'validation' | 'transformation';
+    readonly kind: 'schema';
     /**
      * The issue type.
      */
-    readonly type: string;
-    /**
-     * The raw input data.
-     */
-    readonly input: TInput;
+    readonly type: 'string';
     /**
      * 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 | undefined;
-    /**
-     * The issue path.
-     *
-     * TODO: Investigate if it is possible to make the path type safe based on the
-     * input.
-     */
-    readonly path?: [IssuePathItem, ...IssuePathItem[]] | undefined;
-    /**
-     * The sub issues.
-     */
-    readonly issues?: [BaseIssue<TInput>, ...BaseIssue<TInput>[]] | undefined;
+    readonly expected: 'string';
 }
-
 /**
- * Config type.
+ * String schema type.
  */
-interface Config<TIssue extends BaseIssue<unknown>> {
+interface StringSchema<TMessage extends ErrorMessage<StringIssue> | undefined> extends BaseSchema<string, string, StringIssue> {
     /**
-     * The selected language.
+     * The schema type.
      */
-    readonly lang?: string | undefined;
+    readonly type: 'string';
     /**
-     * The error message.
+     * The schema reference.
      */
-    readonly message?: ErrorMessage<TIssue> | undefined;
+    readonly reference: typeof string;
     /**
-     * Whether it was abort early.
+     * The expected property.
      */
-    readonly abortEarly?: boolean | undefined;
+    readonly expects: 'string';
     /**
-     * Whether the pipe was abort early.
+     * The error message.
      */
-    readonly abortPipeEarly?: boolean | undefined;
+    readonly message: TMessage;
 }
-
-/**
- * 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.
+ * Creates a string schema.
+ *
+ * @returns A string schema.
  */
-type PipeItem<TInput, TOutput, TIssue extends BaseIssue<unknown>> = BaseSchema<TInput, TOutput, TIssue> | PipeAction<TInput, TOutput, TIssue>;
+declare function string(): StringSchema<undefined>;
 /**
- * Pipe item async type.
+ * Creates a string schema.
+ *
+ * @param message The error message.
+ *
+ * @returns A string schema.
  */
-type PipeItemAsync<TInput, TOutput, TIssue extends BaseIssue<unknown>> = BaseSchemaAsync<TInput, TOutput, TIssue> | PipeActionAsync<TInput, TOutput, TIssue>;
+declare function string<const TMessage extends ErrorMessage<StringIssue> | undefined>(message: TMessage): StringSchema<TMessage>;
 
 /**
  * Readonly action type.