import { StandardSchemaV1 } from '@standard-schema/spec';
import { JsonSchema } from './utils/types.js';

type PipeFn<I, O> = (input: I) => O | PipeError;
type PipeCompiledFn<T extends Pipe<any, any>> = (input: unknown) => PipeOutput<T> | PipeError;
type PipeErrorHandlerType = 'return' | 'throw' | 'assign';
type PipeErrorHandler = ((errorCondition: string, error: string) => (lines: string[]) => string[]) & {
    type: PipeErrorHandlerType;
    format: (error: string) => string;
};
type PipeInput<T> = T extends Pipe<infer I, any> ? I : never;
type PipeOutput<T> = T extends Pipe<any, infer O> ? O : never;
type PipeMeta = Pick<JsonSchema, '$refId' | 'title' | 'description' | 'examples' | 'default'>;
type Context = Record<string, any>;
type JsonSchemaBuilder = JsonSchema;
type Entry<I, O> = Pipe<I, O> | PipeFn<I, O>;
type PipeChain<I, O> = {
    <T1>(fn1: Entry<O, T1>): Pipe<I, T1>;
    <T1, T2>(fn1: Entry<O, T1>, fn2: Entry<T1, T2>): Pipe<I, T2>;
    <T1, T2, T3>(fn1: Entry<O, T1>, fn2: Entry<T1, T2>, f3: Entry<T2, T3>): Pipe<I, T3>;
    <T1, T2, T3, T4>(fn1: Entry<O, T1>, fn2: Entry<T1, T2>, f3: Entry<T2, T3>, f4: Entry<T3, T4>): Pipe<I, T4>;
    <T1, T2, T3, T4, T5>(fn1: Entry<O, T1>, fn2: Entry<T1, T2>, f3: Entry<T2, T3>, f4: Entry<T3, T4>, f5: Entry<T4, T5>): Pipe<I, T5>;
    <T1, T2, T3, T4, T5, T6>(fn1: Entry<O, T1>, fn2: Entry<T1, T2>, f3: Entry<T2, T3>, f4: Entry<T3, T4>, f5: Entry<T4, T5>, f6: Entry<T5, T6>): Pipe<I, T6>;
    <T1, T2, T3, T4, T5, T6, T7>(fn1: Entry<O, T1>, fn2: Entry<T1, T2>, f3: Entry<T2, T3>, f4: Entry<T3, T4>, f5: Entry<T4, T5>, f6: Entry<T5, T6>, f7: Entry<T6, T7>): Pipe<I, T7>;
    <T1, T2, T3, T4, T5, T6, T7, T8>(fn1: Entry<O, T1>, fn2: Entry<T1, T2>, f3: Entry<T2, T3>, f4: Entry<T3, T4>, f5: Entry<T4, T5>, f6: Entry<T5, T6>, f7: Entry<T6, T7>, f8: Entry<T7, T8>): Pipe<I, T8>;
    <T1, T2, T3, T4, T5, T6, T7, T8, T9>(fn1: Entry<O, T1>, fn2: Entry<T1, T2>, f3: Entry<T2, T3>, f4: Entry<T3, T4>, f5: Entry<T4, T5>, f6: Entry<T5, T6>, f7: Entry<T6, T7>, f8: Entry<T7, T8>, f9: Entry<T8, T9>): Pipe<I, T9>;
    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(fn1: Entry<O, T1>, fn2: Entry<T1, T2>, f3: Entry<T2, T3>, f4: Entry<T3, T4>, f5: Entry<T4, T5>, f6: Entry<T5, T6>, f7: Entry<T6, T7>, f8: Entry<T7, T8>, f9: Entry<T8, T9>, f10: Entry<T9, T10>): Pipe<I, T10>;
};
type Arrayable<T> = T | T[];
interface Pipe<I, O> extends StandardSchemaV1<I, O> {
    readonly context: () => Context;
    readonly schema: (context: Context) => JsonSchema;
    readonly pipe: PipeChain<I, O>;
    readonly compile: (names: {
        input: string;
        context: string;
        path: string;
    }, opts: {
        rootContext: Context;
        failEarly: boolean;
        path: string;
        wrapError: PipeErrorHandler;
    }) => Arrayable<string | ReturnType<PipeErrorHandler>>;
    prev?: Pipe<any, any>;
    __compiled?: PipeCompiledFn<any>;
}

type PipeErrorMessage = {
    message: string;
    path?: string;
    value: unknown;
};
declare class PipeError {
    messages: PipeErrorMessage[];
    constructor(messages: PipeErrorMessage[]);
    toString(): string;
    static root(message: string, value: unknown, path?: string): PipeError;
    static rootFrom(errors: PipeError[]): PipeError;
    static path(path: PropertyKey, key: string, error: PipeError): PipeError;
    static wrap(path: PropertyKey, error: PipeError): PipeError;
}
declare function createErrorHandler(input: string, type: 'return' | 'throw' | 'assign'): PipeErrorHandler;

export { type Context as C, type Entry as E, type JsonSchemaBuilder as J, PipeError as P, type PipeFn as a, type PipeCompiledFn as b, createErrorHandler as c, type PipeErrorHandlerType as d, type PipeErrorHandler as e, type PipeInput as f, type PipeOutput as g, type PipeMeta as h, type Pipe as i };