@expressive/mvc 1.0.0-beta.4 → 1.0.0-beta.40

package/README.md

@@ -24,10 +24,19 @@
 </p>
 
 <br/>
-<h1 id="overview-section"></h1>
+<p align="center">
+  <b>Have suggestions, need help or just want to discuss?</b><br/><br/>
+  <a href="https://join.slack.com/t/expressivejs/shared_invite/zt-s2j5cdhz-gffKn3bTATMbXf~iq4pvHg" alt="Join Slack">
+    <img src="https://img.shields.io/badge/Slack-Come%20say%20hi!-blueviolet" />  
+  </a>
+</p>
+
+<br/>
+<h1 id="overview-section">Overview</h1>
 
 Classes which extend `Model` can manage behavior for components. Custom models are easy to define, use and even provide. While hooks are great, state and logic are not a part of well-formed JSX. Models help wrap that stuff in robust, portable controllers instead.
 
+
 <br/>
 
 ## How to use

package/lib/index.d.ts

@@ -0,0 +1,592 @@
+import React from 'react';
+
+declare type Async<T = any> = (...args: any[]) => Promise<T>;
+/**
+ * Sets an exotic method with managed ready-state. Property accepts an async function.
+ *
+ * When an act-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 act(action: Async): typeof action & {
+    active: boolean;
+};
+declare function act<S>(action: Async<S>): typeof action & {
+    active: boolean;
+};
+
+type Callback = () => void;
+type Class = new (...args: any[]) => any;
+type InstanceOf<T> = T extends { prototype: infer U } ? U : never;
+type RequestCallback<T extends string = string> = (keys: readonly T[]) => void;
+
+declare type Listener = {
+    commit(): void;
+    release(): void;
+};
+declare class Subscriber<T extends Stateful = any> {
+    onUpdate: Controller.OnEvent;
+    proxy: T;
+    release: Callback;
+    commit: () => () => void;
+    active: boolean;
+    dependant: Set<Listener>;
+    watch: { [key in Model.Event<T, Model>]: true | Callback; };
+    constructor(target: Controller<T> | T, onUpdate: Controller.OnEvent);
+}
+
+declare const CONTROL: unique symbol;
+declare const WHY: unique symbol;
+declare const LOCAL: unique symbol;
+declare const STATE: unique symbol;
+interface Stateful {
+    /** Controller for this instance. */
+    [CONTROL]: Controller;
+    /** Current subscriber (if present) while used in a live context (e.g. hook or effect). */
+    [LOCAL]?: Subscriber;
+    /** Current state of this instance. */
+    [STATE]?: this;
+    /**
+     * 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.
+     */
+    [WHY]?: readonly Model.Event<this>[];
+}
+declare namespace Model {
+    /** Including but not limited to T. */
+    type Extends<T> = T | (string & Record<never, never>);
+    export { Controller };
+    export { Subscriber };
+    export type OnUpdate<T, P> = (this: T, value: ValueOf<keyof T, P>, changed: P) => void;
+    export type Effect<T> = (this: T, argument: T) => Callback | Promise<any> | void;
+    /** Exotic value, actual value is contained. */
+    export interface Ref<T = any> {
+        (next: T): void;
+        current: T | null;
+    }
+    /** Properties of T, of which are methods. */
+    export type Methods<T> = {
+        [K in keyof T]: T[K] extends Ref ? never : T[K] extends Function ? K : never;
+    }[keyof T];
+    /**
+     * 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).
+     **/
+    export type Field<T, U extends Model = Model> = Exclude<keyof T & string, keyof U>;
+    /**
+     * Including but not limited to `keyof T` which are not methods or defined by base Model.
+     **/
+    export type Event<T, U extends Model = Model> = Extends<Field<T, U>>;
+    /** Object containing managed entries found in T. */
+    export type Entries<T, U extends Model = Model> = Pick<T, Field<T, U>>;
+    /** Object comperable to data found in T. */
+    export type Compat<T, U extends Model = Model> = Partial<Entries<T, U>>;
+    /** 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 Values<T, K extends Field<T, Model> = Field<T, Model>> = {
+        [P in K]: Value<T[P]>;
+    };
+}
+interface Model extends Stateful {
+    /**
+     * Circular reference to `this` controller.
+     *
+     * Useful to obtain full reference where one has already destructured.
+     */
+    get: this;
+    /**
+    * Circular reference to `this` controller.
+    *
+    * Shortcut is mainly to update values, while having destructured already.
+    */
+    set: this;
+}
+declare class Model {
+    static [CONTROL]: Controller;
+    static [WHY]: readonly string[];
+    constructor();
+    get [STATE](): this;
+    get [WHY](): readonly string[] | undefined;
+    on<P = Model.Event<this>>(event: (key: P) => RequestCallback | void): Callback;
+    on<P = Model.Event<this>>(keys: [], listener: Model.OnUpdate<this, P>, squash?: boolean, once?: boolean): Callback;
+    on<P = Model.Event<this>>(keys: [], listener: (keys: P[]) => void, squash: true, once?: boolean): Callback;
+    on(keys: [], listener: unknown, squash: boolean, once?: boolean): Callback;
+    on<P extends Model.Event<this>>(key: P | P[], listener: Model.OnUpdate<this, P>, squash?: boolean, once?: boolean): Callback;
+    on<P extends Model.Event<this>>(key: P | P[], listener: (keys: P[]) => void, squash: true, once?: boolean): Callback;
+    on<P extends Model.Event<this>>(key: P | P[], listener: unknown, squash: boolean, once?: boolean): Callback;
+    once<P = Model.Event<this>>(keys: [], listener: Model.OnUpdate<this, P>, squash?: false, once?: boolean): Callback;
+    once<P = Model.Event<this>>(keys: [], listener: (keys: P[]) => void, squash: true, once?: boolean): Callback;
+    once<P = Model.Event<this>>(keys: [], listener: (keys: P[]) => void, squash: true, once?: boolean): Callback;
+    once(keys: [], listener: unknown, squash: boolean, once?: boolean): Callback;
+    once<P extends Model.Event<this>>(key: P | P[], listener: Model.OnUpdate<this, P>, squash?: false): Callback;
+    once<P extends Model.Event<this>>(key: P | P[], listener: (keys: P[]) => void, squash: true): Callback;
+    once<P extends Model.Event<this>>(key: P | P[], listener: unknown, squash: boolean): Callback;
+    once<P extends Model.Event<this>>(key: P | P[]): Promise<P[]>;
+    effect(callback: Model.Effect<this>): Callback;
+    effect(callback: Model.Effect<this>, select: []): Callback;
+    effect(callback: Model.Effect<this>, select: Model.Event<this>[]): Callback;
+    import<O extends Model.Compat<this>>(source: O, select?: (keyof O)[]): void;
+    export(): Model.Values<this>;
+    export<P extends Model.Field<this>>(select: P[]): Model.Values<this, P>;
+    update(): PromiseLike<readonly Model.Event<this>[] | false>;
+    update(strict: true): Promise<readonly Model.Event<this>[]>;
+    update(strict: false): Promise<false>;
+    update(strict: boolean): Promise<readonly Model.Event<this>[] | false>;
+    update(keys: Model.Event<this>): PromiseLike<readonly Model.Event<this>[]>;
+    update(keys: Model.Event<this>, callMethod: boolean): PromiseLike<readonly Model.Event<this>[]>;
+    update<T>(keys: Model.Event<this>, argument: T): PromiseLike<readonly Model.Event<this>[]>;
+    /**
+     * Mark this instance for garbage-collection and send `willDestroy` event to all listeners.
+     */
+    destroy(): void;
+    toString(): string;
+    /**
+     * Creates a new instance of this controller.
+     *
+     * Beyond `new this(...)`, method will activate managed-state.
+     *
+     * @param args - arguments sent to constructor
+     */
+    static create<T extends Class>(this: T, ...args: any[]): InstanceOf<T>;
+    /**
+     * Static equivalent of `x instanceof this`.
+     *
+     * Will determine if provided class is a subtype of this one.
+     */
+    static isTypeof<T extends new () => Model>(this: T, maybe: any): maybe is T;
+}
+
+declare namespace Controller {
+    type OnEvent<T = any> = (key: Model.Event<T>, source: Controller) => RequestCallback | void;
+    type OnValue<T = any, S = Model.Values<T>> = (this: T, value: any, state: S) => boolean | void;
+}
+declare class Controller<T extends Stateful = any> {
+    subject: T;
+    proxy: Model.Entries<T>;
+    state: Model.Values<T, Exclude<keyof T & string, keyof Model>>;
+    frame: Set<string>;
+    waiting: Set<RequestCallback<string>>;
+    onDestroy: Set<Callback>;
+    protected followers: Set<Model.Controller.OnEvent<any>>;
+    constructor(subject: T);
+    start(): void;
+    stop(): void;
+    private manage;
+    ref(key: Model.Field<T>, handler?: Controller.OnValue<T>): (value: any) => void;
+    addListener(listener: Controller.OnEvent<T>): () => void;
+    emit(keys: readonly Model.Event<T>[]): void;
+    update(key: Model.Event<T>, value?: any): void;
+    requestUpdate(): PromiseLike<readonly Model.Event<T>[] | false>;
+    requestUpdate(strict: true): Promise<readonly Model.Event<T>[]>;
+    requestUpdate(strict: false): Promise<false>;
+    requestUpdate(strict: boolean): Promise<readonly Model.Event<T>[] | false>;
+    requestUpdate(callback: (keys: readonly Model.Event<T>[]) => void): void;
+}
+
+/**
+ * Property initializer, will run upon instance creation.
+ * Optional returned callback will run when once upon first access.
+ */
+type Instruction<T> = (this: Controller, key: string, thisArg: Controller) =>
+  | Instruction.Getter<T> 
+  | Instruction.ExplicitDescriptor
+  | Instruction.Descriptor<T>
+  | Instruction.RecursiveDescriptor<T>
+  | boolean
+  | void;
+
+declare namespace Instruction {
+  type Getter<T> = (state: T, within?: Subscriber) => T;
+  type Setter<T> = (value: T, state: any) => boolean | void;
+
+  type Runner<T> = (this: Controller, key: string, on: Controller) => Instruction.Descriptor<T> | boolean | undefined;
+
+  interface Descriptor<T> {
+    configurable?: boolean;
+    enumerable?: boolean;
+    value?: T;
+    writable?: boolean;
+    get?: Getter<T>;
+    set?: Setter<T> | false | void;
+  }
+
+  interface ExplicitDescriptor extends PropertyDescriptor {
+    explicit: true;
+  }
+
+  interface RecursiveDescriptor<T> {
+    recursive: true;
+    enumerable?: boolean;
+    value?: T;
+    set?: Setter<T> | false | void;
+  }
+}
+
+/**
+ * Run instruction as controller sets itself up.
+ * This will specialize the behavior of a given property.
+ */
+declare function apply<T = any>(instruction: Instruction<T>, name?: string): T;
+
+declare namespace from {
+    type Function<T, O = any> = (this: O, on: O) => T;
+    type Factory<T, O = any> = (key: string) => Function<T, O>;
+    type Getter = (controller: Controller, key: string) => any;
+}
+/**
+ * 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 from<R, T>(source: T, compute: (this: T, on: T) => R, suspend: true): Exclude<R, undefined>;
+declare function from<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 from<R, T>(compute: (property: string) => (this: T, state: T) => R, suspend: true): Exclude<R, undefined>;
+declare function from<R, T>(compute: (property: string) => (this: T, state: T) => R, suspend?: boolean): R;
+
+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.Field<T>]: Model.Ref<T[P]>;
+    };
+}
+/**
+ * Creates an object with references to all managed values.
+ * Each property will 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 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 Factory<T, S = unknown> = (this: S, key: string, subject: S) => T;
+    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;
+/**
+ * Set property with starting value `undefined`.
+ *
+ * If required and accessed while still empty, React Suspense will be thrown.
+ * Property will reject any assignment of undefined.
+ *
+ * @param value - Starting value of host property (undefined).
+ * @param required - Property will suspend callee if undefined at time of access.
+ */
+declare function set<T>(value: undefined, required: false): T | undefined;
+declare function set<T>(value: undefined, required?: boolean): T;
+declare function set<T>(value: undefined, onUpdate: set.Callback<T>): T | undefined;
+declare function set<T, S>(value: undefined, onUpdate: set.Callback<T, S>): T | undefined;
+/**
+ * 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 set<T>(factory: set.Factory<Promise<T>>, required: false): T | undefined;
+declare function set<T, S>(factory: set.Factory<Promise<T>, S>, required: false): T | undefined;
+declare function set<T>(factory: set.Factory<Promise<T>>, required?: boolean): T;
+declare function set<T, S>(factory: set.Factory<Promise<T>, S>, required?: boolean): T;
+declare function set<T>(value: set.Factory<Promise<T>>, onUpdate: set.Callback<T>): T;
+declare function set<T, S>(value: set.Factory<Promise<T>, S>, onUpdate: set.Callback<T, S>): 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 set<T>(factory: set.Factory<T>, required: false): T | undefined;
+declare function set<T, S>(factory: set.Factory<T, S>, required: false): T | undefined;
+declare function set<T>(factory: set.Factory<T>, required?: boolean): T;
+declare function set<T, S>(factory: set.Factory<T, S>, required?: boolean): T;
+declare function set<T>(value: set.Factory<T>, onUpdate: set.Callback<T>): T;
+declare function set<T, S>(value: set.Factory<T, S>, onUpdate: set.Callback<T, S>): T;
+
+/**
+ * Create a placeholder for specified Model type.
+ */
+declare function use<T extends Model>(): T | undefined;
+/**
+ * Create a new child instance of model.
+ */
+declare function use<T extends Class>(Type: T, callback?: (i: InstanceOf<T>) => void): InstanceOf<T>;
+/**
+ * Create a managed child from factory function.
+ */
+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 Expects - Type of controller compatible with this class.
+ * @param required - Throw if controller is created independantly.
+ */
+declare function parent<T extends typeof Model>(Expects: T, required: false): InstanceOf<T> | undefined;
+declare function parent<T extends typeof Model>(Expects: T, required?: true): InstanceOf<T>;
+
+declare class MVC extends Model {
+    static [CONTROL]: Controller;
+    /** Attaches this controller to a component. */
+    tap(): this;
+    tap<K extends Model.Field<this>>(key: K, expect: true): Exclude<this[K], undefined>;
+    tap<K extends Model.Field<this>>(key: K, expect?: boolean): this[K];
+    tap<T>(from: (this: this, state: this) => Promise<T>, expect: true): Exclude<T, undefined>;
+    tap<T>(from: (this: this, state: this) => Promise<T>, expect?: boolean): T | undefined;
+    tap<T>(from: (this: this, state: this) => T, expect: true): Exclude<T, undefined>;
+    tap<T>(from: (this: this, state: this) => T, expect?: boolean): T;
+    /**
+     * **React Hook** - Subscribe to instance of controller within a component.
+     *
+     * @param callback - Run once before subscription begins.
+     */
+    use(watch: Model.Field<this>[], callback?: (instance: this) => void): this;
+    use(callback?: (instance: this) => void): this;
+    /**
+     * **React Hook** - Fetch most instance of this controller from context, if it exists.
+     *
+     * @param required - If false, may return undefined.
+     */
+    static get<T extends Class>(this: T, required?: true): InstanceOf<T>;
+    /**
+     * **React Hook** - Fetch most instance of this controller from context.
+     *
+     * @param required - Unless false, will throw where instance cannot be found.
+     */
+    static get<T extends Class>(this: T, required: boolean): InstanceOf<T> | undefined;
+    /**
+     * **React Hook** - Fetch specific value from instance of this controller in context.
+     */
+    static get<T extends Class, I extends InstanceOf<T>, K extends Model.Field<I>>(this: T, key: K): I[K];
+    /**
+     * **React Hook** - Fetch and subscribe to instance of this controller within ambient component.
+     */
+    static tap<T extends Class>(this: T): InstanceOf<T>;
+    static tap<T extends Class, I extends InstanceOf<T>, K extends Model.Field<I>>(this: T, key: K, expect: true): Exclude<I[K], undefined>;
+    static tap<T extends Class, I extends InstanceOf<T>, K extends Model.Field<I>>(this: T, key: K, expect?: boolean): I[K];
+    static tap<T, M extends Class, I extends InstanceOf<M>>(this: M, from: (this: I, state: I) => Promise<T>, expect: true): Exclude<T, undefined>;
+    static tap<T, M extends Class, I extends InstanceOf<M>>(this: M, from: (this: I, state: I) => Promise<T>, expect?: boolean): T;
+    static tap<T, M extends Class, I extends InstanceOf<M>>(this: M, from: (this: I, state: I) => T, expect: true): Exclude<T, undefined>;
+    static tap<T, M extends Class, I extends InstanceOf<M>>(this: M, from: (this: I, state: I) => T, expect?: boolean): T;
+    /**
+     * **React Hook** - Spawn and maintain a controller from within a component.
+     *
+     * More efficient than `use()` if you don't need hook-based features.
+     *
+     * @param callback - Run after creation of instance.
+     */
+    static new<T extends Class>(this: T, callback?: (instance: InstanceOf<T>) => void): InstanceOf<T>;
+    static use<T extends Class, I extends InstanceOf<T>>(this: T, watch: Model.Field<I>[], callback?: (instance: I) => void): I;
+    static use<T extends Class, I extends InstanceOf<T>>(this: T, callback?: (instance: I) => void): I;
+    static use<T extends Class, I extends InstanceOf<T>>(this: T, apply: Model.Compat<I>, keys?: Model.Event<I>[]): I;
+    /**
+     * @deprecated consider doing this manually - not worth minor efficiency gain over using.
+    */
+    static uses<T extends typeof MVC, I extends InstanceOf<T>, D extends Model.Compat<I>>(this: T, apply: D, keys?: (keyof D)[]): InstanceOf<T>;
+    /**
+     * @deprecated is now replaced by overload of `use` method.
+    */
+    static using<T extends typeof MVC, I extends InstanceOf<T>>(this: T, 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 namespace Consumer {
+    type HasProps<E extends Class> = {
+        /** Type of controller to fetch from context. */
+        of: 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> = {
+        /** Type of controller to fetch from context. */
+        of: E;
+        /** Getter function. Is called on every natural render of this component. */
+        get: (value: InstanceType<E> | undefined) => void;
+    };
+    type RenderProps<E extends Class> = {
+        /** Type of controller to fetch from context. */
+        of: 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 type Collection = Array<Model | typeof Model> | {
+    [anything: string]: Model | typeof Model;
+};
+declare class Lookup {
+    private table;
+    get local(): Model[];
+    private key;
+    get(T: typeof Model): any;
+    push(I: Model | typeof Model | Collection): this;
+    register(I: Model | typeof Model): Model;
+    pop(): void;
+}
+
+declare namespace Provider {
+    type Item = Model | typeof Model;
+    type Collection<T extends Item> = T[] | {
+        [key: string]: T;
+    };
+    type Existent<E> = E extends Class ? InstanceType<E> : E extends Model ? E : never;
+    type NormalProps<E, I = Existent<E>> = {
+        of: E;
+        children: React.ReactNode | ((instance: I) => React.ReactNode);
+    } & Model.Compat<I>;
+    type MultipleProps<T extends Item> = {
+        of: Collection<T>;
+        children?: React.ReactNode | (() => React.ReactNode);
+    } & Model.Compat<Existent<T>>;
+    type Props<T extends Item> = MultipleProps<T> | NormalProps<T>;
+}
+declare function Provider<T extends Provider.Item>(props: Provider.Props<T>): React.FunctionComponentElement<React.ProviderProps<Lookup>>;
+
+declare class Global extends MVC {
+    static create<T extends Class>(this: T, ...args: any[]): InstanceOf<T>;
+    /**
+     * Update the active instance of this class.
+     * Returns a thenable; resolves after successful update.
+     * If instance does not already exist, one will be created.
+     */
+    static set<T extends typeof Global>(this: T, updates: Partial<InstanceOf<T>>): PromiseLike<false | readonly Model.Event<Global, Model>[]>;
+    static get(arg?: boolean | string): any;
+    /** Destroy current instance of Global, if it exists. */
+    static reset(): void;
+    destroy(): void;
+}
+
+/**
+ * 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 Class>(Type: T, callback?: (instance?: InstanceOf<T>) => void | true): InstanceOf<T>;
+declare function tap<T extends Class>(Type: T, callback?: (instance?: InstanceOf<T>) => void | boolean): InstanceOf<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 Class>(Type: T, required: true): InstanceOf<T>;
+declare function tap<T extends Class>(Type: T, required?: boolean): InstanceOf<T> | undefined;
+
+declare function useFrom<T extends Stateful, R>(source: (() => T) | T, compute: (this: T, from: T) => R, expect: true): Exclude<R, undefined>;
+declare function useFrom<T extends Stateful, R>(source: (() => T) | T, compute: (this: T, from: T) => R, expect?: boolean): R;
+
+declare function useInContext<T extends typeof Model>(Type: T, arg?: boolean | string): any;
+
+declare function useModel<T extends Class, I extends InstanceOf<T>>(source: T, watch: Model.Field<I>[], callback?: (instance: I) => void): I;
+declare function useModel<T extends Class, I extends InstanceOf<T>>(source: T, callback?: (instance: I) => void): I;
+declare function useModel<T extends Class, I extends InstanceOf<T>>(source: T, apply: Model.Compat<I>, keys?: Model.Event<I>[]): I;
+declare function useModel<T extends Stateful>(source: (() => T) | T, watch?: Model.Field<T>[], callback?: (instance: T) => void): T;
+declare function useModel<T extends Stateful>(source: (() => T) | T, callback?: (instance: T) => void): T;
+declare function useModel<T extends Stateful>(source: (() => T) | T, apply: Model.Compat<T>, keys?: Model.Event<T>[]): T;
+
+declare namespace useTap {
+    interface Tappable {
+        new (): Stateful;
+        new (...args: any[]): Stateful;
+        get?: () => Stateful;
+    }
+}
+declare function useTap<T extends Stateful>(source: T | (() => T)): T;
+declare function useTap<T extends Stateful, K extends Model.Field<T>>(source: T | (() => T) | useTap.Tappable, path: K, expect: true): Exclude<T[K], undefined>;
+declare function useTap<T extends Stateful, K extends Model.Field<T>>(source: T | (() => T) | useTap.Tappable, path: K, expect?: boolean): T[K];
+declare function useTap<T extends Stateful, R>(source: T | (() => T) | useTap.Tappable, compute: (this: T, from: T) => R, expect: true): Exclude<R, undefined>;
+declare function useTap<T extends Stateful, R>(source: T | (() => T) | useTap.Tappable, compute: (this: T, from: T) => R, expect?: boolean): R;
+
+export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, Stateful, WHY, act, apply, MVC as default, from, parent, ref, set, tap, use, useFrom, useInContext, useModel, useTap };