@inploi/flows 0.0.0 → 2.0.0

package/dist/result-3e1b4efe.d.ts

@@ -0,0 +1,1742 @@
+/**
+ * Fallback type.
+ */
+type Fallback<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>>> = MaybeReadonly<InferOutput<TSchema>> | ((dataset?: OutputDataset<InferOutput<TSchema>, InferIssue<TSchema>>, config?: Config<InferIssue<TSchema>>) => MaybeReadonly<InferOutput<TSchema>>);
+/**
+ * Schema with fallback type.
+ */
+type SchemaWithFallback<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TFallback extends Fallback<TSchema>> = TSchema & {
+    /**
+     * The fallback value.
+     */
+    readonly fallback: TFallback;
+};
+
+/**
+ * Fallback async type.
+ */
+type FallbackAsync<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>> = MaybeReadonly<InferOutput<TSchema>> | ((dataset?: OutputDataset<InferOutput<TSchema>, InferIssue<TSchema>>, config?: Config<InferIssue<TSchema>>) => MaybePromise<MaybeReadonly<InferOutput<TSchema>>>);
+/**
+ * Schema with fallback async type.
+ */
+type SchemaWithFallbackAsync<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TFallback extends FallbackAsync<TSchema>> = Omit<TSchema, 'async' | '~standard' | '~run'> & {
+    /**
+     * The fallback value.
+     */
+    readonly fallback: TFallback;
+    /**
+     * Whether it's async.
+     */
+    readonly async: true;
+    /**
+     * The Standard Schema properties.
+     *
+     * @internal
+     */
+    readonly '~standard': StandardProps<InferInput<TSchema>, InferOutput<TSchema>>;
+    /**
+     * Parses unknown input values.
+     *
+     * @param dataset The input dataset.
+     * @param config The configuration.
+     *
+     * @returns The output dataset.
+     *
+     * @internal
+     */
+    readonly '~run': (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<InferOutput<TSchema>, InferIssue<TSchema>>>;
+};
+
+/**
+ * Schema with pipe type.
+ */
+type SchemaWithPipe<TPipe extends readonly [
+    BaseSchema<unknown, unknown, BaseIssue<unknown>>,
+    ...PipeItem<any, unknown, BaseIssue<unknown>>[]
+]> = Omit<FirstTupleItem<TPipe>, 'pipe' | '~standard' | '~run' | '~types'> & {
+    /**
+     * The pipe items.
+     */
+    readonly pipe: TPipe;
+    /**
+     * The Standard Schema properties.
+     *
+     * @internal
+     */
+    readonly '~standard': StandardProps<InferInput<FirstTupleItem<TPipe>>, InferOutput<LastTupleItem<TPipe>>>;
+    /**
+     * Parses unknown input values.
+     *
+     * @param dataset The input dataset.
+     * @param config The configuration.
+     *
+     * @returns The output dataset.
+     *
+     * @internal
+     */
+    readonly '~run': (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => OutputDataset<InferOutput<LastTupleItem<TPipe>>, InferIssue<TPipe[number]>>;
+    /**
+     * 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;
+};
+
+/**
+ * Schema with pipe async type.
+ */
+type SchemaWithPipeAsync<TPipe extends readonly [
+    (BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>),
+    ...(PipeItem<any, unknown, BaseIssue<unknown>> | PipeItemAsync<any, unknown, BaseIssue<unknown>>)[]
+]> = Omit<FirstTupleItem<TPipe>, 'async' | 'pipe' | '~standard' | '~run' | '~types'> & {
+    /**
+     * The pipe items.
+     */
+    readonly pipe: TPipe;
+    /**
+     * Whether it's async.
+     */
+    readonly async: true;
+    /**
+     * The Standard Schema properties.
+     *
+     * @internal
+     */
+    readonly '~standard': StandardProps<InferInput<FirstTupleItem<TPipe>>, InferOutput<LastTupleItem<TPipe>>>;
+    /**
+     * Parses unknown input values.
+     *
+     * @param dataset The input dataset.
+     * @param config The configuration.
+     *
+     * @returns The output dataset.
+     *
+     * @internal
+     */
+    readonly '~run': (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<InferOutput<LastTupleItem<TPipe>>, InferIssue<TPipe[number]>>>;
+    /**
+     * 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;
+};
+
+/**
+ * Base metadata interface.
+ */
+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;
+}
+
+/**
+ * Unknown dataset interface.
+ */
+interface UnknownDataset {
+    /**
+     * Whether is's typed.
+     */
+    typed?: false;
+    /**
+     * The dataset value.
+     */
+    value: unknown;
+    /**
+     * The dataset issues.
+     */
+    issues?: undefined;
+}
+/**
+ * Success dataset interface.
+ */
+interface SuccessDataset<TValue> {
+    /**
+     * Whether is's typed.
+     */
+    typed: true;
+    /**
+     * The dataset value.
+     */
+    value: TValue;
+    /**
+     * The dataset issues.
+     */
+    issues?: undefined;
+}
+/**
+ * Partial dataset interface.
+ */
+interface PartialDataset<TValue, TIssue extends BaseIssue<unknown>> {
+    /**
+     * Whether is's typed.
+     */
+    typed: true;
+    /**
+     * The dataset value.
+     */
+    value: TValue;
+    /**
+     * The dataset issues.
+     */
+    issues: [TIssue, ...TIssue[]];
+}
+/**
+ * Failure dataset interface.
+ */
+interface FailureDataset<TIssue extends BaseIssue<unknown>> {
+    /**
+     * Whether is's typed.
+     */
+    typed: false;
+    /**
+     * The dataset value.
+     */
+    value: unknown;
+    /**
+     * The dataset issues.
+     */
+    issues: [TIssue, ...TIssue[]];
+}
+/**
+ * Output dataset type.
+ */
+type OutputDataset<TValue, TIssue extends BaseIssue<unknown>> = SuccessDataset<TValue> | PartialDataset<TValue, TIssue> | FailureDataset<TIssue>;
+
+/**
+ * The Standard Schema properties interface.
+ */
+interface StandardProps<TInput, TOutput> {
+    /**
+     * The version number of the standard.
+     */
+    readonly version: 1;
+    /**
+     * The vendor name of the schema library.
+     */
+    readonly vendor: 'valibot';
+    /**
+     * Validates unknown input values.
+     */
+    readonly validate: (value: unknown) => StandardResult<TOutput> | Promise<StandardResult<TOutput>>;
+    /**
+     * Inferred types associated with the schema.
+     */
+    readonly types?: StandardTypes<TInput, TOutput> | undefined;
+}
+/**
+ * The result interface of the validate function.
+ */
+type StandardResult<TOutput> = StandardSuccessResult<TOutput> | StandardFailureResult;
+/**
+ * The result interface if validation succeeds.
+ */
+interface StandardSuccessResult<TOutput> {
+    /**
+     * The typed output value.
+     */
+    readonly value: TOutput;
+    /**
+     * The non-existent issues.
+     */
+    readonly issues?: undefined;
+}
+/**
+ * The result interface if validation fails.
+ */
+interface StandardFailureResult {
+    /**
+     * The issues of failed validation.
+     */
+    readonly issues: readonly StandardIssue[];
+}
+/**
+ * The issue interface of the failure output.
+ */
+interface StandardIssue {
+    /**
+     * The error message of the issue.
+     */
+    readonly message: string;
+    /**
+     * The path of the issue, if any.
+     */
+    readonly path?: readonly (PropertyKey | StandardPathItem)[] | undefined;
+}
+/**
+ * The path item interface of the issue.
+ */
+interface StandardPathItem {
+    /**
+     * The key of the path item.
+     */
+    readonly key: PropertyKey;
+}
+/**
+ * The Standard Schema types interface.
+ */
+interface StandardTypes<TInput, TOutput> {
+    /**
+     * The input type of the schema.
+     */
+    readonly input: TInput;
+    /**
+     * The output type of the schema.
+     */
+    readonly output: TOutput;
+}
+
+/**
+ * Base schema interface.
+ */
+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;
+    /**
+     * The Standard Schema properties.
+     *
+     * @internal
+     */
+    readonly '~standard': StandardProps<TInput, TOutput>;
+    /**
+     * Parses unknown input values.
+     *
+     * @param dataset The input dataset.
+     * @param config The configuration.
+     *
+     * @returns The output dataset.
+     *
+     * @internal
+     */
+    readonly '~run': (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => OutputDataset<TOutput, TIssue>;
+    /**
+     * The input, output and issue type.
+     *
+     * @internal
+     */
+    readonly '~types'?: {
+        readonly input: TInput;
+        readonly output: TOutput;
+        readonly issue: TIssue;
+    } | undefined;
+}
+/**
+ * Base schema async interface.
+ */
+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 values.
+     *
+     * @param dataset The input dataset.
+     * @param config The configuration.
+     *
+     * @returns The output dataset.
+     *
+     * @internal
+     */
+    readonly '~run': (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<TOutput, TIssue>>;
+}
+
+/**
+ * Base transformation interface.
+ */
+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<any, any, BaseIssue<unknown>>;
+    /**
+     * Whether it's async.
+     */
+    readonly async: false;
+    /**
+     * Transforms known input values.
+     *
+     * @param dataset The input dataset.
+     * @param config The configuration.
+     *
+     * @returns The output dataset.
+     *
+     * @internal
+     */
+    readonly '~run': (dataset: SuccessDataset<TInput>, config: Config<BaseIssue<unknown>>) => OutputDataset<TOutput, BaseIssue<unknown> | TIssue>;
+    /**
+     * The input, output and issue type.
+     *
+     * @internal
+     */
+    readonly '~types'?: {
+        readonly input: TInput;
+        readonly output: TOutput;
+        readonly issue: TIssue;
+    } | undefined;
+}
+/**
+ * Base transformation async interface.
+ */
+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<any, any, BaseIssue<unknown>> | BaseTransformationAsync<any, any, BaseIssue<unknown>>;
+    /**
+     * Whether it's async.
+     */
+    readonly async: true;
+    /**
+     * Transforms known input values.
+     *
+     * @param dataset The input dataset.
+     * @param config The configuration.
+     *
+     * @returns The output dataset.
+     *
+     * @internal
+     */
+    readonly '~run': (dataset: SuccessDataset<TInput>, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<TOutput, BaseIssue<unknown> | TIssue>>;
+}
+
+/**
+ * Base validation interface.
+ */
+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<any, any, BaseIssue<unknown>>;
+    /**
+     * The expected property.
+     */
+    readonly expects: string | null;
+    /**
+     * Whether it's async.
+     */
+    readonly async: false;
+    /**
+     * Validates known input values.
+     *
+     * @param dataset The input dataset.
+     * @param config The configuration.
+     *
+     * @returns The output dataset.
+     *
+     * @internal
+     */
+    readonly '~run': (dataset: OutputDataset<TInput, BaseIssue<unknown>>, config: Config<BaseIssue<unknown>>) => OutputDataset<TOutput, BaseIssue<unknown> | TIssue>;
+    /**
+     * The input, output and issue type.
+     *
+     * @internal
+     */
+    readonly '~types'?: {
+        readonly input: TInput;
+        readonly output: TOutput;
+        readonly issue: TIssue;
+    } | undefined;
+}
+/**
+ * Base validation async interface.
+ */
+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<any, any, BaseIssue<unknown>> | BaseValidationAsync<any, any, BaseIssue<unknown>>;
+    /**
+     * Whether it's async.
+     */
+    readonly async: true;
+    /**
+     * Validates known input values.
+     *
+     * @param dataset The input dataset.
+     * @param config The configuration.
+     *
+     * @returns The output dataset.
+     *
+     * @internal
+     */
+    readonly '~run': (dataset: OutputDataset<TInput, BaseIssue<unknown>>, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<TOutput, BaseIssue<unknown> | TIssue>>;
+}
+
+/**
+ * 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'];
+/**
+ * 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> = {
+    [TKey in keyof TObject]?: unknown;
+} & Omit<TObject, TKeys> & Partial<Pick<TObject, TKeys>>;
+/**
+ * Extracts first tuple item.
+ */
+type FirstTupleItem<TTuple extends readonly [unknown, ...unknown[]]> = TTuple[0];
+/**
+ * Extracts last tuple item.
+ */
+type LastTupleItem<TTuple extends readonly [unknown, ...unknown[]]> = TTuple[TTuple extends readonly [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?: UnknownDataset, config?: Config<InferIssue<TWrapped>>) => MaybeReadonly<InferInput<TWrapped> | TInput>) | undefined;
+/**
+ * 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?: UnknownDataset, config?: Config<InferIssue<TWrapped>>) => MaybePromise<MaybeReadonly<InferInput<TWrapped> | TInput>>) | undefined;
+/**
+ * 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;
+
+/**
+ * Optional entry schema type.
+ */
+type OptionalEntrySchema = ExactOptionalSchema<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown> | NullishSchema<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown> | OptionalSchema<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown>;
+/**
+ * Optional entry schema async type.
+ */
+type OptionalEntrySchemaAsync = ExactOptionalSchemaAsync<BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, unknown> | NullishSchemaAsync<BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, unknown> | OptionalSchemaAsync<BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, unknown>;
+/**
+ * Object entries interface.
+ */
+interface ObjectEntries {
+    [key: string]: BaseSchema<unknown, unknown, BaseIssue<unknown>> | SchemaWithFallback<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown> | OptionalEntrySchema;
+}
+/**
+ * Object entries async interface.
+ */
+interface ObjectEntriesAsync {
+    [key: string]: BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>> | SchemaWithFallback<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown> | SchemaWithFallbackAsync<BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, unknown> | OptionalEntrySchema | OptionalEntrySchemaAsync;
+}
+/**
+ * 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 input keys type.
+ */
+type OptionalInputKeys<TEntries extends ObjectEntries | ObjectEntriesAsync> = {
+    [TKey in keyof TEntries]: TEntries[TKey] extends OptionalEntrySchema | OptionalEntrySchemaAsync ? TKey : never;
+}[keyof TEntries];
+/**
+ * Optional output keys type.
+ */
+type OptionalOutputKeys<TEntries extends ObjectEntries | ObjectEntriesAsync> = {
+    [TKey in keyof TEntries]: TEntries[TKey] extends OptionalEntrySchema | OptionalEntrySchemaAsync ? undefined extends TEntries[TKey]['default'] ? TKey : never : never;
+}[keyof TEntries];
+/**
+ * Input with question marks type.
+ */
+type InputWithQuestionMarks<TEntries extends ObjectEntries | ObjectEntriesAsync, TObject extends InferEntriesInput<TEntries>> = MarkOptional<TObject, OptionalInputKeys<TEntries>>;
+/**
+ * Output with question marks type.
+ */
+type OutputWithQuestionMarks<TEntries extends ObjectEntries | ObjectEntriesAsync, TObject extends 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]>;
+
+/**
+ * Array path item interface.
+ */
+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 interface.
+ */
+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 interface.
+ */
+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 interface.
+ */
+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 interface.
+ */
+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.
+ */
+type IssuePathItem = ArrayPathItem | MapPathItem | ObjectPathItem | SetPathItem | UnknownPathItem;
+/**
+ * Base issue interface.
+ */
+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 | undefined;
+    /**
+     * The issue path.
+     */
+    readonly path?: [IssuePathItem, ...IssuePathItem[]] | undefined;
+    /**
+     * The sub issues.
+     */
+    readonly issues?: [BaseIssue<TInput>, ...BaseIssue<TInput>[]] | undefined;
+}
+
+/**
+ * Config interface.
+ */
+interface Config<TIssue extends BaseIssue<unknown>> {
+    /**
+     * The selected language.
+     */
+    readonly lang?: string | undefined;
+    /**
+     * The error message.
+     */
+    readonly message?: ErrorMessage<TIssue> | undefined;
+    /**
+     * Whether it should be aborted early.
+     */
+    readonly abortEarly?: boolean | undefined;
+    /**
+     * Whether a pipe should be aborted early.
+     */
+    readonly abortPipeEarly?: boolean | 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>;
+
+/**
+ * Boolean issue interface.
+ */
+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 interface.
+ */
+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>;
+
+/**
+ * Exact optional schema interface.
+ */
+interface ExactOptionalSchema<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TDefault extends Default<TWrapped, never>> extends BaseSchema<InferInput<TWrapped>, InferOutput<TWrapped>, InferIssue<TWrapped>> {
+    /**
+     * The schema type.
+     */
+    readonly type: 'exact_optional';
+    /**
+     * The schema reference.
+     */
+    readonly reference: typeof exactOptional;
+    /**
+     * The expected property.
+     */
+    readonly expects: TWrapped['expects'];
+    /**
+     * The wrapped schema.
+     */
+    readonly wrapped: TWrapped;
+    /**
+     * The default value.
+     */
+    readonly default: TDefault;
+}
+/**
+ * Creates an exact optional schema.
+ *
+ * @param wrapped The wrapped schema.
+ *
+ * @returns An exact optional schema.
+ */
+declare function exactOptional<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped): ExactOptionalSchema<TWrapped, undefined>;
+/**
+ * Creates an exact optional schema.
+ *
+ * @param wrapped The wrapped schema.
+ * @param default_ The default value.
+ *
+ * @returns An exact optional schema.
+ */
+declare function exactOptional<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, const TDefault extends Default<TWrapped, never>>(wrapped: TWrapped, default_: TDefault): ExactOptionalSchema<TWrapped, TDefault>;
+
+/**
+ * Exact optional schema async interface.
+ */
+interface ExactOptionalSchemaAsync<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TDefault extends DefaultAsync<TWrapped, never>> extends BaseSchemaAsync<InferInput<TWrapped>, InferOutput<TWrapped>, InferIssue<TWrapped>> {
+    /**
+     * The schema type.
+     */
+    readonly type: 'exact_optional';
+    /**
+     * The schema reference.
+     */
+    readonly reference: typeof exactOptional | typeof exactOptionalAsync;
+    /**
+     * The expected property.
+     */
+    readonly expects: TWrapped['expects'];
+    /**
+     * The wrapped schema.
+     */
+    readonly wrapped: TWrapped;
+    /**
+     * The default value.
+     */
+    readonly default: TDefault;
+}
+/**
+ * Creates an exact optional schema.
+ *
+ * @param wrapped The wrapped schema.
+ *
+ * @returns An exact optional schema.
+ */
+declare function exactOptionalAsync<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped): ExactOptionalSchemaAsync<TWrapped, undefined>;
+/**
+ * Creates an exact optional schema.
+ *
+ * @param wrapped The wrapped schema.
+ * @param default_ The default value.
+ *
+ * @returns An exact optional schema.
+ */
+declare function exactOptionalAsync<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, const TDefault extends DefaultAsync<TWrapped, never>>(wrapped: TWrapped, default_: TDefault): ExactOptionalSchemaAsync<TWrapped, TDefault>;
+
+/**
+ * Literal type.
+ */
+type Literal = bigint | boolean | number | string | symbol;
+/**
+ * Literal issue interface.
+ */
+interface LiteralIssue extends BaseIssue<unknown> {
+    /**
+     * The issue kind.
+     */
+    readonly kind: 'schema';
+    /**
+     * The issue type.
+     */
+    readonly type: 'literal';
+    /**
+     * The expected property.
+     */
+    readonly expected: string;
+}
+/**
+ * Literal schema interface.
+ */
+interface LiteralSchema<TLiteral extends Literal, TMessage extends ErrorMessage<LiteralIssue> | undefined> extends BaseSchema<TLiteral, TLiteral, LiteralIssue> {
+    /**
+     * The schema type.
+     */
+    readonly type: 'literal';
+    /**
+     * The schema reference.
+     */
+    readonly reference: typeof literal;
+    /**
+     * The literal value.
+     */
+    readonly literal: TLiteral;
+    /**
+     * The error message.
+     */
+    readonly message: TMessage;
+}
+/**
+ * Creates a literal schema.
+ *
+ * @param literal_ The literal value.
+ *
+ * @returns A literal schema.
+ */
+declare function literal<const TLiteral extends Literal>(literal_: TLiteral): LiteralSchema<TLiteral, undefined>;
+/**
+ * Creates a literal schema.
+ *
+ * @param literal_ The literal value.
+ * @param message The error message.
+ *
+ * @returns A literal schema.
+ */
+declare function literal<const TLiteral extends Literal, const TMessage extends ErrorMessage<LiteralIssue> | undefined>(literal_: TLiteral, message: TMessage): LiteralSchema<TLiteral, TMessage>;
+
+/**
+ * Infer nullable output type.
+ */
+type InferNullableOutput<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TDefault extends DefaultAsync<TWrapped, null>> = undefined extends TDefault ? InferOutput<TWrapped> | null : InferOutput<TWrapped> | Extract<DefaultValue<TDefault>, null>;
+
+/**
+ * Nullable schema interface.
+ */
+interface NullableSchema<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TDefault extends Default<TWrapped, null>> extends BaseSchema<InferInput<TWrapped> | null, InferNullableOutput<TWrapped, TDefault>, InferIssue<TWrapped>> {
+    /**
+     * The schema type.
+     */
+    readonly type: 'nullable';
+    /**
+     * The schema reference.
+     */
+    readonly reference: typeof nullable;
+    /**
+     * The expected property.
+     */
+    readonly expects: `(${TWrapped['expects']} | null)`;
+    /**
+     * The wrapped schema.
+     */
+    readonly wrapped: TWrapped;
+    /**
+     * The default value.
+     */
+    readonly default: TDefault;
+}
+/**
+ * Creates a nullable schema.
+ *
+ * @param wrapped The wrapped schema.
+ *
+ * @returns A nullable schema.
+ */
+declare function nullable<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped): NullableSchema<TWrapped, undefined>;
+/**
+ * Creates a nullable schema.
+ *
+ * @param wrapped The wrapped schema.
+ * @param default_ The default value.
+ *
+ * @returns A nullable schema.
+ */
+declare function nullable<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, const TDefault extends Default<TWrapped, null>>(wrapped: TWrapped, default_: TDefault): NullableSchema<TWrapped, TDefault>;
+
+/**
+ * Infer nullish output type.
+ */
+type InferNullishOutput<TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TDefault extends DefaultAsync<TWrapped, null | undefined>> = undefined extends TDefault ? InferOutput<TWrapped> | null | undefined : InferOutput<TWrapped> | Extract<DefaultValue<TDefault>, null | undefined>;
+
+/**
+ * Nullish schema interface.
+ */
+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, undefined>;
+/**
+ * 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 interface.
+ */
+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 nullish | 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, undefined>;
+/**
+ * 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>;
+
+/**
+ * Number issue interface.
+ */
+interface NumberIssue extends BaseIssue<unknown> {
+    /**
+     * The issue kind.
+     */
+    readonly kind: 'schema';
+    /**
+     * The issue type.
+     */
+    readonly type: 'number';
+    /**
+     * The expected property.
+     */
+    readonly expected: 'number';
+}
+/**
+ * Number schema interface.
+ */
+interface NumberSchema<TMessage extends ErrorMessage<NumberIssue> | undefined> extends BaseSchema<number, number, NumberIssue> {
+    /**
+     * The schema type.
+     */
+    readonly type: 'number';
+    /**
+     * The schema reference.
+     */
+    readonly reference: typeof number;
+    /**
+     * The expected property.
+     */
+    readonly expects: 'number';
+    /**
+     * The error message.
+     */
+    readonly message: TMessage;
+}
+/**
+ * Creates a number schema.
+ *
+ * @returns A number schema.
+ */
+declare function number(): NumberSchema<undefined>;
+/**
+ * Creates a number schema.
+ *
+ * @param message The error message.
+ *
+ * @returns A number schema.
+ */
+declare function number<const TMessage extends ErrorMessage<NumberIssue> | undefined>(message: TMessage): NumberSchema<TMessage>;
+
+/**
+ * Object issue interface.
+ */
+interface ObjectIssue extends BaseIssue<unknown> {
+    /**
+     * The issue kind.
+     */
+    readonly kind: 'schema';
+    /**
+     * The issue type.
+     */
+    readonly type: 'object';
+    /**
+     * The expected property.
+     */
+    readonly expected: 'Object' | `"${string}"`;
+}
+
+/**
+ * Object schema interface.
+ */
+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>> = undefined extends TDefault ? InferOutput<TWrapped> | undefined : InferOutput<TWrapped> | Extract<DefaultValue<TDefault>, undefined>;
+
+/**
+ * Optional schema interface.
+ */
+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 an optional schema.
+ *
+ * @param wrapped The wrapped schema.
+ *
+ * @returns An optional schema.
+ */
+declare function optional<const TWrapped extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(wrapped: TWrapped): OptionalSchema<TWrapped, undefined>;
+/**
+ * Creates an optional schema.
+ *
+ * @param wrapped The wrapped schema.
+ * @param default_ The default value.
+ *
+ * @returns An 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 interface.
+ */
+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 optional | 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, undefined>;
+/**
+ * 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 interface.
+ */
+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 interface.
+ */
+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>;
+
+/**
+ * Unknown schema interface.
+ */
+interface UnknownSchema extends BaseSchema<unknown, unknown, never> {
+    /**
+     * The schema type.
+     */
+    readonly type: 'unknown';
+    /**
+     * The schema reference.
+     */
+    readonly reference: typeof unknown;
+    /**
+     * The expected property.
+     */
+    readonly expects: 'unknown';
+}
+/**
+ * Creates a unknown schema.
+ *
+ * @returns A unknown schema.
+ */
+declare function unknown(): UnknownSchema;
+
+/**
+ * Readonly output type.
+ */
+type ReadonlyOutput<TInput> = TInput extends Map<infer TKey, infer TValue> ? ReadonlyMap<TKey, TValue> : TInput extends Set<infer TValue> ? ReadonlySet<TValue> : Readonly<TInput>;
+/**
+ * Readonly action interface.
+ */
+interface ReadonlyAction<TInput> extends BaseTransformation<TInput, ReadonlyOutput<TInput>, never> {
+    /**
+     * The action type.
+     */
+    readonly type: 'readonly';
+    /**
+     * The action reference.
+     */
+    readonly reference: typeof readonly;
+}
+/**
+ * Creates a readonly transformation action.
+ *
+ * @returns A readonly action.
+ */
+declare function readonly<TInput>(): ReadonlyAction<TInput>;
+
+/**
+ * A Valibot error with useful information.
+ */
+declare class ValiError<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>> extends Error {
+    /**
+     * The error issues.
+     */
+    readonly issues: [InferIssue<TSchema>, ...InferIssue<TSchema>[]];
+    /**
+     * Creates a Valibot error with useful information.
+     *
+     * @param issues The error issues.
+     */
+    constructor(issues: [InferIssue<TSchema>, ...InferIssue<TSchema>[]]);
+}
+
+declare const responseSchema: ObjectSchema<{
+    /** Not necessarily true when we receive a positive response because the API considers only 200 as success */
+    readonly success: BooleanSchema<undefined>;
+    readonly integration_response: ObjectSchema<{
+        readonly service: OptionalSchema<StringSchema<undefined>, undefined>;
+        readonly status: NumberSchema<undefined>;
+        readonly data: UnknownSchema;
+        readonly error: NullableSchema<ObjectSchema<{
+            readonly message: StringSchema<undefined>;
+            readonly data: UnknownSchema;
+        }, undefined>, undefined>;
+    }, undefined>;
+}, undefined>;
+type IntegrationResponse = InferOutput<typeof responseSchema>;
+
+type TextInput = {
+    type: 'text';
+    config: {
+        key: string;
+        optional: boolean;
+        placeholder?: string;
+        format: 'text' | 'email' | 'url' | 'phone';
+        defaultValue?: string;
+        maxChars: number | undefined;
+        minChars: number | undefined;
+    };
+    submission: TextInputSubmission;
+};
+type TextInputSubmission = {
+    type: 'string';
+    value: string;
+};
+type NumberInput = {
+    type: 'number';
+    config: {
+        key: string;
+        optional: boolean;
+        placeholder?: string;
+        defaultValue?: string;
+        decimalCases?: number;
+        min?: number;
+        max?: number;
+    };
+    submission: NumberInputSubmission;
+};
+type NumberInputSubmission = {
+    type: 'number';
+    value: number;
+};
+type MultipleChoiceInput = {
+    type: 'multiple-choice';
+    config: {
+        key: string;
+        options: {
+            value: string;
+            label: string;
+        }[];
+        minSelected?: number;
+        maxSelected?: number;
+    };
+    submission: MultipleChoiceInputSubmission;
+};
+type MultipleChoiceInputSubmission = {
+    type: 'enum';
+    value: string[];
+};
+type BooleanChoiceInput = {
+    type: 'boolean';
+    config: {
+        key: string;
+        labels: {
+            true: string;
+            false: string;
+        };
+        optional: boolean;
+    };
+    submission: BooleanChoiceInputSubmission;
+};
+type BooleanChoiceInputSubmission = {
+    type: 'boolean';
+    value: boolean;
+};
+type FileToUpload = {
+    name: string;
+    data: string;
+    sizeKb: number;
+};
+type FileInput = {
+    type: 'file';
+    config: {
+        key: string;
+        optional: boolean;
+        extensions: string[];
+        fileSizeLimitKib?: number;
+        allowMultiple: boolean;
+    };
+    key: string;
+    submission: FileInputSubmission;
+};
+type FileInputSubmission = {
+    type: 'file';
+    value: FileToUpload[];
+};
+type SubmitInput = {
+    type: 'submit';
+    config: {
+        key: string;
+        label: string;
+    };
+    submission: SubmitInputSubmission;
+};
+type SubmitInputSubmission = {
+    type: 'integration';
+    value: IntegrationResponse;
+};
+type AddressInput = {
+    type: 'address';
+    config: {
+        key: string;
+        optional: boolean;
+        /** Keys for remapping
+         * @example {line1: "lineOne"} will send submissions with the key being "lineOne" instead of "line1"
+         */
+        keys: {
+            line1: string | null;
+            line2: string | null;
+            line3: string | null;
+            city: string | null;
+            state: string | null;
+            postcode: string | null;
+            country: string | null;
+        };
+        placeholder?: string;
+    };
+    submission: AddressInputSubmission;
+};
+type AddressInputSubmission = {
+    type: 'address';
+    value: {
+        [remappedKey: string]: string | undefined;
+    };
+};
+type PhoneInput = {
+    type: 'phone';
+    config: {
+        key: string;
+        optional: boolean;
+        submissionFormat: 'phone' | 'text';
+        placeholder?: string;
+        defaultValue: {
+            countryCode?: string;
+            phoneNumber?: string;
+        };
+        minChars?: number;
+        maxChars?: number;
+    };
+    submission: PhoneInputSubmission;
+};
+type PhoneInputSubmission = {
+    type: 'phone';
+    value: {
+        countryCode: string;
+        phoneNumber: string;
+    };
+} | {
+    type: 'string';
+    value: string;
+};
+type FlowInput = TextInput | NumberInput | MultipleChoiceInput | BooleanChoiceInput | FileInput | SubmitInput | AddressInput | PhoneInput;
+
+type FlowSubmissions = {
+    [key: string]: FlowInput['submission'] | {
+        type: 'integration';
+        value: unknown;
+    };
+};
+
+type Result<R, E> = Ok<R> | Err<E>;
+interface Ok<R> {
+    ok: true;
+    err: false;
+    val: R;
+    '~brand': 'ok';
+}
+declare const Ok: <const R>(val: R) => Ok<R>;
+interface Err<E> {
+    ok: false;
+    err: true;
+    val: E;
+    '~brand': 'err';
+}
+declare const Err: <const E>(val: E) => Err<E>;
+
+export { Err as E, FlowSubmissions as F, InferOutput as I, LiteralSchema as L, NullableSchema as N, Ok as O, PhoneInput as P, Result as R, StringSchema as S, ValiError as V, FlowInput as a, ObjectSchema as b, OptionalSchema as c };