valibot/dist/index.d.ts

The modular and type safe schema library for validating structural data

/**
 * Checks if the input matches the schema. As this is an assertion function, it
 * can be used as a type guard.
 *
 * @param schema The schema to be used.
 * @param input The input to be tested.
 */
declare function assert<const TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(schema: TSchema, input: unknown): asserts input is InferInput<TSchema>;

/**
 * Changes the local configuration of a schema.
 *
 * @param schema The schema to configure.
 * @param config The parse configuration.
 *
 * @returns The configured schema.
 */
declare function config<const TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>>(schema: TSchema, config: Config<InferIssue<TSchema>>): TSchema;

/**
 * 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;
};
/**
 * Returns a fallback value as output if the input does not match the schema.
 *
 * @param schema The schema to catch.
 * @param fallback The fallback value.
 *
 * @returns The passed schema.
 */
declare function fallback<const TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, const TFallback extends Fallback<TSchema>>(schema: TSchema, fallback: TFallback): SchemaWithFallback<TSchema, 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>>>;
};
/**
 * Returns a fallback value as output if the input does not match the schema.
 *
 * @param schema The schema to catch.
 * @param fallback The fallback value.
 *
 * @returns The passed schema.
 */
declare function fallbackAsync<const TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, const TFallback extends FallbackAsync<TSchema>>(schema: TSchema, fallback: TFallback): SchemaWithFallbackAsync<TSchema, TFallback>;

/**
 * Flat errors type.
 */
type FlatErrors<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>> | undefined> = Prettify<{
    /**
     * The root errors.
     *
     * Hint: The error messages of issues without a path that belong to the root
     * of the schema are added to this key.
     */
    readonly root?: [string, ...string[]];
    /**
     * The nested errors.
     *
     * Hint: The error messages of issues with a path that belong to the nested
     * parts of the schema and can be converted to a dot path are added to this
     * key.
     */
    readonly nested?: Prettify<Readonly<Partial<Record<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>> ? IssueDotPath<TSchema> : string, [
        string,
        ...string[]
    ]>>>>;
    /**
     * The other errors.
     *
     * Hint: Some issue paths, for example for complex data types like `Set` and
     * `Map`, have no key or a key that cannot be converted to a dot path. These
     * error messages are added to this key.
     */
    readonly other?: [string, ...string[]];
}>;
/**
 * Flatten the error messages of issues.
 *
 * @param issues The list of issues.
 *
 * @returns A flat error object.
 */
declare function flatten(issues: [BaseIssue<unknown>, ...BaseIssue<unknown>[]]): FlatErrors<undefined>;
/**
 * Flatten the error messages of issues.
 *
 * @param issues The list of issues.
 *
 * @returns A flat error object.
 */
declare function flatten<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>>(issues: [InferIssue<TSchema>, ...InferIssue<TSchema>[]]): FlatErrors<TSchema>;

/**
 * Extracts the exact keys of a tuple, array or object.
 */
type KeyOf$1<TValue> = IsAny<TValue> extends true ? never : TValue extends readonly unknown[] ? number extends TValue['length'] ? number : {
    [TKey in keyof TValue]: TKey extends `${infer TIndex extends number}` ? TIndex : never;
}[number] : TValue extends Record<string, unknown> ? keyof TValue & (string | number) : never;
/**
 * Path type.
 */
type Path$1 = readonly (string | number)[];
/**
 * Required path type.
 */
type RequiredPath$1 = readonly [string | number, ...Path$1];
/**
 * Lazily evaluate only the last valid path segment based on the given value.
 */
type LazyPath$1<TValue, TPathToCheck extends Path$1, TValidPath extends Path$1 = readonly []> = TPathToCheck extends readonly [] ? TValidPath : TPathToCheck extends readonly [
    infer TFirstKey extends KeyOf$1<TValue> & keyof TValue,
    ...infer TPathRest extends Path$1
] ? LazyPath$1<TValue[TFirstKey], TPathRest, readonly [...TValidPath, TFirstKey]> : IsNever<KeyOf$1<TValue>> extends false ? readonly [...TValidPath, KeyOf$1<TValue>] : TValidPath;
/**
 * Returns the path if valid, otherwise the last possible valid path based on
 * the given value.
 */
type ValidPath$1<TValue extends Record<string, unknown> | ArrayLike<unknown>, TPath extends RequiredPath$1> = TPath extends LazyPath$1<TValue, TPath> ? TPath : LazyPath$1<TValue, TPath>;

/**
 * Forwards the issues of the passed validation action.
 *
 * @param action The validation action.
 * @param path The path to forward the issues to.
 *
 * @returns The modified action.
 */
declare function forward<TInput extends Record<string, unknown> | ArrayLike<unknown>, TIssue extends BaseIssue<unknown>, const TPath extends RequiredPath$1>(action: BaseValidation<TInput, TInput, TIssue>, path: ValidPath$1<TInput, TPath>): BaseValidation<TInput, TInput, TIssue>;

/**
 * Forwards the issues of the passed validation action.
 *
 * @param action The validation action.
 * @param path The path to forward the issues to.
 *
 * @returns The modified action.
 */
declare function forwardAsync<TInput extends Record<string, unknown> | ArrayLike<unknown>, TIssue extends BaseIssue<unknown>, const TPath extends RequiredPath$1>(action: BaseValidation<TInput, TInput, TIssue> | BaseValidationAsync<TInput, TInput, TIssue>, path: ValidPath$1<TInput, TPath>): BaseValidationAsync<TInput, TInput, TIssue>;

/**
 * Schema with default type.
 */
type SchemaWithDefault = ExactOptionalSchema<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown> | NullableSchema<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown> | NullishSchema<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown> | OptionalSchema<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown> | UndefinedableSchema<BaseSchema<unknown, unknown, BaseIssue<unknown>>, unknown>;
/**
 * Schema with default async type.
 */
type SchemaWithDefaultAsync = ExactOptionalSchemaAsync<BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, unknown> | NullableSchemaAsync<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> | UndefinedableSchemaAsync<BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, unknown>;
/**
 * Infer default type.
 */
type InferDefault<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>> | SchemaWithDefault | SchemaWithDefaultAsync> = TSchema extends SchemaWithDefault | SchemaWithDefaultAsync ? TSchema['default'] extends (...args: any) => any ? ReturnType<TSchema['default']> : TSchema['default'] : undefined;
/**
 * Returns the default value of the schema.
 *
 * @param schema The schema to get it from.
 * @param dataset The input dataset if available.
 * @param config The config if available.
 *
 * @returns The default value.
 */
declare function getDefault<const TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>>(schema: TSchema, dataset?: UnknownDataset, config?: Config<InferIssue<TSchema>>): InferDefault<TSchema>;

/**
 * Infer defaults type.
 */
type InferDefaults<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>> = TSchema extends LooseObjectSchema<infer TEntries, ErrorMessage<LooseObjectIssue> | undefined> | ObjectSchema<infer TEntries, ErrorMessage<ObjectIssue> | undefined> | ObjectWithRestSchema<infer TEntries, BaseSchema<unknown, unknown, BaseIssue<unknown>>, ErrorMessage<ObjectWithRestIssue> | undefined> | StrictObjectSchema<infer TEntries, ErrorMessage<StrictObjectIssue> | undefined> ? {
    -readonly [TKey in keyof TEntries]: InferDefaults<TEntries[TKey]>;
} : TSchema extends LooseObjectSchemaAsync<infer TEntries, ErrorMessage<LooseObjectIssue> | undefined> | ObjectSchemaAsync<infer TEntries, ErrorMessage<ObjectIssue> | undefined> | ObjectWithRestSchemaAsync<infer TEntries, BaseSchema<unknown, unknown, BaseIssue<unknown>>, ErrorMessage<ObjectWithRestIssue> | undefined> | StrictObjectSchemaAsync<infer TEntries, ErrorMessage<StrictObjectIssue> | undefined> ? {
    -readonly [TKey in keyof TEntries]: InferDefaults<TEntries[TKey]>;
} : TSchema extends LooseTupleSchema<infer TItems, ErrorMessage<LooseTupleIssue> | undefined> | StrictTupleSchema<infer TItems, ErrorMessage<StrictTupleIssue> | undefined> | TupleSchema<infer TItems, ErrorMessage<TupleIssue> | undefined> | TupleWithRestSchema<infer TItems, BaseSchema<unknown, unknown, BaseIssue<unknown>>, ErrorMessage<TupleWithRestIssue> | undefined> ? {
    -readonly [TKey in keyof TItems]: InferDefaults<TItems[TKey]>;
} : TSchema extends LooseTupleSchemaAsync<infer TItems, ErrorMessage<LooseTupleIssue> | undefined> | StrictTupleSchemaAsync<infer TItems, ErrorMessage<StrictTupleIssue> | undefined> | TupleSchemaAsync<infer TItems, ErrorMessage<TupleIssue> | undefined> | TupleWithRestSchemaAsync<infer TItems, BaseSchema<unknown, unknown, BaseIssue<unknown>>, ErrorMessage<TupleWithRestIssue> | undefined> ? {
    -readonly [TKey in keyof TItems]: InferDefaults<TItems[TKey]>;
} : Awaited<InferDefault<TSchema>>;

/**
 * Returns the default values of the schema.
 *
 * Hint: The difference to `getDefault` is that for object and tuple schemas
 * this function recursively returns the default values of the subschemas
 * instead of `undefined`.
 *
 * @param schema The schema to get them from.
 *
 * @returns The default values.
 */
declare function getDefaults<const TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | LooseObjectSchema<ObjectEntries, ErrorMessage<LooseObjectIssue> | undefined> | LooseTupleSchema<TupleItems, ErrorMessage<LooseTupleIssue> | undefined> | ObjectSchema<ObjectEntries, ErrorMessage<ObjectIssue> | undefined> | ObjectWithRestSchema<ObjectEntries, BaseSchema<unknown, unknown, BaseIssue<unknown>>, ErrorMessage<ObjectWithRestIssue> | undefined> | StrictObjectSchema<ObjectEntries, ErrorMessage<StrictObjectIssue> | undefined> | StrictTupleSchema<TupleItems, ErrorMessage<StrictTupleIssue> | undefined> | TupleSchema<TupleItems, ErrorMessage<TupleIssue> | undefined> | TupleWithRestSchema<TupleItems, BaseSchema<unknown, unknown, BaseIssue<unknown>>, ErrorMessage<TupleWithRestIssue> | undefined>>(schema: TSchema): InferDefaults<TSchema>;

/**
 * Returns the default values of the schema.
 *
 * Hint: The difference to `getDefault` is that for object and tuple schemas
 * this function recursively returns the default values of the subschemas
 * instead of `undefined`.
 *
 * @param schema The schema to get them from.
 *
 * @returns The default values.
 */
declare function getDefaultsAsync<const TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>> | LooseObjectSchema<ObjectEntries, ErrorMessage<LooseObjectIssue> | undefined> | LooseObjectSchemaAsync<ObjectEntriesAsync, ErrorMessage<LooseObjectIssue> | undefined> | LooseTupleSchema<TupleItems, ErrorMessage<LooseTupleIssue> | undefined> | LooseTupleSchemaAsync<TupleItemsAsync, ErrorMessage<LooseTupleIssue> | undefined> | ObjectSchema<ObjectEntries, ErrorMessage<ObjectIssue> | undefined> | ObjectSchemaAsync<ObjectEntriesAsync, ErrorMessage<ObjectIssue> | undefined> | ObjectWithRestSchema<ObjectEntries, BaseSchema<unknown, unknown, BaseIssue<unknown>>, ErrorMessage<ObjectWithRestIssue> | undefined> | ObjectWithRestSchemaAsync<ObjectEntriesAsync, BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, ErrorMessage<ObjectWithRestIssue> | undefined> | StrictObjectSchema<ObjectEntries, ErrorMessage<StrictObjectIssue> | undefined> | StrictObjectSchemaAsync<ObjectEntriesAsync, ErrorMessage<StrictObjectIssue> | undefined> | StrictTupleSchema<TupleItems, ErrorMessage<StrictTupleIssue> | undefined> | StrictTupleSchemaAsync<TupleItemsAsync, ErrorMessage<StrictTupleIssue> | undefined> | TupleSchema<TupleItems, ErrorMessage<TupleIssue> | undefined> | TupleSchemaAsync<TupleItemsAsync, ErrorMessage<TupleIssue> | undefined> | TupleWithRestSchema<TupleItems, BaseSchema<unknown, unknown, BaseIssue<unknown>>, ErrorMessage<TupleWithRestIssue> | undefined> | TupleWithRestSchemaAsync<TupleItemsAsync, BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, ErrorMessage<TupleWithRestIssue> | undefined>>(schema: TSchema): Promise<InferDefaults<TSchema>>;

/**
 * Infer fallback type.
 */
type InferFallback<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>> = TSchema extends SchemaWithFallback<BaseSchema<unknown, unknown, BaseIssue<unknown>>, infer TFallback> | SchemaWithFallbackAsync<BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, infer TFallback> ? TFallback extends InferOutput<TSchema> ? TFallback : TFallback extends () => MaybePromise<InferOutput<TSchema>> ? ReturnType<TFallback> : never : undefined;
/**
 * Returns the fallback value of the schema.
 *
 * @param schema The schema to get it from.
 * @param dataset The output dataset if available.
 * @param config The config if available.
 *
 * @returns The fallback value.
 */
declare function getFallback<const TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>>(schema: TSchema, dataset?: OutputDataset<InferOutput<TSchema>, InferIssue<TSchema>>, config?: Config<InferIssue<TSchema>>): InferFallback<TSchema>;

/**
 * Infer fallbacks type.
 */
type InferFallbacks<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>> = TSchema extends LooseObjectSchema<infer TEntries, ErrorMessage<LooseObjectIssue> | undefined> | ObjectSchema<infer TEntries, ErrorMessage<ObjectIssue> | undefined> | ObjectWithRestSchema<infer TEntries, BaseSchema<unknown, unknown, BaseIssue<unknown>>, ErrorMessage<ObjectWithRestIssue> | undefined> | StrictObjectSchema<infer TEntries, ErrorMessage<StrictObjectIssue> | undefined> ? {
    -readonly [TKey in keyof TEntries]: InferFallbacks<TEntries[TKey]>;
} : TSchema extends LooseObjectSchemaAsync<infer TEntries, ErrorMessage<LooseObjectIssue> | undefined> | ObjectSchemaAsync<infer TEntries, ErrorMessage<ObjectIssue> | undefined> | ObjectWithRestSchemaAsync<infer TEntries, BaseSchema<unknown, unknown, BaseIssue<unknown>>, ErrorMessage<ObjectWithRestIssue> | undefined> | StrictObjectSchemaAsync<infer TEntries, ErrorMessage<StrictObjectIssue> | undefined> ? {
    -readonly [TKey in keyof TEntries]: InferFallbacks<TEntries[TKey]>;
} : TSchema extends LooseTupleSchema<infer TItems, ErrorMessage<LooseTupleIssue> | undefined> | StrictTupleSchema<infer TItems, ErrorMessage<StrictTupleIssue> | undefined> | TupleSchema<infer TItems, ErrorMessage<TupleIssue> | undefined> | TupleWithRestSchema<infer TItems, BaseSchema<unknown, unknown, BaseIssue<unknown>>, ErrorMessage<TupleWithRestIssue> | undefined> ? {
    -readonly [TKey in keyof TItems]: InferFallbacks<TItems[TKey]>;
} : TSchema extends LooseTupleSchemaAsync<infer TItems, ErrorMessage<LooseTupleIssue> | undefined> | StrictTupleSchemaAsync<infer TItems, ErrorMessage<StrictTupleIssue> | undefined> | TupleSchemaAsync<infer TItems, ErrorMessage<TupleIssue> | undefined> | TupleWithRestSchemaAsync<infer TItems, BaseSchema<unknown, unknown, BaseIssue<unknown>>, ErrorMessage<TupleWithRestIssue> | undefined> ? {
    -readonly [TKey in keyof TItems]: InferFallbacks<TItems[TKey]>;
} : Awaited<InferFallback<TSchema>>;

/**
 * Returns the fallback values of the schema.
 *
 * Hint: The difference to `getFallback` is that for object and tuple schemas
 * this function recursively returns the fallback values of the subschemas
 * instead of `undefined`.
 *
 * @param schema The schema to get them from.
 *
 * @returns The fallback values.
 */
declare function getFallbacks<const TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | LooseObjectSchema<ObjectEntries, ErrorMessage<LooseObjectIssue> | undefined> | LooseTupleSchema<TupleItems, ErrorMessage<LooseTupleIssue> | undefined> | ObjectSchema<ObjectEntries, ErrorMessage<ObjectIssue> | undefined> | ObjectWithRestSchema<ObjectEntries, BaseSchema<unknown, unknown, BaseIssue<unknown>>, ErrorMessage<ObjectWithRestIssue> | undefined> | StrictObjectSchema<ObjectEntries, ErrorMessage<StrictObjectIssue> | undefined> | StrictTupleSchema<TupleItems, ErrorMessage<StrictTupleIssue> | undefined> | TupleSchema<TupleItems, ErrorMessage<TupleIssue> | undefined> | TupleWithRestSchema<TupleItems, BaseSchema<unknown, unknown, BaseIssue<unknown>>, ErrorMessage<TupleWithRestIssue> | undefined>>(schema: TSchema): InferFallbacks<TSchema>;

/**
 * Returns the fallback values of the schema.
 *
 * Hint: The difference to `getFallback` is that for object and tuple schemas
 * this function recursively returns the fallback values of the subschemas
 * instead of `undefined`.
 *
 * @param schema The schema to get them from.
 *
 * @returns The fallback values.
 */
declare function getFallbacksAsync<const TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>> | LooseObjectSchema<ObjectEntries, ErrorMessage<LooseObjectIssue> | undefined> | LooseObjectSchemaAsync<ObjectEntriesAsync, ErrorMessage<LooseObjectIssue> | undefined> | LooseTupleSchema<TupleItems, ErrorMessage<LooseTupleIssue> | undefined> | LooseTupleSchemaAsync<TupleItemsAsync, ErrorMessage<LooseTupleIssue> | undefined> | ObjectSchema<ObjectEntries, ErrorMessage<ObjectIssue> | undefined> | ObjectSchemaAsync<ObjectEntriesAsync, ErrorMessage<ObjectIssue> | undefined> | ObjectWithRestSchema<ObjectEntries, BaseSchema<unknown, unknown, BaseIssue<unknown>>, ErrorMessage<ObjectWithRestIssue> | undefined> | ObjectWithRestSchemaAsync<ObjectEntriesAsync, BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, ErrorMessage<ObjectWithRestIssue> | undefined> | StrictObjectSchema<ObjectEntries, ErrorMessage<StrictObjectIssue> | undefined> | StrictObjectSchemaAsync<ObjectEntriesAsync, ErrorMessage<StrictObjectIssue> | undefined> | StrictTupleSchema<TupleItems, ErrorMessage<StrictTupleIssue> | undefined> | StrictTupleSchemaAsync<TupleItemsAsync, ErrorMessage<StrictTupleIssue> | undefined> | TupleSchema<TupleItems, ErrorMessage<TupleIssue> | undefined> | TupleSchemaAsync<TupleItemsAsync, ErrorMessage<TupleIssue> | undefined> | TupleWithRestSchema<TupleItems, BaseSchema<unknown, unknown, BaseIssue<unknown>>, ErrorMessage<TupleWithRestIssue> | undefined> | TupleWithRestSchemaAsync<TupleItemsAsync, BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, ErrorMessage<TupleWithRestIssue> | undefined>>(schema: TSchema): Promise<InferFallbacks<TSchema>>;

/**
 * Checks if the input matches the schema. By using a type predicate, this
 * function can be used as a type guard.
 *
 * @param schema The schema to be used.
 * @param input The input to be tested.
 *
 * @returns Whether the input matches the schema.
 */
declare function is<const TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(schema: TSchema, input: unknown): input is InferInput<TSchema>;

/**
 * Schema type.
 */
type Schema$9 = LooseObjectSchema<ObjectEntries, ErrorMessage<LooseObjectIssue> | undefined> | LooseObjectSchemaAsync<ObjectEntriesAsync, ErrorMessage<LooseObjectIssue> | undefined> | ObjectSchema<ObjectEntries, ErrorMessage<ObjectIssue> | undefined> | ObjectSchemaAsync<ObjectEntriesAsync, ErrorMessage<ObjectIssue> | undefined> | ObjectWithRestSchema<ObjectEntries, BaseSchema<unknown, unknown, BaseIssue<unknown>>, ErrorMessage<ObjectWithRestIssue> | undefined> | ObjectWithRestSchemaAsync<ObjectEntriesAsync, BaseSchema<unknown, unknown, BaseIssue<unknown>>, ErrorMessage<ObjectWithRestIssue> | undefined> | StrictObjectSchema<ObjectEntries, ErrorMessage<StrictObjectIssue> | undefined> | StrictObjectSchemaAsync<ObjectEntriesAsync, ErrorMessage<StrictObjectIssue> | undefined>;
/**
 * Force tuple type.
 */
type ForceTuple<T> = T extends [string, ...string[]] ? T : [];
/**
 * Object keys type.
 */
type ObjectKeys$1<TSchema extends Schema$9> = ForceTuple<UnionToTuple<keyof TSchema['entries']>>;
/**
 * Creates a picklist schema of object keys.
 *
 * @param schema The object schema.
 *
 * @returns A picklist schema.
 */
declare function keyof<const TSchema extends Schema$9>(schema: TSchema): PicklistSchema<ObjectKeys$1<TSchema>, undefined>;
/**
 * Creates a picklist schema of object keys.
 *
 * @param schema The object schema.
 * @param message The error message.
 *
 * @returns A picklist schema.
 */
declare function keyof<const TSchema extends Schema$9, const TMessage extends ErrorMessage<PicklistIssue> | undefined>(schema: TSchema, message: TMessage): PicklistSchema<ObjectKeys$1<TSchema>, TMessage>;

/**
 * Schema type.
 */
type Schema$8 = SchemaWithoutPipe<LooseObjectSchema<ObjectEntries, ErrorMessage<LooseObjectIssue> | undefined> | LooseObjectSchemaAsync<ObjectEntriesAsync, ErrorMessage<LooseObjectIssue> | undefined> | ObjectSchema<ObjectEntries, ErrorMessage<ObjectIssue> | undefined> | ObjectSchemaAsync<ObjectEntriesAsync, ErrorMessage<ObjectIssue> | undefined> | ObjectWithRestSchema<ObjectEntries, BaseSchema<unknown, unknown, BaseIssue<unknown>>, ErrorMessage<ObjectWithRestIssue> | undefined> | ObjectWithRestSchemaAsync<ObjectEntriesAsync, BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, ErrorMessage<ObjectWithRestIssue> | undefined> | StrictObjectSchema<ObjectEntries, ErrorMessage<StrictObjectIssue> | undefined> | StrictObjectSchemaAsync<ObjectEntriesAsync, ErrorMessage<StrictObjectIssue> | undefined>>;
/**
 * Schema with omit type.
 */
type SchemaWithOmit<TSchema extends Schema$8, TKeys extends ObjectKeys<TSchema>> = TSchema extends ObjectSchema<infer TEntries, ErrorMessage<ObjectIssue> | undefined> | StrictObjectSchema<infer TEntries, ErrorMessage<StrictObjectIssue> | undefined> ? Omit<TSchema, 'entries' | '~standard' | '~run' | '~types'> & {
    /**
     * The object entries.
     */
    readonly entries: Omit<TEntries, TKeys[number]>;
    /**
     * The Standard Schema properties.
     *
     * @internal
     */
    readonly '~standard': StandardProps<InferObjectInput<Omit<TEntries, TKeys[number]>>, InferObjectOutput<Omit<TEntries, TKeys[number]>>>;
    /**
     * Parses unknown input.
     *
     * @param dataset The input dataset.
     * @param config The configuration.
     *
     * @returns The output dataset.
     *
     * @internal
     */
    readonly '~run': (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => OutputDataset<InferObjectOutput<Omit<TEntries, TKeys[number]>>, Extract<InferIssue<TSchema>, {
        type: TSchema['type'];
    }> | InferObjectIssue<Omit<TEntries, TKeys[number]>>>;
    /**
     * The input, output and issue type.
     *
     * @internal
     */
    readonly '~types'?: {
        readonly input: InferObjectInput<Omit<TEntries, TKeys[number]>>;
        readonly output: InferObjectOutput<Omit<TEntries, TKeys[number]>>;
        readonly issue: Extract<InferIssue<TSchema>, {
            type: TSchema['type'];
        }> | InferObjectIssue<Omit<TEntries, TKeys[number]>>;
    } | undefined;
} : TSchema extends ObjectSchemaAsync<infer TEntries, ErrorMessage<ObjectIssue> | undefined> | StrictObjectSchemaAsync<infer TEntries, ErrorMessage<StrictObjectIssue> | undefined> ? Omit<TSchema, 'entries' | '~standard' | '~run' | '~types'> & {
    /**
     * The object entries.
     */
    readonly entries: Omit<TEntries, TKeys[number]>;
    /**
     * The Standard Schema properties.
     *
     * @internal
     */
    readonly '~standard': StandardProps<InferObjectInput<Omit<TEntries, TKeys[number]>>, InferObjectOutput<Omit<TEntries, TKeys[number]>>>;
    /**
     * Parses unknown input.
     *
     * @param dataset The input dataset.
     * @param config The configuration.
     *
     * @returns The output dataset.
     *
     * @internal
     */
    readonly '~run': (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<InferObjectOutput<Omit<TEntries, TKeys[number]>>, Extract<InferIssue<TSchema>, {
        type: TSchema['type'];
    }> | InferObjectIssue<Omit<TEntries, TKeys[number]>>>>;
    /**
     * The input, output and issue type.
     *
     * @internal
     */
    readonly '~types'?: {
        readonly input: InferObjectInput<Omit<TEntries, TKeys[number]>>;
        readonly output: InferObjectOutput<Omit<TEntries, TKeys[number]>>;
        readonly issue: Extract<InferIssue<TSchema>, {
            type: TSchema['type'];
        }> | InferObjectIssue<Omit<TEntries, TKeys[number]>>;
    } | undefined;
} : TSchema extends LooseObjectSchema<infer TEntries, ErrorMessage<LooseObjectIssue> | undefined> ? Omit<TSchema, 'entries' | '~standard' | '~run' | '~types'> & {
    /**
     * The object entries.
     */
    readonly entries: Omit<TEntries, TKeys[number]>;
    /**
     * The Standard Schema properties.
     *
     * @internal
     */
    readonly '~standard': StandardProps<InferObjectInput<Omit<TEntries, TKeys[number]>> & {
        [key: string]: unknown;
    }, InferObjectInput<Omit<TEntries, TKeys[number]>> & {
        [key: string]: unknown;
    }>;
    /**
     * Parses unknown input.
     *
     * @param dataset The input dataset.
     * @param config The configuration.
     *
     * @returns The output dataset.
     *
     * @internal
     */
    readonly '~run': (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => OutputDataset<InferObjectOutput<Omit<TEntries, TKeys[number]>> & {
        [key: string]: unknown;
    }, Extract<InferIssue<TSchema>, {
        type: TSchema['type'];
    }> | InferObjectIssue<Omit<TEntries, TKeys[number]>>>;
    /**
     * The input, output and issue type.
     *
     * @internal
     */
    readonly '~types'?: {
        readonly input: InferObjectInput<Omit<TEntries, TKeys[number]>> & {
            [key: string]: unknown;
        };
        readonly output: InferObjectOutput<Omit<TEntries, TKeys[number]>> & {
            [key: string]: unknown;
        };
        readonly issue: Extract<InferIssue<TSchema>, {
            type: TSchema['type'];
        }> | InferObjectIssue<Omit<TEntries, TKeys[number]>>;
    } | undefined;
} : TSchema extends LooseObjectSchemaAsync<infer TEntries, ErrorMessage<LooseObjectIssue> | undefined> ? Omit<TSchema, 'entries' | '~standard' | '~run' | '~types'> & {
    /**
     * The object entries.
     */
    readonly entries: Omit<TEntries, TKeys[number]>;
    /**
     * The Standard Schema properties.
     *
     * @internal
     */
    readonly '~standard': StandardProps<InferObjectInput<Omit<TEntries, TKeys[number]>> & {
        [key: string]: unknown;
    }, InferObjectInput<Omit<TEntries, TKeys[number]>> & {
        [key: string]: unknown;
    }>;
    /**
     * Parses unknown input.
     *
     * @param dataset The input dataset.
     * @param config The configuration.
     *
     * @returns The output dataset.
     *
     * @internal
     */
    readonly '~run': (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<InferObjectOutput<Omit<TEntries, TKeys[number]>> & {
        [key: string]: unknown;
    }, Extract<InferIssue<TSchema>, {
        type: TSchema['type'];
    }> | InferObjectIssue<Omit<TEntries, TKeys[number]>>>>;
    /**
     * The input, output and issue type.
     *
     * @internal
     */
    readonly '~types'?: {
        readonly input: InferObjectInput<Omit<TEntries, TKeys[number]>> & {
            [key: string]: unknown;
        };
        readonly output: InferObjectOutput<Omit<TEntries, TKeys[number]>> & {
            [key: string]: unknown;
        };
        readonly issue: Extract<InferIssue<TSchema>, {
            type: TSchema['type'];
        }> | InferObjectIssue<Omit<TEntries, TKeys[number]>>;
    } | undefined;
} : TSchema extends ObjectWithRestSchema<infer TEntries, BaseSchema<unknown, unknown, BaseIssue<unknown>>, ErrorMessage<ObjectWithRestIssue> | undefined> ? Omit<TSchema, 'entries' | '~standard' | '~run' | '~types'> & {
    /**
     * The object entries.
     */
    readonly entries: Omit<TEntries, TKeys[number]>;
    /**
     * The Standard Schema properties.
     *
     * @internal
     */
    readonly '~standard': StandardProps<InferObjectInput<Omit<TEntries, TKeys[number]>> & {
        [key: string]: InferInput<TSchema['rest']>;
    }, InferObjectOutput<Omit<TEntries, TKeys[number]>> & {
        [key: string]: InferOutput<TSchema['rest']>;
    }>;
    /**
     * Parses unknown input.
     *
     * @param dataset The input dataset.
     * @param config The configuration.
     *
     * @returns The output dataset.
     *
     * @internal
     */
    readonly '~run': (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => OutputDataset<InferObjectOutput<Omit<TEntries, TKeys[number]>> & {
        [key: string]: InferOutput<TSchema['rest']>;
    }, Extract<InferIssue<TSchema>, {
        type: TSchema['type'];
    }> | InferObjectIssue<Omit<TEntries, TKeys[number]>> | InferIssue<TSchema['rest']>>;
    /**
     * The input, output and issue type.
     *
     * @internal
     */
    readonly '~types'?: {
        readonly input: InferObjectInput<Omit<TEntries, TKeys[number]>> & {
            [key: string]: InferInput<TSchema['rest']>;
        };
        readonly output: InferObjectOutput<Omit<TEntries, TKeys[number]>> & {
            [key: string]: InferOutput<TSchema['rest']>;
        };
        readonly issue: Extract<InferIssue<TSchema>, {
            type: TSchema['type'];
        }> | InferObjectIssue<Omit<TEntries, TKeys[number]>> | InferIssue<TSchema['rest']>;
    } | undefined;
} : TSchema extends ObjectWithRestSchemaAsync<infer TEntries, BaseSchema<unknown, unknown, BaseIssue<unknown>>, ErrorMessage<ObjectWithRestIssue> | undefined> ? Omit<TSchema, 'entries' | '~standard' | '~run' | '~types'> & {
    /**
     * The object entries.
     */
    readonly entries: Omit<TEntries, TKeys[number]>;
    /**
     * The Standard Schema properties.
     *
     * @internal
     */
    readonly '~standard': StandardProps<InferObjectInput<Omit<TEntries, TKeys[number]>> & {
        [key: string]: InferInput<TSchema['rest']>;
    }, InferObjectOutput<Omit<TEntries, TKeys[number]>> & {
        [key: string]: InferOutput<TSchema['rest']>;
    }>;
    /**
     * Parses unknown input.
     *
     * @param dataset The input dataset.
     * @param config The configuration.
     *
     * @returns The output dataset.
     *
     * @internal
     */
    readonly '~run': (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<InferObjectOutput<Omit<TEntries, TKeys[number]>> & {
        [key: string]: InferOutput<TSchema['rest']>;
    }, Extract<InferIssue<TSchema>, {
        type: TSchema['type'];
    }> | InferObjectIssue<Omit<TEntries, TKeys[number]>> | InferIssue<TSchema['rest']>>>;
    /**
     * The input, output and issue type.
     *
     * @internal
     */
    readonly '~types'?: {
        readonly input: InferObjectInput<Omit<TEntries, TKeys[number]>> & {
            [key: string]: InferInput<TSchema['rest']>;
        };
        readonly output: InferObjectOutput<Omit<TEntries, TKeys[number]>> & {
            [key: string]: InferOutput<TSchema['rest']>;
        };
        readonly issue: Extract<InferIssue<TSchema>, {
            type: TSchema['type'];
        }> | InferObjectIssue<Omit<TEntries, TKeys[number]>> | InferIssue<TSchema['rest']>;
    } | undefined;
} : never;
/**
 * Creates a modified copy of an object schema that does not contain the
 * selected entries.
 *
 * @param schema The schema to omit from.
 * @param keys The selected entries.
 *
 * @returns An object schema.
 */
declare function omit<const TSchema extends Schema$8, const TKeys extends ObjectKeys<TSchema>>(schema: TSchema, keys: TKeys): SchemaWithOmit<TSchema, TKeys>;

/**
 * Parses an unknown input based on a schema.
 *
 * @param schema The schema to be used.
 * @param input The input to be parsed.
 * @param config The parse configuration.
 *
 * @returns The parsed input.
 */
declare function parse<const TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(schema: TSchema, input: unknown, config?: Config<InferIssue<TSchema>>): InferOutput<TSchema>;

/**
 * Parses an unknown input based on a schema.
 *
 * @param schema The schema to be used.
 * @param input The input to be parsed.
 * @param config The parse configuration.
 *
 * @returns The parsed input.
 */
declare function parseAsync<const TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>>(schema: TSchema, input: unknown, config?: Config<InferIssue<TSchema>>): Promise<InferOutput<TSchema>>;

/**
 * The parser interface.
 */
interface Parser<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, TConfig extends Config<InferIssue<TSchema>> | undefined> {
    /**
     * Parses an unknown input based on the schema.
     */
    (input: unknown): InferOutput<TSchema>;
    /**
     * The schema to be used.
     */
    readonly schema: TSchema;
    /**
     * The parser configuration.
     */
    readonly config: TConfig;
}
/**
 * Returns a function that parses an unknown input based on a schema.
 *
 * @param schema The schema to be used.
 *
 * @returns The parser function.
 */
declare function parser<const TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(schema: TSchema): Parser<TSchema, undefined>;
/**
 * Returns a function that parses an unknown input based on a schema.
 *
 * @param schema The schema to be used.
 * @param config The parser configuration.
 *
 * @returns The parser function.
 */
declare function parser<const TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>>, const TConfig extends Config<InferIssue<TSchema>> | undefined>(schema: TSchema, config: TConfig): Parser<TSchema, TConfig>;

/**
 * The parser async interface.
 */
interface ParserAsync<TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, TConfig extends Config<InferIssue<TSchema>> | undefined> {
    /**
     * Parses an unknown input based on the schema.
     */
    (input: unknown): Promise<InferOutput<TSchema>>;
    /**
     * The schema to be used.
     */
    readonly schema: TSchema;
    /**
     * The parser configuration.
     */
    readonly config: TConfig;
}
/**
 * Returns a function that parses an unknown input based on a schema.
 *
 * @param schema The schema to be used.
 *
 * @returns The parser function.
 */
declare function parserAsync<const TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>>(schema: TSchema): ParserAsync<TSchema, undefined>;
/**
 * Returns a function that parses an unknown input based on a schema.
 *
 * @param schema The schema to be used.
 * @param config The parser configuration.
 *
 * @returns The parser function.
 */
declare function parserAsync<const TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, const TConfig extends Config<InferIssue<TSchema>> | undefined>(schema: TSchema, config: TConfig): ParserAsync<TSchema, TConfig>;

/**
 * Schema type.
 */
type Schema$7 = SchemaWithoutPipe<LooseObjectSchema<ObjectEntries, ErrorMessage<LooseObjectIssue> | undefined> | ObjectSchema<ObjectEntries, ErrorMessage<ObjectIssue> | undefined> | ObjectWithRestSchema<ObjectEntries, BaseSchema<unknown, unknown, BaseIssue<unknown>>, ErrorMessage<ObjectWithRestIssue> | undefined> | StrictObjectSchema<ObjectEntries, ErrorMessage<StrictObjectIssue> | undefined>>;
/**
 * Partial entries type.
 */
type PartialEntries$1<TEntries extends ObjectEntries, TKeys extends readonly (keyof TEntries)[] | undefined> = {
    [TKey in keyof TEntries]: TKeys extends readonly (keyof TEntries)[] ? TKey extends TKeys[number] ? OptionalSchema<TEntries[TKey], undefined> : TEntries[TKey] : OptionalSchema<TEntries[TKey], undefined>;
};
/**
 * Schema with partial type.
 */
type SchemaWithPartial<TSchema extends Schema$7, TKeys extends ObjectKeys<TSchema> | undefined> = TSchema extends ObjectSchema<infer TEntries, ErrorMessage<ObjectIssue> | undefined> | StrictObjectSchema<infer TEntries, ErrorMessage<StrictObjectIssue> | undefined> ? Omit<TSchema, 'entries' | '~standard' | '~run' | '~types'> & {
    /**
     * The object entries.
     */
    readonly entries: PartialEntries$1<TEntries, TKeys>;
    /**
     * The Standard Schema properties.
     *
     * @internal
     */
    readonly '~standard': StandardProps<InferObjectInput<PartialEntries$1<TEntries, TKeys>>, InferObjectOutput<PartialEntries$1<TEntries, TKeys>>>;
    /**
     * Parses unknown input.
     *
     * @param dataset The input dataset.
     * @param config The configuration.
     *
     * @returns The output dataset.
     *
     * @internal
     */
    readonly '~run': (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => OutputDataset<InferObjectOutput<PartialEntries$1<TEntries, TKeys>>, InferIssue<TSchema>>;
    /**
     * The input, output and issue type.
     *
     * @internal
     */
    readonly '~types'?: {
        readonly input: InferObjectInput<PartialEntries$1<TEntries, TKeys>>;
        readonly output: InferObjectOutput<PartialEntries$1<TEntries, TKeys>>;
        readonly issue: InferIssue<TSchema>;
    } | undefined;
} : TSchema extends LooseObjectSchema<infer TEntries, ErrorMessage<LooseObjectIssue> | undefined> ? Omit<TSchema, 'entries' | '~standard' | '~run' | '~types'> & {
    /**
     * The object entries.
     */
    readonly entries: PartialEntries$1<TEntries, TKeys>;
    /**
     * The Standard Schema properties.
     *
     * @internal
     */
    readonly '~standard': StandardProps<InferObjectInput<PartialEntries$1<TEntries, TKeys>> & {
        [key: string]: unknown;
    }, InferObjectOutput<PartialEntries$1<TEntries, TKeys>> & {
        [key: string]: unknown;
    }>;
    /**
     * Parses unknown input.
     *
     * @param dataset The input dataset.
     * @param config The configuration.
     *
     * @returns The output dataset.
     *
     * @internal
     */
    readonly '~run': (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => OutputDataset<InferObjectOutput<PartialEntries$1<TEntries, TKeys>> & {
        [key: string]: unknown;
    }, InferIssue<TSchema>>;
    /**
     * The input, output and issue type.
     *
     * @internal
     */
    readonly '~types'?: {
        readonly input: InferObjectInput<PartialEntries$1<TEntries, TKeys>> & {
            [key: string]: unknown;
        };
        readonly output: InferObjectOutput<PartialEntries$1<TEntries, TKeys>> & {
            [key: string]: unknown;
        };
        readonly issue: InferIssue<TSchema>;
    } | undefined;
} : TSchema extends ObjectWithRestSchema<infer TEntries, infer TRest, ErrorMessage<ObjectWithRestIssue> | undefined> ? Omit<TSchema, 'entries' | '~standard' | '~run' | '~types'> & {
    /**
     * The object entries.
     */
    readonly entries: PartialEntries$1<TEntries, TKeys>;
    /**
     * The Standard Schema properties.
     *
     * @internal
     */
    readonly '~standard': StandardProps<InferObjectInput<PartialEntries$1<TEntries, TKeys>> & {
        [key: string]: InferInput<TRest>;
    }, InferObjectOutput<PartialEntries$1<TEntries, TKeys>> & {
        [key: string]: InferOutput<TRest>;
    }>;
    /**
     * Parses unknown input.
     *
     * @param dataset The input dataset.
     * @param config The configuration.
     *
     * @returns The output dataset.
     *
     * @internal
     */
    readonly '~run': (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => OutputDataset<InferObjectOutput<PartialEntries$1<TEntries, TKeys>> & {
        [key: string]: InferOutput<TRest>;
    }, InferIssue<TSchema>>;
    /**
     * The input, output and issue type.
     *
     * @internal
     */
    readonly '~types'?: {
        readonly input: InferObjectInput<PartialEntries$1<TEntries, TKeys>> & {
            [key: string]: InferInput<TRest>;
        };
        readonly output: InferObjectOutput<PartialEntries$1<TEntries, TKeys>> & {
            [key: string]: InferOutput<TRest>;
        };
        readonly issue: InferIssue<TSchema>;
    } | undefined;
} : never;
/**
 * Creates a modified copy of an object schema that marks all entries as optional.
 *
 * @param schema The schema to modify.
 *
 * @returns An object schema.
 */
declare function partial<const TSchema extends Schema$7>(schema: TSchema): SchemaWithPartial<TSchema, undefined>;
/**
 * Creates a modified copy of an object schema that marks the selected entries
 * as optional.
 *
 * @param schema The schema to modify.
 * @param keys The selected entries.
 *
 * @returns An object schema.
 */
declare function partial<const TSchema extends Schema$7, const TKeys extends ObjectKeys<TSchema>>(schema: TSchema, keys: TKeys): SchemaWithPartial<TSchema, TKeys>;

/**
 * Schema type.
 */
type Schema$6 = SchemaWithoutPipe<LooseObjectSchemaAsync<ObjectEntriesAsync, ErrorMessage<LooseObjectIssue> | undefined> | ObjectSchemaAsync<ObjectEntriesAsync, ErrorMessage<ObjectIssue> | undefined> | ObjectWithRestSchemaAsync<ObjectEntriesAsync, BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>, ErrorMessage<ObjectWithRestIssue> | undefined> | StrictObjectSchemaAsync<ObjectEntriesAsync, ErrorMessage<StrictObjectIssue> | undefined>>;
/**
 * Partial entries type.
 */
type PartialEntries<TEntries extends ObjectEntriesAsync, TKeys extends readonly (keyof TEntries)[] | undefined> = {
    [TKey in keyof TEntries]: TKeys extends readonly (keyof TEntries)[] ? TKey extends TKeys[number] ? OptionalSchemaAsync<TEntries[TKey], undefined> : TEntries[TKey] : OptionalSchemaAsync<TEntries[TKey], undefined>;
};
/**
 * Schema with partial type.
 */
type SchemaWithPartialAsync<TSchema extends Schema$6, TKeys extends ObjectKeys<TSchema> | undefined> = TSchema extends ObjectSchemaAsync<infer TEntries, ErrorMessage<ObjectIssue> | undefined> | StrictObjectSchemaAsync<infer TEntries, ErrorMessage<StrictObjectIssue> | undefined> ? Omit<TSchema, 'entries' | '~standard' | '~run' | '~types'> & {
    /**
     * The object entries.
     */
    readonly entries: PartialEntries<TEntries, TKeys>;
    /**
     * The Standard Schema properties.
     *
     * @internal
     */
    readonly '~standard': StandardProps<InferObjectInput<PartialEntries<TEntries, TKeys>>, InferObjectOutput<PartialEntries<TEntries, TKeys>>>;
    /**
     * Parses unknown input.
     *
     * @param dataset The input dataset.
     * @param config The configuration.
     *
     * @returns The output dataset.
     *
     * @internal
     */
    readonly '~run': (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<InferObjectOutput<PartialEntries<TEntries, TKeys>>, InferIssue<TSchema>>>;
    /**
     * The input, output and issue type.
     *
     * @internal
     */
    readonly '~types'?: {
        readonly input: InferObjectInput<PartialEntries<TEntries, TKeys>>;
        readonly output: InferObjectOutput<PartialEntries<TEntries, TKeys>>;
        readonly issue: InferIssue<TSchema>;
    } | undefined;
} : TSchema extends LooseObjectSchemaAsync<infer TEntries, ErrorMessage<LooseObjectIssue> | undefined> ? Omit<TSchema, 'entries' | '~standard' | '~run' | '~types'> & {
    /**
     * The object entries.
     */
    readonly entries: PartialEntries<TEntries, TKeys>;
    /**
     * The Standard Schema properties.
     *
     * @internal
     */
    readonly '~standard': StandardProps<InferObjectInput<PartialEntries<TEntries, TKeys>> & {
        [key: string]: unknown;
    }, InferObjectOutput<PartialEntries<TEntries, TKeys>> & {
        [key: string]: unknown;
    }>;
    /**
     * Parses unknown input.
     *
     * @param dataset The input dataset.
     * @param config The configuration.
     *
     * @returns The output dataset.
     *
     * @internal
     */
    readonly '~run': (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<InferObjectOutput<PartialEntries<TEntries, TKeys>> & {
        [key: string]: unknown;
    }, InferIssue<TSchema>>>;
    /**
     * The input, output and issue type.
     *
     * @internal
     */
    readonly '~types'?: {
        readonly input: InferObjectInput<PartialEntries<TEntries, TKeys>> & {
            [key: string]: unknown;
        };
        readonly output: InferObjectOutput<PartialEntries<TEntries, TKeys>> & {
            [key: string]: unknown;
        };
        readonly issue: InferIssue<TSchema>;
    } | undefined;
} : TSchema extends ObjectWithRestSchemaAsync<infer TEntries, infer TRest, ErrorMessage<ObjectWithRestIssue> | undefined> ? Omit<TSchema, 'entries' | '~standard' | '~run' | '~types'> & {
    /**
     * The object entries.
     */
    readonly entries: PartialEntries<TEntries, TKeys>;
    /**
     * The Standard Schema properties.
     *
     * @internal
     */
    readonly '~standard': StandardProps<InferObjectInput<PartialEntries<TEntries, TKeys>> & {
        [key: string]: InferInput<TRest>;
    }, InferObjectOutput<PartialEntries<TEntries, TKeys>> & {
        [key: string]: InferOutput<TRest>;
    }>;
    /**
     * Parses unknown input.
     *
     * @param dataset The input dataset.
     * @param config The configuration.
     *
     * @returns The output dataset.
     *
     * @internal
     */
    readonly '~run': (dataset: UnknownDataset, config: Config<BaseIssue<unknown>>) => Promise<OutputDataset<InferObjectOutput<PartialEntries<TEntries, TKeys>> & {
        [key: string]: InferOutput<TRest>;
    }, InferIssue<TSchema>>>;
    /**
     * The input, output and issue type.
     *
     * @internal
     */
    readonly '~types'?: {
        readonly input: InferObjectInput<PartialEntries<TEntries, TKeys>> & {
            [key: string]: InferInput<TRest>;
        };
        readonly output: InferObjectOutput<PartialEntries<TEntries, TKeys>> & {
            [key: string]: InferOutput<TRest>;
        };
        readonly issue: InferIssue<TSchema>;
    } | undefined;
} : never;
/**
 * Creates a modified copy of an object schema that marks all entries as optional.
 *
 * @param schema The schema to modify.
 *
 * @returns An object schema.
 */
declare function partialAsync<const TSchema extends Schema$6>(schema: TSchema): SchemaWithPartialAsync<TSchema, undefined>;
/**
 * Creates a modified copy of an object schema that marks the selected entries
 * as optional.
 *
 * @param schema The schema to modify.
 * @param keys The selected entries.
 *
 * @returns An object schema.
 */
declare function partialAsync<const TSchema extends Schema$6, const TKeys extends ObjectKeys<TSchema>>(schema: TSchema, keys: TKeys): SchemaWithPartialAsync<TSchema, TKeys>;

/**
 * The schema