/**
 * Enhanced Validation Plugin for OpenSpeed
 * Supports multiple validators via Standard Schema (Zod, Valibot, ArkType, Effect, etc.)
 */
import type { Context } from '../context.js';
export interface StandardSchemaV1<Input = unknown, Output = Input> {
    readonly '~standard': {
        readonly version: 1;
        readonly vendor: string;
        readonly validate: (value: unknown) => StandardSchemaV1Result<Output>;
    };
}
export interface StandardSchemaV1Result<Output> {
    readonly value?: Output;
    readonly issues?: ReadonlyArray<StandardSchemaV1Issue>;
}
export interface StandardSchemaV1Issue {
    readonly message: string;
    readonly path?: ReadonlyArray<string | number>;
}
export type Validator<T = any> = StandardSchemaV1<any, T> | {
    parse: (value: unknown) => T;
} | {
    safeParse: (value: unknown) => {
        success: boolean;
        data?: T;
        error?: any;
    };
};
export interface ValidationOptions {
    body?: Validator;
    params?: Validator;
    query?: Validator;
    headers?: Validator;
    response?: Validator;
    onError?: (error: ValidationError, ctx: Context) => void;
}
export interface ValidationError {
    type: 'body' | 'params' | 'query' | 'headers' | 'response';
    issues: Array<{
        message: string;
        path?: Array<string | number>;
    }>;
}
/**
 * Main validation middleware
 */
export declare function validate(options: ValidationOptions): (ctx: Context, next: () => Promise<any>) => Promise<void>;
/**
 * Helper for creating typed route handlers with validation
 */
export declare function createValidatedHandler<TBody = any, TParams = any, TQuery = any>(schema: {
    body?: Validator<TBody>;
    params?: Validator<TParams>;
    query?: Validator<TQuery>;
}, handler: (ctx: Context & {
    body: TBody;
    params: TParams;
    query: TQuery;
}) => any): (((ctx: Context, next: () => Promise<any>) => Promise<void>) | ((ctx: Context) => Promise<any>))[];
/**
 * Example usage:
 *
 * // With Zod
 * import { z } from 'zod';
 * import { validate } from 'openspeed/plugins/validate';
 *
 * app.post('/user', validate({
 *   body: z.object({
 *     name: z.string(),
 *     age: z.number()
 *   })
 * }), (ctx) => {
 *   const { name, age } = ctx.getBody(); // Type-safe!
 *   return ctx.json({ name, age });
 * });
 *
 * // With Valibot
 * import * as v from 'valibot';
 *
 * app.post('/user', validate({
 *   body: v.object({
 *     name: v.string(),
 *     age: v.number()
 *   })
 * }), (ctx) => {
 *   return ctx.json(ctx.getBody());
 * });
 *
 * // With ArkType
 * import { type } from 'arktype';
 *
 * app.post('/user', validate({
 *   body: type({
 *     name: 'string',
 *     age: 'number'
 *   })
 * }), (ctx) => {
 *   return ctx.json(ctx.getBody());
 * });
 */
//# sourceMappingURL=validate.d.ts.map