import type { Pred } from 'runtyp';
import type { RouteErrorDef, RouteErrorSpec, RouteFailure } from './types';
import { builtInErrors, type ThrowableBuiltinCode } from './builtinErrors';
export type { RouteErrorSpec } from './types';
type FailFn<Spec extends RouteErrorSpec, Code extends string> = Spec['data'] extends Pred<infer D> ? undefined extends D ? (data?: Exclude<D, undefined>) => RouteFailure & {
    code: Code;
} : (data: D) => RouteFailure & {
    code: Code;
} : () => RouteFailure & {
    code: Code;
};
type BuiltinFailers = {
    [K in ThrowableBuiltinCode]: FailFn<(typeof builtInErrors)[K], K>;
};
/** Internal marker — domain defs only (builtin failers are implicit). */
declare const ERROR_DEFS: unique symbol;
/** Pass the whole handle to `route({ errors: e })` — domain codes only. */
type ErrorsHandle = {
    [ERROR_DEFS]: Readonly<Record<string, RouteErrorDef>>;
};
export type ErrorsHandleWithFailers<T extends Record<string, RouteErrorSpec>> = ErrorsHandle & BuiltinFailers & {
    [K in keyof T & string]: FailFn<T[K], K>;
};
export type DefineErrorsInput = Record<string, RouteErrorDef> | ErrorsHandle;
type FailersFromHandle<H> = Extract<{
    [K in keyof H]: H[K] extends (...args: any[]) => infer R ? R : never;
}[keyof H], RouteFailure>;
type DomainFailuresFromDefs<E extends Record<string, RouteErrorDef>> = Extract<{
    [K in keyof E & string]: RouteFailure & {
        code: K;
    };
}[keyof E & string], RouteFailure>;
/** Union of RouteFailure values from an errors handle (builtins + domain failers). */
export type RouteFailuresFrom<E> = FailersFromHandle<E>;
/** Declare domain route errors; builtin failers are always on the returned handle. */
export declare function defineErrors<const T extends Record<string, RouteErrorSpec>>(spec?: T): ErrorsHandleWithFailers<T>;
/** Builtin-only fail handle — use in handlers when a route has no domain errors. */
export declare const err: ErrorsHandleWithFailers<{}>;
/** Failures from {@link err} — builtins only (every route allows these). */
export type BuiltinRouteFailures = FailersFromHandle<typeof err>;
/** Failures allowed on a route from its `errors:` param (builtins when omitted). */
export type RouteFailuresFor<E> = [
    E
] extends [undefined] ? BuiltinRouteFailures : E extends ErrorsHandle ? FailersFromHandle<E> : E extends Record<string, RouteErrorDef> ? BuiltinRouteFailures | DomainFailuresFromDefs<E> : BuiltinRouteFailures;
export declare function resolveRouteErrorDefs(errors?: DefineErrorsInput): Record<string, RouteErrorDef> | undefined;