import "../_dnt.polyfills.js";
import { Guard, SmartExclude } from "./is.js";
import { Run, Rune, RunicArgs, Runner } from "./Rune.js";
/** @ts-ignore: assume it's a valid key */
type GetPath<T, P> = P extends [infer K, ...infer Q] ? GetPath<T[K], Q> : T;
type EnsurePath<T, P> = never extends P ? P extends [infer K, ...infer Q] ? [K & keyof T, ...EnsurePath<T[K & keyof T], Q>] | [keyof T, ...PropertyKey[]] : [(keyof T)?] : P;
export declare class ValueRune<out T, out U = never> extends Rune<T, U> {
    static new<T, U, A extends unknown[]>(ctor: new (runner: Runner, ...args: A) => Run<T, U>, ...args: A): Rune.ValueRune<T, U>;
    map<T2>(fn: (value: T) => T2 | Promise<T2>): ValueRune<T2, U>;
    access<P extends (string & {} | "" | number & {} | 0 | symbol)[], T, U, X>(this: ValueRune<T, U>, ...keys: never extends P ? RunicArgs<X, [...EnsurePath<T, P>]> : {
        [K in keyof P]: P[K] | Rune<P[K], any>;
    }): ValueRune<GetPath<T, {
        [K in keyof X]: Rune.T<X[K]>;
    }>, U | RunicArgs.U<X>>;
    handle<T2 extends T, T3, U2>(guard: Guard<T, T2>, alt: (rune: ValueRune<T2, never>) => Rune<T3, U2>): ValueRune<Exclude<T, T2> | T3, U | U2>;
    unhandle<U2 extends T>(fn: Guard<T, U2>): ValueRune<SmartExclude<T, U2>, U | U2>;
    throws<U2 extends unknown[]>(...guards: {
        [K in keyof U2]: Guard<unknown, U2[K]>;
    }): ValueRune<T, U | U2[number]>;
    rehandle<U2 extends U>(guard: Guard<U, U2>): ValueRune<T | U2, Exclude<U, U2>>;
    rehandle<U2 extends U, T3, U3>(guard: Guard<U, U2>, alt: (rune: ValueRune<U2, never>) => Rune<T3, U3>): ValueRune<T | T3, Exclude<U, U2> | U3>;
    lazy(): Rune.ValueRune<T, U>;
    filter(fn: (value: T) => boolean): ValueRune<T, U>;
    filter<T2 extends T>(fn: (value: T) => value is T2): ValueRune<T2, U>;
    final(): Rune.ValueRune<T, U>;
    reduce<T2>(init: T2, fn: (last: T2, value: T) => T2 | Promise<T2>): ValueRune<T2, U>;
    collect(): Rune.ValueRune<T[], U>;
    dbg<X>(...prefix: RunicArgs<X, unknown[]>): Rune.ValueRune<Rune.T<this>, Rune.U<this>>;
    chain<T2, U2>(fn: (result: ValueRune<T, never>) => Rune<T2, U2>): ValueRune<T2, U | U2>;
    match<T, U, T2, U2>(this: ValueRune<T, U>, fn: (match: Match<T, never, never>) => ExhaustiveMatch<T2, U2>): ValueRune<T2, U | U2>;
}
type ExhaustiveMatch<T, U> = Match<never, T, U>;
declare class Match<M, T, U> {
    readonly value: ValueRune<M, never>;
    conditions: [(x: M) => boolean, ValueRune<T, U>][];
    constructor(value: ValueRune<M, never>);
    when<M2 extends M, T2, U2>(guard: Guard<M, M2>, fn: (value: ValueRune<M2, never>) => ValueRune<T2, U2>): Match<Exclude<M, M2>, T | T2, U | U2>;
    else<T2, U2>(fn: (value: ValueRune<M, never>) => ValueRune<T2, U2>): ExhaustiveMatch<T | T2, U | U2>;
}
export {};