import { AnyElysia } from 'elysia';

type IsAny<T> = 0 extends 1 & T ? true : false;
type IsNever<T> = [T] extends [never] ? true : false;
type IsUnknown<T> = IsAny<T> extends true ? false : unknown extends T ? true : false;
type Not<T> = T extends true ? false : true;
type And<A extends boolean, B extends boolean> = A extends true ? B extends true ? true : false : false;
type ReplaceGeneratorWithAsyncGenerator<T extends Record<string, unknown>> = {
    [K in keyof T]: T[K] extends Generator<infer A, infer B, infer C> ? And<Not<IsNever<A>>, void extends B ? true : false> extends true ? AsyncGenerator<A, B, C> : And<IsNever<A>, void extends B ? false : true> extends true ? B : AsyncGenerator<A, B, C> | B : T[K] extends AsyncGenerator<infer A, infer B, infer C> ? And<Not<IsNever<A>>, void extends B ? true : false> extends true ? AsyncGenerator<A, B, C> : And<IsNever<A>, void extends B ? false : true> extends true ? B : AsyncGenerator<A, B, C> | B : T[K];
} & {};
type NonEmptyArray<T> = [T, ...T[]];
type Enumerate<N extends number, Acc extends number[] = []> = Acc['length'] extends N ? Acc[number] : Enumerate<N, [...Acc, Acc['length']]>;
type Range<F extends number, T extends number> = Exclude<Enumerate<T>, Enumerate<F>>;

declare class EdenFetchError<Status extends number = number, Value = unknown> extends Error {
    status: Status;
    value: Value;
    constructor(status: Status, value: Value);
}
declare class EdenFatalError extends Error {
    static throw(): EdenFatalError;
    constructor();
}
type MapError<T extends Record<number, unknown>> = [
    {
        [K in keyof T]-?: K extends ErrorRange ? K : never;
    }[keyof T]
] extends [infer A extends number] ? {
    [K in A]: EdenFetchError<K, T[K]>;
}[A] : false;
type ErrorRange = Range<300, 599>;
/**
 * Type representing any error-like object that can be thrown by Eden client operations.
 * This includes EdenFetchError instances with any status code and value.
 *
 * @template _T - The Elysia app type (reserved for future use with route-specific error types)
 */
type EdenClientErrorLike<_T extends AnyElysia = AnyElysia> = EdenFetchError<number, unknown> | Error;
declare const ERROR_SYMBOL: unique symbol;
type TypeError<TMessage extends string> = TMessage & {
    _: typeof ERROR_SYMBOL;
};

export { EdenFetchError as E, type IsNever as I, type MapError as M, type NonEmptyArray as N, type ReplaceGeneratorWithAsyncGenerator as R, type TypeError as T, EdenFatalError as a, type ErrorRange as b, type EdenClientErrorLike as c, ERROR_SYMBOL as d, type IsUnknown as e };