@expressive/mvc 1.0.0-beta.9 → 1.0.0

package/lib/index.d.ts

@@ -0,0 +1,594 @@
+import React from 'react';
+
+type Callback = () => void;
+type Class = new (...args: any[]) => any;
+type InstanceOf<T> = T extends { prototype: infer U } ? U : never;
+
+/** Type may not be undefined - instead will be null.  */
+type NoVoid<T> = T extends undefined ? null : T;
+
+declare type Listener = {
+    commit(): void;
+    release(): void;
+};
+declare namespace Subscriber {
+    type OnEvent<T = any> = (key: Model.Event<T> | null, source: Control) => Callback | void;
+}
+declare class Subscriber<T extends {} = any> {
+    parent: Control<T>;
+    onUpdate: Subscriber.OnEvent;
+    proxy: T;
+    release: Callback;
+    latest?: Model.Event<T>[];
+    active: boolean;
+    dependant: Set<Listener>;
+    watch: Map<any, boolean | (() => true | void)>;
+    constructor(parent: Control<T>, onUpdate: Subscriber.OnEvent);
+    get using(): Model.Key<T>[];
+    add(key: any, value?: boolean | Callback): void;
+    commit(): () => void;
+    private onEvent;
+}
+
+declare const LOCAL = "$debug local";
+declare const STATE = "$debug state";
+declare const UPDATE = "$debug update";
+declare const CONTROL = "$debug controller";
+declare const Debug: {
+    readonly CONTROL: "$debug controller";
+    readonly LOCAL: "$debug local";
+    readonly STATE: "$debug state";
+    readonly UPDATE: "$debug update";
+};
+declare type Debug<T extends {}> = T & {
+    /** Controller for this instance. */
+    [CONTROL]?: Control<T>;
+    /** Current subscriber (if present) while used in a live context (e.g. hook or effect). */
+    [LOCAL]?: Subscriber<T>;
+    /** Current state of this instance. */
+    [STATE]?: Model.Export<T>;
+    /**
+     * Last update causing a refresh to subscribers.
+     *
+     * If accessed directly, will contain all keys from last push.
+     * If within a subscribed function, will contain only keys which explicitly caused a refresh.
+     */
+    [UPDATE]?: readonly Model.Event<T>[];
+};
+
+declare namespace Model {
+    export { Control };
+    export { Subscriber };
+    /** Including but not limited to T. */
+    type Extends<T> = T | (string & Record<never, never>);
+    export type Type<T extends Model = Model> = typeof Model & (new () => T);
+    export type Effect<T> = (this: T, argument: T) => Callback | Promise<any> | void;
+    /** Exotic value, actual value is contained. */
+    export type Ref<T = any> = {
+        (next: T): void;
+        current: T | null;
+    };
+    /** Properties of T which are methods. */
+    export type Methods<T> = {
+        [K in keyof T]: T[K] extends Ref ? never : T[K] extends Function ? K : never;
+    }[keyof T];
+    type BuiltIn = keyof Model | keyof Debug<{}>;
+    /**
+     * Subset of `keyof T` which are not methods or defined by base Model U.
+     *
+     * **Note**: This excludes all keys which are not of type `string` (only those are managed).
+     *
+     * TODO: Should exclude methods
+     **/
+    export type Key<T> = Exclude<keyof T, BuiltIn> & string;
+    /**
+     * Including but not limited to `keyof T` which are not methods or defined by base Model.
+     **/
+    export type Event<T> = Extends<Key<T>>;
+    /** Object containing managed entries found in T. */
+    export type Entries<T> = {
+        [K in Key<T>]: T[K];
+    };
+    /** Object comperable to data found in T. */
+    export type Compat<T> = {
+        [K in Key<T>]?: T[K];
+    };
+    /** Actual value stored in state. */
+    export type Value<R> = R extends Ref<infer T> ? T : R;
+    /** Actual value belonging to a managed property. */
+    export type ValueOf<T extends {}, K> = K extends keyof T ? Value<T[K]> : undefined;
+    /**
+     * Values from current state of given controller.
+     *
+     * Differs from `Entries` as values here will drill into "real" values held by exotics like ref.
+     */
+    export type Get<T, K extends Key<T> = Key<T>> = {
+        [P in K]: Value<T[P]>;
+    };
+    export type Export<T, E extends Model = Model> = {
+        [P in Key<T>]: Value<T[P]>;
+    };
+}
+declare class Model {
+    /**
+     * Circular reference to `this` controller.
+     *
+     * Useful to obtain full reference where one has already destructured.
+     */
+    is: this;
+    constructor();
+    on<P extends Model.Event<this>>(keys?: P | Iterable<P>, timeout?: number): Promise<P[]>;
+    on<P extends Model.Event<this>>(keys: P | Iterable<P>, listener: (this: this, keys: Model.Event<this>[]) => void, once?: boolean): Callback;
+    on(effect: Model.Effect<this>): Callback;
+    on(effect: Model.Effect<this>, watch?: []): Callback;
+    on(effect: Model.Effect<this>, watch?: Model.Event<this>[]): Callback;
+    on(key?: undefined, timeout?: number): Promise<Model.Event<this>[]>;
+    on(current?: boolean): Promise<Model.Event<this>[] | null>;
+    on(current: true): Promise<Model.Event<this>[]>;
+    on(current: null): Promise<null>;
+    get(): Model.Export<this>;
+    get<P extends Model.Key<this>>(property: P): this[P];
+    get<P extends Model.Key<this>>(property: P, timeout: number): Promise<this[P]>;
+    get<P extends Model.Key<this>>(property: P, onChange: true): Promise<this[P]>;
+    get<P extends Model.Key<this>>(property: P, onChange: boolean): this[P] | Promise<this[P]>;
+    get<P extends Model.Key<this>>(property: P, listener: (this: this, value: this[P], key: P[]) => void): Callback;
+    get<P extends Model.Key<this>>(select: Iterable<P>): Model.Get<this, P>;
+    get<P extends Model.Key<this>>(select: Iterable<P>, timeout: number): Promise<Model.Get<this, P>>;
+    get<P extends Model.Key<this>>(select: Iterable<P>, onChange: true): Promise<Model.Get<this, P>>;
+    get<P extends Model.Key<this>>(select: Iterable<P>, onChange: boolean): Model.Get<this, P> | Promise<Model.Get<this, P>>;
+    get<P extends Model.Key<this>>(select: Iterable<P>, listener: (this: this, value: Model.Get<this, P>, key: P[]) => void): Callback;
+    set(key: Model.Event<this>): PromiseLike<readonly Model.Event<this>[]>;
+    set<K extends Model.Event<this>>(key: Model.Event<this>, value: Model.ValueOf<this, K>): PromiseLike<readonly Model.Event<this>[]>;
+    set<T extends Model.Compat<this>>(source: T, select: (keyof T)[]): PromiseLike<(keyof T)[]>;
+    set<T extends Model.Compat<this>>(source: T, force?: boolean): PromiseLike<(keyof T)[]>;
+    /**
+     * Clean up side effects and mark this instance for garbage-collection.
+     */
+    end(): void;
+    /**
+     * Creates a new instance of this controller.
+     *
+     * Beyond `new this(...)`, method will activate managed-state.
+     *
+     * @param args - arguments sent to constructor
+     */
+    static new<T extends Class>(this: T, ...args: ConstructorParameters<T>): InstanceOf<T>;
+    /**
+     * Static equivalent of `x instanceof this`.
+     *
+     * Will determine if provided class is a subtype of this one.
+     */
+    static isTypeof<T extends Model.Type>(this: T, maybe: any): maybe is T;
+}
+
+declare namespace Control {
+    /**
+     * Called immediately when any key is changed or emitted.
+     * Returned callback is notified when update is complete.
+     */
+    type OnSync<T = any> = (key: Model.Event<T> | null, source: Control) => OnAsync<T> | void;
+    /** Called at the end of an event frame with all keys affected. */
+    type OnAsync<T = any> = (keys: Model.Event<T>[]) => void;
+    type OnValue<T = any> = (this: T, value: any) => boolean | void;
+}
+declare class Control<T extends {} = any> {
+    subject: T;
+    state: Map<any, any>;
+    frame: Set<string>;
+    waiting: Set<Model.Control.OnAsync<T>>;
+    followers: Set<Model.Control.OnSync<any>>;
+    latest?: Model.Event<T>[];
+    constructor(subject: T);
+    subscribe(callback: Subscriber.OnEvent<T>): Model.Subscriber<T>;
+    watch(key: keyof T & string): void;
+    addListener(listener: Control.OnSync<T>): () => void;
+    ref<K extends Model.Key<T>>(key: K, handler?: (this: T, value: T[K]) => boolean | void): (value: any) => void;
+    update(key: Model.Key<T>): void;
+    clear(): void;
+}
+
+/**
+ * Property initializer, will run upon instance creation.
+ * Optional returned callback will run when once upon first access.
+ */
+declare type Instruction<T> = (this: Control, key: string, thisArg: Control) => Instruction.Getter<T> | Instruction.ExplicitDescriptor | Instruction.Descriptor<T> | Instruction.RecursiveDescriptor<T> | boolean | void;
+declare namespace Instruction {
+    type Getter<T> = (within?: Subscriber) => T;
+    type Setter<T> = (value: T) => boolean | void;
+    type Runner<T> = (this: Control, key: string, on: Control) => Instruction.Descriptor<T> | boolean | undefined;
+    interface Descriptor<T> {
+        configurable?: boolean;
+        enumerable?: boolean;
+        value?: T;
+        writable?: boolean;
+        get?: Getter<T>;
+        set?: Setter<T> | false;
+        suspend?: boolean;
+        destroy?: () => void;
+    }
+    interface ExplicitDescriptor extends PropertyDescriptor {
+        explicit: true;
+    }
+    interface RecursiveDescriptor<T> {
+        recursive: true;
+        enumerable?: boolean;
+        value?: T;
+        set?: Setter<T> | false;
+        suspend?: boolean;
+    }
+}
+/**
+ * Run instruction as controller sets itself up.
+ * This will specialize the behavior of a given property.
+ */
+declare function add<T = any>(instruction: Instruction<any>, label?: string): T;
+
+declare type Async<T = any> = (...args: any[]) => Promise<T>;
+/**
+ * Sets an exotic method with managed ready-state. Property accepts an async function.
+ *
+ * When a run-method is invoked, its `active` property to true for duration of call.
+ * This is emitted as an update to property, both when called and after returns (or throws).
+ *
+ * **Note:** Subsequent calls will immediately throw if one is still pending.
+ *
+ * @param action - Action to fire when resulting property is invoked.
+ */
+declare function run(action: Async): typeof action & {
+    active: boolean;
+};
+declare function run<S>(action: Async<S>): typeof action & {
+    active: boolean;
+};
+
+declare namespace get {
+    type Function<T, S = any> = (this: S, on: S) => T;
+    type Factory<T, S = unknown> = (this: S, key: string, thisArg: S) => T;
+}
+/**
+ * Implement a computed value; output will be generated by provided function.
+ *
+ * @param source - Source model from which computed value will be a subscriber.
+ * @param compute - Compute function. Bound to a subscriber-proxy of source, returns output value. Will update automatically as input values change.
+ * @param suspend - Value will throw suspense when evaulating to undefined.
+ */
+declare function get<R, T>(source: T, compute: (this: T, on: T) => R, suspend: true): Exclude<R, undefined>;
+declare function get<R, T>(source: T, compute: (this: T, on: T) => R, suspend?: boolean): R;
+/**
+ * Implement a computed value; output is returned by function from provided factory.
+ *
+ * @param compute - Factory function to generate a getter to subscribe dependancies.
+ * @param suspend - Value will throw suspense when evaulating to undefined.
+ */
+declare function get<R, T>(compute: (property: string, on: T) => (this: T, state: T) => R, suspend: true): Exclude<R, undefined>;
+declare function get<R, T>(compute: (property: string, on: T) => (this: T, state: T) => R, suspend?: boolean): R;
+/**
+ * Set property with an async function.
+ *
+ * Property cannot be accessed until factory resolves, yeilding a result.
+ * If accessed while processing, React Suspense will be thrown.
+ *
+ * - `required: true` (default) -
+ *      Run factory immediately upon creation of model instance.
+ * - `required: false` -
+ *      Run factory only if/when accessed.
+ *      Value will always throw suspense at least once - use with caution.
+ *
+ * @param factory - Callback run to derrive property value.
+ * @param required - (default: true) Run factory immediately on creation, otherwise on access.
+ */
+declare function get<T>(factory: get.Factory<Promise<T>>, required: false): T | undefined;
+declare function get<T, S>(factory: get.Factory<Promise<T>, S>, required: false): T | undefined;
+declare function get<T>(factory: get.Factory<Promise<T>>, required?: boolean): T;
+declare function get<T, S>(factory: get.Factory<Promise<T>, S>, required?: boolean): T;
+/**
+ * Set property with a factory function.
+ *
+ * - `required: true` (default) -
+ *      Run factory immediately upon creation of model instance.
+ * - `required: false` -
+ *      Run factory only if/when accessed.
+ *      Value will always throw suspense at least once - use with caution.
+ *
+ * @param factory - Callback run to derrive property value.
+ * @param required - (default: true) Run factory immediately on creation, otherwise on access.
+ */
+declare function get<T>(factory: get.Factory<T>, required: false): T | undefined;
+declare function get<T, S>(factory: get.Factory<T, S>, required: false): T | undefined;
+declare function get<T>(factory: get.Factory<T>, required?: boolean): T;
+declare function get<T, S>(factory: get.Factory<T, S>, required?: boolean): T;
+/**
+ * Assign a property with result of a promise.
+ */
+declare function get<T>(factory: Promise<T>, required: false): T | undefined;
+declare function get<T>(factory: Promise<T>, required?: boolean): T;
+
+declare namespace ref {
+    type Callback<T, S = any> = (this: S, argument: T) => ((next: T) => void) | Promise<void> | void | boolean;
+    interface Object<T = any> {
+        (next: T): void;
+        current: T | null;
+    }
+    /** Object with references to all managed values of `T`. */
+    type Proxy<T extends Model> = {
+        [P in Model.Key<T>]-?: Model.Ref<T[P]>;
+    };
+    type CustomProxy<T extends Model, R> = {
+        [P in Model.Key<T>]-?: R;
+    };
+}
+/**
+ * Creates an object with references to all managed values.
+ * Each property is a function to set value in state when invoked.
+ *
+ * *Properties are simultaneously a ref-function and ref-object, use as needed.*
+ *
+ * @param target - Source model from which to reference values.
+ */
+declare function ref<T extends Model>(target: T): ref.Proxy<T>;
+/**
+ * Creates an object with values based on managed values.
+ * Each property will invoke mapper function on first access supply
+ * the its return value going forward.
+ *
+ * @param target - Source model from which to reference values.
+ * @param mapper - Function producing the placeholder value for any given property.
+ */
+declare function ref<O extends Model, R>(target: O, mapper: (key: Model.Key<O>) => R): ref.CustomProxy<O, R>;
+/**
+ * Creates a ref-compatible property.
+ * Will persist value, and updates to this are made part of controller event-stream.
+ *
+ * *Output is simultaneously a ref-function and ref-object, use as needed.*
+ *
+ * @param callback - Optional callback to synchronously fire when reference is first set or does update.
+ */
+declare function ref<T = HTMLElement>(callback?: ref.Callback<T>): ref.Object<T>;
+declare function ref<T, S>(callback?: ref.Callback<T, S>): ref.Object<T>;
+
+declare namespace set {
+    type Callback<T, S = any> = (this: S, argument: T) => ((next: T) => void) | Promise<any> | void | boolean;
+}
+/**
+ * Set property with a placeholder.
+ *
+ * Property cannot be accessed until it is defined. If accessed while undefined, a hybrid
+ * `Promise`/`Error` (ala: [Suspense](https://reactjs.org/docs/concurrent-mode-suspense.html)) will be thrown.
+ */
+declare function set<T = any>(): T;
+declare function set<T>(onUpdate: set.Callback<T>): T;
+declare function set<T, S>(onUpdate: set.Callback<T, S>): T;
+declare function set<T>(value: undefined, onUpdate: set.Callback<T>): T;
+declare function set<T, S>(value: undefined, onUpdate: set.Callback<T, S>): T;
+declare function set<T>(value: T, onUpdate: set.Callback<T>): T;
+declare function set<T, S>(value: T, onUpdate: set.Callback<T, S>): T;
+
+declare type MapFunction<T, R> = T extends Map<infer K, infer V> ? (value: V, key: K, map: T) => R | void : T extends Set<infer K> ? (value: K, key: K, set: T) => R | void : never;
+declare type Managed<T> = Exclude<T, "forEach"> & {
+    from?: T;
+    forEach<R>(mapFunction: MapFunction<T, R>, thisArg?: any): Exclude<R, undefined>[] | void;
+};
+
+declare function use<K = any>(initial: SetConstructor): Managed<Set<K>>;
+declare function use<K = any, V = any>(initial: MapConstructor): Managed<Map<K, V>>;
+declare function use(initial: Set<unknown>): Managed<Set<any>>;
+declare function use(initial: Map<unknown, unknown>): Managed<Map<any, any>>;
+declare function use(from: () => Set<unknown>): Managed<Set<any>>;
+declare function use(from: () => Map<unknown, unknown>): Managed<Map<any, any>>;
+declare function use<T extends Set<any> | Map<any, any>>(initial: T): Managed<T>;
+declare function use<T extends Set<any> | Map<any, any>>(from: () => T): Managed<T>;
+/**
+ * Create a placeholder for specified Model type.
+ */
+declare function use<T extends Model>(): T | undefined;
+declare function use<T extends Model>(from: () => T, required: false): T | undefined;
+declare function use<T extends Model>(from: () => T, required: boolean): T;
+/**
+ * Create a new child instance of model.
+ */
+declare function use<T extends Model>(Type: Model.Type<T>, callback?: (i: T) => void): T;
+/**
+ * Create a managed child from factory function.
+ */
+declare function use<T extends {}>(from: () => Promise<T>, required: false): T | undefined;
+declare function use<T extends {}>(from: () => Promise<T>, required: boolean): T;
+declare function use<T extends {}>(from: () => Promise<T>, callback?: (i: T) => void): T;
+declare function use<T extends {}>(from: () => T, callback?: (i: T) => void): T;
+/**
+ * Create child-instance relationship with provided model.
+ *
+ * Note: If `peer` is not already initialized before parent is
+ * (created with `new` as opposed to create method), that model will
+ * attach this via `parent()` instruction. It will not, however, if
+ * already active.
+ */
+declare function use<T extends {}>(peer: T, callback?: (i: T) => void): T;
+
+/**
+ * Fetches and assigns the controller which spawned this host.
+ * When parent assigns an instance via `use()` directive, it
+ * will be made available to child upon this request.
+ *
+ * @param Type - Type of controller compatible with this class.
+ * @param required - Throw if controller is created independantly.
+ */
+declare function has<T extends Model>(Type: Model.Type<T>, required: false): T | undefined;
+declare function has<T extends Model>(Type: Model.Type<T>, required?: true): T;
+
+declare namespace MVC {
+    type EffectCallback<T = MVC> = (found: T) => Callback | void;
+    type ForceUpdate = {
+        (): void;
+        <T = void>(passthru?: Promise<T>): Promise<T>;
+    };
+    type TapCallback<T extends Model, R> = (this: T, model: T, update: MVC.ForceUpdate) => R;
+}
+declare class MVC extends Model {
+    end(force?: boolean): boolean | void;
+    static global?: boolean;
+    static keepAlive?: boolean;
+    /**
+     * Create a new instance of this model and activate its managed state.
+     *
+     * @param args - arguments sent to constructor
+     */
+    static new<T extends Class>(this: T, ...args: ConstructorParameters<T>): InstanceOf<T>;
+    /**
+     * **React Hook** - Fetch most instance of this controller from context, if it exists.
+     *
+     * @param required - Unless false, will throw where instance cannot be found.
+     */
+    static get<T extends MVC>(this: Model.Type<T>, required?: boolean, effectCallback?: MVC.EffectCallback<T>): T;
+    /**
+     * **React Hook** - Fetch most instance of this controller from context.
+     *
+     * @param required - If false, may return undefined.
+     */
+    static get<T extends MVC>(this: Model.Type<T>, required: false, effectCallback?: MVC.EffectCallback<T | undefined>): T | undefined;
+    /**
+     * **React Hook** - Fetch instance.
+     *
+     * Effect callback will run once if found, throw if not found.
+     * Returned function is called on unmount.
+     */
+    static get<I extends MVC>(this: Model.Type<I>, effectCallback: MVC.EffectCallback<I>): I | undefined;
+    /**
+     * **React Hook** - Fetch specific value from instance of this controller in context.
+     */
+    static get<I extends MVC, K extends Model.Key<I>>(this: Model.Type<I>, key: K): I[K];
+    /**
+     * **React Hook** - Fetch and subscribe to instance of this controller within ambient component.
+     */
+    static tap<T extends MVC>(this: Model.Type<T>): T;
+    static tap<T extends MVC, K extends Model.Key<T>>(this: Model.Type<T>, key: K, expect: true): Exclude<T[K], undefined>;
+    static tap<T extends MVC, K extends Model.Key<T>>(this: Model.Type<T>, key: K, expect?: boolean): NoVoid<T[K]>;
+    static tap<T extends MVC, R>(this: Model.Type<T>, connect: MVC.TapCallback<T, () => R>): NoVoid<R>;
+    static tap<T extends MVC, R>(this: Model.Type<T>, connect: MVC.TapCallback<T, (() => R) | null>): NoVoid<R> | null;
+    static tap<T extends MVC, R>(this: Model.Type<T>, compute: MVC.TapCallback<T, Promise<R> | R>, expect: true): Exclude<R, undefined>;
+    static tap<T extends MVC, R>(this: Model.Type<T>, compute: MVC.TapCallback<T, Promise<R>>, expect?: boolean): NoVoid<R> | null;
+    static tap<T extends MVC, R>(this: Model.Type<T>, compute: MVC.TapCallback<T, R>, expect?: boolean): NoVoid<R>;
+    static use<I extends MVC>(this: Model.Type<I>, watch: Model.Key<I>[], callback?: (instance: I) => void): I;
+    static use<I extends MVC>(this: Model.Type<I>, callback?: (instance: I) => void): I;
+    static use<I extends MVC>(this: Model.Type<I>, apply: Model.Compat<I>, keys?: Model.Event<I>[]): I;
+    static meta<T extends Class>(this: T): T;
+    static meta<T extends Class, K extends keyof T>(this: T, key: K, expect: true): Exclude<T[K], undefined>;
+    static meta<T extends Class, K extends keyof T>(this: T, key: K, expect?: boolean): T[K];
+    static meta<T, M extends Class>(this: M, from: (this: M, state: M) => Promise<T>, expect: true): Exclude<T, undefined>;
+    static meta<T, M extends Class>(this: M, from: (this: M, state: M) => Promise<T>, expect?: boolean): T;
+    static meta<T, M extends Class>(this: M, from: (this: M, state: M) => T, expect: true): Exclude<T, undefined>;
+    static meta<T, M extends Class>(this: M, from: (this: M, state: M) => T, expect?: boolean): T;
+}
+
+declare function useContext<T extends Model>(Type: Model.Type<T>, required: false): T | undefined;
+declare function useContext<T extends Model>(Type: Model.Type<T>, required?: boolean): T;
+
+declare function useNew<T extends Model>(source: Model.Type<T> | (() => T), callback?: (instance: T) => void): T;
+declare function useNew<T extends Model>(source: Model.Type<T> | (() => T), watch: Model.Key<T>[], callback?: (instance: T) => void): T;
+declare function useNew<T extends Model>(source: Model.Type<T> | (() => T), apply: Model.Compat<T>, keys?: Model.Event<T>[]): T;
+
+declare namespace useTap {
+    type Source<T extends Model> = T | Model.Type<T> | (() => T | Model.Type<T>);
+    type Callback<T extends Model, R> = (this: T, model: T, update: MVC.ForceUpdate) => R;
+}
+declare function useTap<T extends Model>(source: useTap.Source<T>): T;
+declare function useTap<T extends Model, K extends Model.Key<T>>(source: useTap.Source<T>, path: K, expect: true): Exclude<T[K], undefined>;
+declare function useTap<T extends Model, K extends Model.Key<T>>(source: useTap.Source<T>, path: K, expect?: boolean): NoVoid<T[K]>;
+declare function useTap<T extends Model, R>(source: useTap.Source<T>, connect: useTap.Callback<T, () => R>): NoVoid<R>;
+declare function useTap<T extends Model, R>(source: useTap.Source<T>, connect: useTap.Callback<T, (() => R) | null>): NoVoid<R> | null;
+declare function useTap<T extends Model, R>(source: useTap.Source<T>, compute: useTap.Callback<T, Promise<R> | R>, expect: true): Exclude<R, undefined>;
+declare function useTap<T extends Model, R>(source: useTap.Source<T>, compute: useTap.Callback<T, Promise<R>>, expect?: boolean): NoVoid<R> | null;
+declare function useTap<T extends Model, R>(source: useTap.Source<T>, compute: useTap.Callback<T, R>, expect?: boolean): NoVoid<R>;
+
+declare namespace Consumer {
+    type HasProps<E extends Class> = {
+        /** @deprecated - use for instead */
+        of?: never;
+        /** Type of controller to fetch from context. */
+        for: E;
+        /**
+         * Getter function. Is called on every natural render of this component.
+         * Will throw if usable instance cannot be found in context.
+         */
+        has: (value: InstanceType<E>) => void;
+    };
+    type GetProps<E extends Class> = {
+        /** @deprecated - use for instead */
+        of?: never;
+        /** Type of controller to fetch from context. */
+        for: E;
+        /** Getter function. Is called on every natural render of this component. */
+        get: (value: InstanceType<E> | undefined) => void;
+    };
+    type RenderProps<E extends Class> = {
+        /** @deprecated - use for instead */
+        of?: never;
+        /** Type of controller to fetch from context. */
+        for: E;
+        /**
+         * Render function, will receive instance of desired controller.
+         *
+         * Similar to `tap()`, updates to properties accessed in
+         * this function will cause a refresh when they change.
+         */
+        children: (value: InstanceType<E>) => React.ReactElement<any, any> | null;
+    };
+    type Props<T extends Class> = HasProps<T> | GetProps<T> | RenderProps<T>;
+}
+declare function Consumer<T extends Class>(props: Consumer.Props<T>): any;
+
+declare namespace Provider {
+    type Item = Model | Model.Type;
+    type Multiple<T extends Item = Item> = T[] | {
+        [key: string]: T;
+    };
+    type Instance<E> = E extends Class ? InstanceType<E> : E extends Model ? E : never;
+    type NormalProps<E, I = Instance<E>> = {
+        for: E;
+        fallback?: React.ReactNode;
+        children?: React.ReactNode | ((instance: I) => React.ReactNode);
+        and?: Model.Compat<I>;
+    };
+    type MultipleProps<T extends Item> = {
+        for: Multiple<T>;
+        fallback?: React.ReactNode;
+        children?: React.ReactNode;
+        and?: Model.Compat<Instance<T>>;
+    };
+    type Props<T extends Item> = MultipleProps<T> | NormalProps<T>;
+}
+declare function Provider<T extends Provider.Item>(props: Provider.Props<T>): JSX.Element;
+
+declare class Global extends MVC {
+    static global: boolean;
+    static keepAlive: boolean;
+}
+
+declare namespace tap {
+    type Callback<T extends Model> = (instance: T | undefined) => void | boolean;
+}
+/**
+ * Find and attach most applicable instance of Model via context.
+ *
+ * Host controller will search element-hierarchy relative to where it spawned.
+ *
+ * @param Type - Type of model to find from context
+ * @param callback -
+ *  - Invoked after context is scanned, is passed result - either found or undefined.
+ *  - If argument is inadequate, but required, your implemention should simply throw.
+ *  - If inadequate and not required, conditionally return false.
+ */
+declare function tap<T extends Model>(Type: Model.Type<T>, callback?: (instance?: T) => void | true): T;
+declare function tap<T extends Model>(Type: Model.Type<T>, callback?: (instance?: T) => void | boolean): T | undefined;
+/**
+ * Find and attach most applicable instance of Model via context.
+ *
+ * Expects a `<Provider>` of target controller to exist.
+ * Host controller will search element-hierarchy relative to where it spawned.
+ *
+ * @param Type - Type of controller to attach to property.
+ * @param required - Throw if instance of Type cannot be found.
+ */
+declare function tap<T extends Model>(Type: Model.Type<T>, required: true): T;
+declare function tap<T extends Model>(Type: Model.Type<T>, required?: boolean): T | undefined;
+
+export { Consumer, Debug, Global, MVC, MVC as Model, Provider, add, MVC as default, get, has, ref, run, set, tap, use, useContext, useNew, useTap };