import "../_dnt.polyfills.js";
import { EventSource, Receipt, Timeline } from "./Timeline.js";
import { Trace } from "./Trace.js";
import * as _ from "./_empty.js";
export declare abstract class Runner {
    abstract order: number;
    abstract timeline: Timeline;
    _currentTrace?: Trace;
    protected abstract _prime<T, U>(rune: Rune<T, U>): Run<T, U>;
    memo: Map<(runner: Runner) => Run<any, any>, _.Run<any, any>>;
    prime<T, U>(rune: Rune<T, U>): Run<T, U>;
    getPrimed<T, U>(rune: Rune<T, U>): Run<T, U> | undefined;
    onCleanup(run: Run<unknown, unknown>): void;
}
declare const _T: unique symbol;
declare const _U: unique symbol;
export declare namespace Rune {
    type T<R> = R extends {
        [_T]: infer T;
    } ? T : R;
    type U<R> = R extends {
        [_U]: infer U;
    } ? U : never;
    export import ValueRune = _.ValueRune;
    export import ArrayRune = _.ArrayRune;
    export import FnRune = _.FnRune;
}
export interface Rune<out T, out U = never> {
    [_T]: T;
    [_U]: U;
}
export declare class Rune<out T, out U = never> {
    readonly _prime: (runner: Runner) => Run<T, U>;
    private _;
    _trace: Trace;
    constructor(_prime: (runner: Runner) => Run<T, U>);
    static new<T, U, A extends unknown[]>(ctor: new (runner: Runner, ...args: A) => Run<T, U>, ...args: A): _.Rune<T, U>;
    run(runner?: Runner): Promise<T>;
    iter(runner?: Runner): AsyncGenerator<Awaited<T>, void, unknown>;
    static constant<T>(value: T): _.ValueRune<T, never>;
    static resolve<V>(value: V): Rune.ValueRune<Rune.T<V>, Rune.U<V>>;
    static str<X>(strings: TemplateStringsArray, ..._values: RunicArgs<X, unknown[]>): _.ValueRune<string, _.RunicArgs.U<X>>;
    static tuple<R extends unknown[]>(runes: [...R]): Rune.ValueRune<{
        [K in keyof R]: Rune.T<R[K]>;
    }, Rune.U<R[number]>>;
    static array<T, X>(runes: RunicArgs<X, T[]>): _.ArrayRune<T, _.RunicArgs.U<X>>;
    static fn<A extends any[], T, X>(...[fn]: RunicArgs<X, [(...args: A) => T]>): _.FnRune<(...args: A) => T, _.RunicArgs.U<X>>;
    static object<R extends {}>(runes: R): Rune.ValueRune<{
        [K in keyof R]: Rune.T<R[K]>;
    }, Rune.U<R[keyof R]>>;
    static captureUnhandled<R extends unknown[], T2, U2>(sources: [...R], fn: (...runes: {
        [K in keyof R]: Rune.ValueRune<Rune.T<R[K]>, never>;
    }) => Rune<T2, U2>): Rune.ValueRune<T2, Rune.U<R[number]> | U2>;
    static asyncIter<T>(fn: () => AsyncIterable<T>): Rune.ValueRune<T, never>;
    static _placeholder(): _.Rune<never, never>;
    into<A extends unknown[], C extends Rune<any, any>>(ctor: new (_prime: (runner: Runner) => Run<T, U | RunicArgs.U<A>>, ...args: A) => C, ...args: A): C;
    as<R>(this: R, _ctor: new (_prime: (runner: Runner) => Run<T, U>, ...args: any) => R): R;
    unsafeAs<T2, U2 = U>(): Rune<T2, U2>;
    pipe<R extends Rune<any, any>>(fn: (rune: this) => R): R;
    static pin<T, U>(rune: Rune<T, U>, pinned: Rune<unknown, unknown>): Rune<T, U>;
}
export declare abstract class Run<T, U> {
    readonly runner: Runner;
    "": [T, U];
    trace: Trace;
    order: number;
    timeline: Timeline;
    constructor(runner: Runner);
    dependencies: Run<unknown, unknown>[];
    use<T, U>(rune: Rune<T, U>): Run<T, U>;
    useRun(run: Run<unknown, unknown>): void;
    referenceCount: number;
    alive: boolean;
    reference(): void;
    _sources: Array<(runner: Runner) => Run<any, any>>;
    dereference(cleanupBatches?: Run<unknown, unknown>[][]): void;
    cleanup(): void;
    _currentTime: number;
    _currentPromise: Promise<T>;
    _currentReceipt: Receipt;
    evaluate(time: number, receipt: Receipt): Promise<T>;
    abstract _evaluate(time: number, receipt: Receipt): Promise<T>;
}
export declare abstract class RunStream<T> extends Run<T, never> {
    initPromise: import("../deps/std/async.js").Deferred<void>;
    valueQueue: [number, T][];
    eventSource: EventSource;
    first: boolean;
    done: boolean;
    curIter: AbortController;
    lastValue: T;
    constructor(runner: Runner);
    _evaluate(time: number, receipt: Receipt): Promise<T>;
    push(value: T): void;
    finish(): void;
}
export declare class Unhandled<U = unknown> {
    readonly value: U;
    readonly trace: Trace;
    private _;
    constructor(value: U, trace: Trace);
}
export type RunicArgs<X, A> = (never extends X ? never : X extends A ? X : never) | {
    [K in keyof A]: A[K] | Rune<A[K], RunicArgs.U<X>>;
};
export declare namespace RunicArgs {
    type U<X> = X extends unknown[] ? Rune.U<X[number]> : Rune.U<X[keyof X]>;
    function resolve<X, A>(args: RunicArgs<X, A>): {
        [K in keyof A]: Rune.ValueRune<A[K], RunicArgs.U<X>>;
    };
}
export {};