import * as Debug from "@starbeam/debug";
import { Stack, DebugFilter, DebugListener, DebugTimeline } from "@starbeam/debug";
import * as interfaces from "@starbeam/interfaces";
import { CompositeInternals, Description, MutableInternals, ReactiveId, Timestamp, Diff } from "@starbeam/interfaces";
import { Frame as IFrame } from "@starbeam/interfaces";
import { UNINITIALIZED, REACTIVE } from "@starbeam/shared";
declare class Context {
    #private;
    readonly component: ComponentContext;
    set app(app: object);
    get app(): object;
    hasApp(): boolean;
    create<Args extends unknown[], Ret>(key: object, constructor: (...args: Args) => Ret, ...args: Args): Ret;
}
declare class ComponentContext {
    #private;
    get current(): object;
    push(component: object): void;
    pop(): void;
    exists(): boolean;
    create<Args extends unknown[], Ret>(constructor: (...args: Args) => Ret, ...args: Args): Ret;
}
declare const CONTEXT: Context;
type Unsubscribe = () => void;
/**
 * Implement this interface if you are building a new abstraction that wants to
 * expose cleanup in an idiomatic way.
 *
 * Note that users could always use `LIFETIME.on.cleanup(object, handler)` and
 * `LIFETIME.link(parent, child)` directly, but {@link CleanupTarget} is a way
 * to add cleanup support to objects consistently and idiomatically.
 */
interface CleanupTarget {
    readonly link: (child: object) => Unsubscribe;
    readonly on: OnCleanup;
}
interface OnCleanup {
    readonly cleanup: (finalizer: () => void) => Unsubscribe;
}
declare class LifetimeAPI {
    #private;
    readonly on: {
        cleanup: (object: object, handler: () => void) => Unsubscribe;
    };
    /**
     * Finalize an object. This will run all of the finalizers registered on the
     * object, then finalize all associated children.
     */
    finalize(object: object): void;
    link(parent: object, child: object, options?: {
        root: object;
    }): Unsubscribe;
    unlink(parent: object, child: object): void;
}
declare const LIFETIME: LifetimeAPI;
type Lifetime = {
    [P in keyof LifetimeAPI]: LifetimeAPI[P];
};
declare const INSPECT: unique symbol;
declare class TimestampImpl implements interfaces.Timestamp {
    #private;
    /**
     * Returns the current `Timestamp` according to @starbeam/shared
     */
    static now(): interfaces.Timestamp;
    /**
     * The earliest timestamp from @starbeam/shared that was visible to this @starbeam/timeline.
     */
    static zero(): interfaces.Timestamp;
    static assert(timestamp: interfaces.Timestamp, what: string): asserts timestamp is TimestampImpl;
    static debug(timestamp: interfaces.Timestamp): {
        at: number;
    };
    [INSPECT]: () => object;
    constructor(timestamp: number);
    gt(other: Timestamp): boolean;
    eq(other: Timestamp): boolean;
    /**
     * Bump the timestamp using `@starbeam/shared`
     */
    next(): Timestamp;
    toString: () => string;
}
declare function zero(): interfaces.Timestamp;
declare function getNow(): interfaces.Timestamp;
type Timestamp$0 = interfaces.Timestamp;
declare const Timestamp: typeof TimestampImpl;
declare function max(...timestamps: interfaces.Timestamp[]): interfaces.Timestamp;
declare class Now {
    #private;
    get now(): interfaces.Timestamp;
    bump(): interfaces.Timestamp;
}
interface ExhaustiveMatcher<T> {
    mutable: (internals: interfaces.MutableInternals) => T;
    composite: (internals: interfaces.CompositeInternals) => T;
    delegate: (internals: interfaces.DelegateInternals) => T;
    static: (internals: interfaces.StaticInternals) => T;
}
interface DefaultMatcher<T> extends Partial<ExhaustiveMatcher<T>> {
    default: (internals: interfaces.ReactiveInternals) => T;
}
type Matcher<T> = ExhaustiveMatcher<T> | DefaultMatcher<T>;
type ReactiveProtocol<I extends interfaces.ReactiveInternals = interfaces.ReactiveInternals> = interfaces.ReactiveProtocol<I>;
declare const ReactiveProtocol: {
    readonly description: (this: void, reactive: ReactiveProtocol) => Debug.Description;
    readonly id: (this: void, reactive: ReactiveProtocol) => interfaces.ReactiveId;
    readonly is: <T extends "delegate" | "static" | "mutable" | "composite">(this: void, reactive: ReactiveProtocol, kind: T) => reactive is {
        [REACTIVE]: Extract<interfaces.MutableInternals, {
            type: T;
        }> | Extract<interfaces.CompositeInternals, {
            type: T;
        }> | Extract<interfaces.DelegateInternals, {
            type: T;
        }> | Extract<interfaces.StaticInternals, {
            type: T;
        }>;
    };
    readonly match: <T_1>(this: void, reactive: ReactiveProtocol, matcher: Matcher<T_1>) => T_1;
    readonly subscribesTo: (this: void, reactive: ReactiveProtocol) => ReactiveProtocol[];
    readonly dependencies: (this: void, reactive: ReactiveProtocol) => Iterable<interfaces.MutableInternals>;
    readonly dependenciesInList: (this: void, children: readonly ReactiveProtocol[]) => Iterable<interfaces.MutableInternals>;
    readonly lastUpdated: (this: void, reactive: ReactiveProtocol) => Timestamp;
    readonly lastUpdatedIn: (this: void, reactives: ReactiveProtocol[]) => Timestamp;
    readonly log: (this: void, reactive: ReactiveProtocol, options?: {
        implementation?: boolean;
        source?: boolean;
        id?: boolean;
    }) => void;
    readonly debug: (this: void, reactive: ReactiveProtocol, { implementation, source }?: {
        implementation?: boolean | undefined;
        source?: boolean | undefined;
    }) => string;
};
declare const ReactiveInternals: {
    is<T extends "delegate" | "static" | "mutable" | "composite">(this: void, internals: interfaces.ReactiveInternals, kind: T): internals is Extract<interfaces.MutableInternals, {
        type: T;
    }> | Extract<interfaces.CompositeInternals, {
        type: T;
    }> | Extract<interfaces.DelegateInternals, {
        type: T;
    }> | Extract<interfaces.StaticInternals, {
        type: T;
    }>;
    id(this: void, internals: interfaces.ReactiveInternals): interfaces.ReactiveId;
    dependencies(internals: interfaces.ReactiveInternals): Iterable<interfaces.MutableInternals>;
    dependenciesInList(this: void, children: readonly ReactiveInternals[]): Iterable<interfaces.MutableInternals>;
    subscribesTo(this: void, internals: interfaces.ReactiveInternals): interfaces.ReactiveInternals[];
    lastUpdated(this: void, internals: ReactiveInternals): Timestamp;
    lastUpdatedIn(this: void, internals: ReactiveInternals[]): Timestamp;
    description(this: void, internals: ReactiveInternals): Debug.Description;
    debug(this: void, internals: interfaces.ReactiveInternals, { implementation, source, id }?: {
        implementation?: boolean | undefined;
        source?: boolean | undefined;
        id?: boolean | undefined;
    }): string;
    log(this: void, internals: interfaces.ReactiveInternals, options?: {
        implementation?: boolean;
        source?: boolean;
        id?: boolean;
    }): void;
    match<T_1>(this: void, internals: ReactiveInternals, matcher: Matcher<T_1>): T_1;
};
type ReactiveInternals = interfaces.ReactiveInternals;
type Reactive<T, I extends ReactiveInternals = ReactiveInternals> = interfaces.Reactive<T, I>;
declare const Reactive: {
    is<T>(this: void, value: unknown): value is interfaces.Reactive<T, interfaces.ReactiveInternals>;
    from<T_1>(this: void, value: T_1 | Reactive<T_1, interfaces.ReactiveInternals>, description?: string | Debug.Description): Reactive<T_1, interfaces.ReactiveInternals>;
};
type ReactiveCore<T, I extends ReactiveInternals = ReactiveInternals> = interfaces.ReactiveCore<T, I>;
declare const ReactiveCore: {
    is<T>(value: unknown): value is interfaces.ReactiveCore<T, interfaces.ReactiveInternals>;
};
declare class Frame<T = unknown> implements ReactiveProtocol<CompositeInternals>, IFrame {
    #private;
    static create<T>(this: void, value: T, children: Set<ReactiveProtocol>, finalized: Timestamp, description: Description): Frame<T>;
    static uninitialized<T>(finalized: Timestamp, description: Description): Frame<T | UNINITIALIZED>;
    static value<T>(this: void, frame: Frame<T>): T;
    static isInitialized(this: void, frame: Frame): boolean;
    static update<T>(this: void, frame: Frame<T>, value: T, children: Set<ReactiveProtocol>, finalized: Timestamp): Frame<T>;
    static updateChildren<T>(this: void, frame: Frame<T>, children: Set<ReactiveProtocol>): void;
    constructor(id: ReactiveId, value: T, initialized: {
        [REACTIVE]: Omit<MutableInternals, "lastUpdated"> & {
            lastUpdated: Timestamp;
        };
    }, children: Set<ReactiveProtocol>, finalized: Timestamp, description: Description);
    get [REACTIVE](): CompositeInternals;
    get description(): Description;
    validate(): FrameValidation<Exclude<T, UNINITIALIZED>>;
}
declare class ActiveFrame<T> {
    #private;
    readonly description: Description;
    static create<T>(updating: Frame<T> | null, prev: ActiveFrame<T> | null, description: Description): ActiveFrame<T>;
    private constructor();
    add(child: ReactiveProtocol): void;
    finally(): {
        prev: ActiveFrame<unknown> | null;
    };
    finalize(value: T, timeline: Timeline): {
        prev: ActiveFrame<unknown> | null;
        frame: Frame<T>;
    };
}
interface ValidFrame<T> {
    readonly status: "valid";
    readonly value: T;
}
interface InvalidFrame {
    readonly status: "invalid";
}
type FrameValidation<T> = ValidFrame<T> | InvalidFrame;
declare class Subscription {
    #private;
    constructor(dependencies: Set<MutableInternals>, lastNotified: undefined | Timestamp, ready: (internals: MutableInternals) => void);
    update(dependencies: Set<MutableInternals>): void;
    get dependencies(): Set<MutableInternals>;
    get lastNotified(): Timestamp | undefined;
    notify(timestamp: Timestamp, internals: MutableInternals): void;
}
declare class Subscriptions {
    #private;
    static create(): Subscriptions;
    private constructor();
    notify(dependency: MutableInternals): void;
    register(reactive: ReactiveProtocol, ready: (internals: MutableInternals) => void): Unsubscribe;
    update(reactive: ReactiveProtocol): void;
}
declare class FrameStack {
    #private;
    static didConsumeCell(frames: FrameStack, reactive: ReactiveProtocol<interfaces.MutableInternals>, caller: Stack): void;
    static didConsumeFrame(frames: FrameStack, frame: interfaces.Frame, diff: interfaces.Diff<interfaces.MutableInternals>, caller: Stack): void;
    static empty(timeline: Timeline, subscriptions: Subscriptions): FrameStack;
    constructor(subscriptions: Subscriptions, current: ActiveFrame<unknown> | null, timeline: Timeline);
    get currentFrame(): ActiveFrame<unknown> | null;
    create<T>(options: {
        evaluate: () => T;
        description: interfaces.Description;
    }): Frame<T>;
    // FIXME Overloads shouldn't trigger member-ordering
    create<T>(options: {
        description: interfaces.Description;
    }): ActiveFrame<T>;
    finally<T>(prev: ActiveFrame<T> | null): void;
    update<T>(options: {
        updating: Frame<T | UNINITIALIZED>;
        evaluate: () => T;
    }): Frame<T>;
    // FIXME Overloads shouldn't trigger member-ordering
    update<T>({ updating }: {
        updating: Frame<T | UNINITIALIZED>;
    }): ActiveFrame<T>;
}
/**
 * # How Subscriptions Work at the Lowest Level
 *
 * You subscribe to an object implementing ReactiveProtocol by using `Timeline#on.change`.
 *
 * ## Composites
 *
 * If the object represents a composite, the {@linkcode Timeline} will immediately subscribe to the
 * dependencies of the composite.
 *
 * Whenever any of those dependencies change, the timeline will notify the subscriber. Whenever a
 * reactive object's composite dependencies may have changed (i.e. when it was polled), the object
 * is responsible for calling `TIMELINE.update(object)` to notify the timeline. This updates the
 * internal dependencies of that object used for notifications.
 *
 * ## Delegates
 *
 * If an object implementing {@linkcode ReactiveProtocol} simply polls another reactive object, it
 * can use a {@linkcode DelegateInternals} property to point to that object. In this case, the
 * object doesn't need to worry about `TIMELINE.update`.
 *
 * ## Notifications
 *
 * Whenever a {@linkcode MutableInternals} is updated, the timeline will notify all subscribers of
 * reactives that depend on that dependency.
 */
declare class Timeline {
    #private;
    attach: (notify: () => void, options?: {
        filter: DebugFilter;
    }) => DebugListener;
    on: {
        readonly rendered: (callback: () => void) => (() => void);
        readonly change: (input: ReactiveProtocol, ready: (internals: interfaces.MutableInternals) => void) => Unsubscribe;
    };
    /**
     * In debug mode, register a barrier for untracked reads. This allows you to throw an error if an
     * untracked read occurred in a context (such as a render function) that a renderer knows will
     * produce rendered content.
     */
    untrackedReadBarrier: (assertion: (reactive: ReactiveProtocol, caller: Stack) => void) => void;
    static create(): Timeline;
    private constructor();
    get frame(): FrameStack;
    get log(): DebugTimeline;
    // Returns the current timestamp
    get now(): interfaces.Timestamp;
    bump(mutable: interfaces.MutableInternals, caller: Stack): interfaces.Timestamp;
    didConsumeCell(cell: ReactiveProtocol<interfaces.MutableInternals>, caller: Stack): void;
    didConsumeFrame(frame: interfaces.Frame, diff: interfaces.Diff<interfaces.MutableInternals>, caller: Stack): void;
    next(): interfaces.Timestamp;
    /**
     * When a reactive's dependencies might have changed, any renderables that depend on this reactive
     * need to refresh their dependencies. If there are no renderers for this reactive value,
     * {@linkcode update} does nothing.
     *
     * Otherwise, each relevant renderable will unsubscribe from any stale dependencies and subscribe
     * to any new dependencies.
     *
     * For example, Formulas call this method after recomputing their value, which results in a
     * possible change to their dependencies.
     */
    update(reactive: ReactiveProtocol): void;
    willEvaluate(): void;
    mutation<T>(description: string, callback: () => T): T;
    /// DEBUG MODE ///
    /** @internal */
    untrackedRead(cell: ReactiveProtocol, caller: Stack): void;
}
declare const TIMELINE: Timeline;
declare function diff<T>(prev: Set<T> | ReadonlySet<T>, next: Set<T> | ReadonlySet<T>): Diff<T>;
declare namespace diff {
    var empty: <T>() => Diff<T>;
}
declare namespace timestamp {
    const INSPECT: unique symbol;
    class TimestampImpl implements interfaces.Timestamp {
        #private;
        /**
         * Returns the current `Timestamp` according to @starbeam/shared
         */
        static now(): interfaces.Timestamp;
        /**
         * The earliest timestamp from @starbeam/shared that was visible to this @starbeam/timeline.
         */
        static zero(): interfaces.Timestamp;
        static assert(timestamp: interfaces.Timestamp, what: string): asserts timestamp is TimestampImpl;
        static debug(timestamp: interfaces.Timestamp): {
            at: number;
        };
        [INSPECT]: () => object;
        constructor(timestamp: number);
        gt(other: Timestamp): boolean;
        eq(other: Timestamp): boolean;
        /**
         * Bump the timestamp using `@starbeam/shared`
         */
        next(): Timestamp;
        toString: () => string;
    }
    function zero(): interfaces.Timestamp;
    function getNow(): interfaces.Timestamp;
    type Timestamp = interfaces.Timestamp;
    const Timestamp: typeof TimestampImpl;
    function max(...timestamps: interfaces.Timestamp[]): interfaces.Timestamp;
    class Now {
        #private;
        get now(): interfaces.Timestamp;
        bump(): interfaces.Timestamp;
    }
    const NOW: Now;
}
declare const Timestamp$0: typeof timestamp.TimestampImpl;
type Timestamp = interfaces.Timestamp;
export { ComponentContext, Context, CONTEXT, CleanupTarget, Lifetime, OnCleanup, LIFETIME, TIMELINE, FrameValidation, ActiveFrame, Frame, Reactive, ReactiveCore, ReactiveInternals, ReactiveProtocol, Subscription, Subscriptions, INSPECT, max, getNow as now, zero, diff, Timestamp$0 as Timestamp };
export type { Unsubscribe };
export { REACTIVE } from "@starbeam/shared";
//# sourceMappingURL=index.d.ts.map