/**
 * Argument validators for function definitions.
 *
 * These serve double duty:
 * 1. Runtime validation — reject bad input before the handler runs.
 * 2. Type inference — TypeScript infers handler arg types from validators.
 *
 * @example
 * ```typescript
 * import { mutation, v } from "@pylonsync/functions";
 *
 * export default mutation({
 *   args: {
 *     name: v.string(),
 *     age: v.optional(v.number()),
 *     tags: v.array(v.string()),
 *   },
 *   async handler(ctx, args) {
 *     // args is typed as { name: string, age?: number, tags: string[] }
 *   },
 * });
 * ```
 */
import type { AnyValidator, InferArgs, InferValidator, Validator, ValidatorSchema } from "./types";
export declare const v: {
    /** String value. */
    string: () => Validator<string, false>;
    /** Number (float64). Same as `v.float()`. */
    number: () => Validator<number, false>;
    /**
     * 64-bit float. Alias for `v.number()` so the validator API matches the
     * schema DSL (which uses `field.float()`). Prefer this in new code.
     */
    float: () => Validator<number, false>;
    /** Integer. */
    int: () => Validator<number, false>;
    /** Boolean. Same as `v.bool()`. */
    boolean: () => Validator<boolean, false>;
    /**
     * Boolean. Alias for `v.boolean()` so the validator API matches the
     * schema DSL (which uses `field.bool()`). Prefer this in new code.
     */
    bool: () => Validator<boolean, false>;
    /**
     * ISO-8601 datetime string. Validates the shape of a string value; the
     * stored column type comes from the schema (`field.datetime()`).
     */
    datetime: () => Validator<string, false>;
    /**
     * Richtext string. Same runtime validation as `v.string()`; named
     * explicitly so server functions read as the matching schema type.
     */
    richtext: () => Validator<string, false>;
    /** ID reference to another entity. */
    id: (table: string) => Validator<string, false>;
    /** Null value. */
    null: () => Validator<null, false>;
    /** Array of values. */
    array: <TValidator extends AnyValidator>(items: TValidator) => Validator<InferValidator<TValidator>[], false>;
    /** Object with typed fields. */
    object: <TSchema extends ValidatorSchema>(fields: TSchema) => Validator<InferArgs<TSchema>, false>;
    /** Optional value (may be omitted). */
    optional: <TValidator extends AnyValidator>(inner: TValidator) => Validator<InferValidator<TValidator>, true>;
    /** Union of multiple types. */
    union: <TVariants extends AnyValidator[]>(...variants: TVariants) => Validator<InferValidator<TVariants[number]>, false>;
    /** Exact literal value. */
    literal: <const TValue extends string | number | boolean>(value: TValue) => Validator<TValue, false>;
    /** Any valid JSON value. */
    any: () => Validator<any, false>;
    /**
     * Arbitrary JSON value (object, array, or scalar). The validator-side
     * match for `field.json()` — accepts any JSON shape but types the arg
     * as `unknown`, so handlers narrow before use instead of getting `any`.
     */
    json: () => Validator<unknown, false>;
};
export declare function validateArgs(args: unknown, schema: Record<string, Validator>): {
    valid: boolean;
    errors: string[];
};