Initial commit — jibo-cli v3.0.7 with bundled node_modules

node_modules/jibo-kb/lib/dts/Model.d.ts

@@ -0,0 +1,265 @@
+import Cache from './Cache';
+import KnowledgeDatabase from './KnowledgeDatabase';
+import Node from './Node';
+export declare type ErrCallback = (err) => void;
+export declare type NodeCallback = (err, node?: Node) => void;
+export declare type NodesCallback = (err, nodes?: Node[]) => void;
+export declare type ModelConstructor = new (kbNames: string | string[], httpUrl: string) => Model;
+/** Combine multiple KB slices into one. Model instances are the main
+ * interaction point with the Knowledge Base. Methods for following
+ * edges between nodes are here.
+ *
+ * Extend this class to add model specific methods to a Model.
+ *
+ * @class Model
+ * @memberof jibo.kb
+ * @param {string|string[]} kbNames KB slice names to use in this
+ * model.
+ * @param {string} httpUrl Base URL of KB service to use.
+ */
+export default class Model {
+    private static modelClassRegistry;
+    pool: KnowledgeDatabase[];
+    cache: Cache;
+    roots: {
+        [kbName: string]: Node;
+    };
+    kbNames: string[];
+    httpUrl: string;
+    /** Register a Model subclass to be instantiated for a given KB name
+     * list.
+     *
+     * @method jibo.kb.Model.registerModelClass
+     * @static
+     * @param {string|string[]} kbNames KB name or name list use this
+     * subclass for.
+     * @param {Function} classConstructor The constructor function for
+     * the subclass.
+     * @internal
+     */
+    static registerModelClass(kbNames: string | string[], classConstructor: ModelConstructor): void;
+    /** Use the given KB slice names to find a Model subclass in the
+     * Model subclass registry. Defaults to the plain `Model` object
+     * if nothing matches.
+     *
+     * @method jibo.kb.Model.findModelClass
+     * @static
+     * @param {string|string[]} kbNames Array of knowledge base slice
+     * names.
+     * @returns {Function} Model class constructor.
+     * @internal
+     */
+    static findModelClass(kbNames: string | string[]): ModelConstructor;
+    constructor(kbNames: string | string[], httpUrl?: string);
+    /** Initalize the model and all its kb slices.
+     * Not needed when using the KB service as a client.
+     *
+     * @method jibo.kb.Model#init
+     * @param {Function} callback Callback for the method.
+     * @internal
+     */
+    init(callback: ErrCallback): void;
+    /** Create a new Model object.
+     *
+     * This behaves the same as `kb.createModel()`, except the KB
+     * names are not required to start with /. KB names that don't
+     * start with / will be relative to this Model. Specifically, they
+     * will relative to the KB name of the first KB in this model.
+     *
+     * For example, if this Model has the KB names `['/snap',
+     * '/snap/albums']` and this method is called as
+     * `model.createModel(['history', '/jibo.loop'])`, then the new
+     * model returned by this method will have the KB names
+     * `['/snap/history', '/jibo.loop']`.
+     *
+     * @method jibo.kb.Model#createModel
+     * @param {string|string[]} kbNames KB slice names to use in new
+     * model.
+     * @param {string} [httpUrl] Base URL of KB service to use
+     * (defaults to same URL as `this`).
+     * @returns {jibo.kb.Model} New Model object
+     */
+    createModel(kbNames: string | string[], httpUrl?: string): Model;
+    /** Create a new empty node on this Model. Will be attached to the
+     * first KB in this Model.
+     *
+     * @method jibo.kb.Model#createNode
+     * @param {string} nodeType Node type.
+     * @param {Object} [data] Initial data.
+     * @returns {jibo.kb.Node} New node object
+     */
+    createNode(nodeType: string, data?: any): Node;
+    /** Load a node or array of nodes, by their IDs. All KBs in this
+     * Model slices are searched in order until found. If node is not
+     * found result will be `null`.  If an array is supplied, then
+     * multiple IDs are searched for, and an array of results is
+     * returned. If callback is omitted, a promise is returned
+     * instead.
+     *
+     * @method jibo.kb.Model#load
+     * @param {string|string[]} ids ID or array of IDs to load.
+     * @param {Function} [callback] `(err, nodes) => {}`. If callback is
+     * omitted, a promise that resolves to `nodes` is returned instead.
+     * @returns {Promise} A promise that resolves with the value of
+     * `node` if the callback is omitted.
+     */
+    load(id: string, callback: NodeCallback): any;
+    load(ids: string[], callback: NodesCallback): any;
+    load(id: string): Promise<Node>;
+    load(ids: string[]): Promise<Node[]>;
+    loadList(ids: string[], callback: NodesCallback): any;
+    fetchList(ids: string[], quietly?: boolean): Node[];
+    /** Load the root node of the first KB. If a KB slice name is
+     * given, then load the root node for that KB instead. If callback
+     * is omitted a promise is returned instead.
+     *
+     * @method jibo.kb.Model#loadRoot
+     * @param {string} [kbName] Name of KB slice to load root node
+     * from. Default is first slice.
+     * @param {Function} [callback] (err, rootNode) => {}. If callback
+     * is omitted a promise that resolves to `rootNode` is returned
+     * instead.
+     * @returns {Promise} A promise that resolves with the value of
+     * `rootNode` if the callback is omitted.
+     */
+    loadRoot(callback: NodeCallback): any;
+    loadRoot(kbName: string, callback: NodeCallback): any;
+    loadRoot(): Promise<Node>;
+    loadRoot(kbName: string): Promise<Node>;
+    /** Preload all nodes connected by the layer names into the
+     * cache. Does not return the nodes. If callback is omitted a
+     * promise is returned instead.
+     *
+     * @method jibo.kb.Model#loadLayers
+     * @param {jibo.kb.Node} node Initial node to start from.
+     * @param {string|string[]} layers Edge names to follow.
+     * @param {Function} [callback] Callback for the method. If callback
+     * is omitted a promise is returned instead.
+     * @returns {Promise} A promise if the callback is omitted.
+     */
+    loadLayers(node: Node, layers: string | string[], callback: Function): any;
+    loadLayers(node: Node, layers: string | string[]): Promise<any>;
+    /** Save all nodes connected by the layer names. Only used after
+     * activating the cache and preloading the given layers with
+     * loadLayers(). If callback is omitted a promise is returned
+     * instead.
+     *
+     * @method jibo.kb.Model#saveLayers
+     * @param {jibo.kb.Node} node Initial node to start from.
+     * @param {string|string[]} layers Edge names to follow.
+     * @param {Function} [callback] Callback for the method. If callback
+     * is omitted a promise is returned instead.
+     * @returns {Promise} A promise if the callback is omitted.
+     */
+    saveLayers(node: Node, layers: string | string[], callback: Function): any;
+    saveLayers(node: Node, layers: string | string[]): Promise<any>;
+    /** Load all nodes connected by the layer names. Execute the given
+     * action once on each node. If callback is omitted a promise is
+     * returned instead.
+     *
+     * @method jibo.kb.Model#visitLayers
+     * @param {jibo.kb.Node} node Initial node to start from.
+     * @param {string|string[]} layers Edge names to follow.
+     * @param {Function} action `(eachNode, callback) => {}`
+     * @param {Function} [callback] Callback for the method. If callback
+     * is omitted a promise is returned instead.
+     * @returns {Promise} A promise if the callback is omitted.
+     */
+    visitLayers(node: Node, layers: string | string[], action: Function, callback: Function): any;
+    visitLayers(node: Node, layers: string | string[], action: Function): Promise<any>;
+    /** Create a clone of this Model object and its slices, but with
+     * the cache enabled. Cache based operations are intended to be
+     * short term in nature. Release the clone for garbage collection
+     * when finished.
+     *
+     * @method jibo.kb.Model#begin
+     * @returns {jibo.kb.Model} A new Model object.
+     */
+    begin(): Model;
+    /** Synchronously fetch a node, or array of nodes, from the
+     * cache. Use on models created with `begin()` and preloaded with
+     * nodes. Nodes searched for but not found during preloading will
+     * be null. Nodes not preloaded will be undefined.
+     *
+     * @method jibo.kb.Model#fetch
+     * @param {string|string[]} ids ID or array of IDs node to fetch.
+     * @param {boolean} [quietly] Suppress warning if node not found
+     * in cache.
+     * @throws Exception if cache is not enabled.
+     * @returns {jibo.kb.Node} Node or `null` if not found. If
+     * an array of IDs is supplied, then an array of nodes is
+     * returned.
+     */
+    fetch(id: string, quietly?: boolean): Node;
+    fetch(ids: string[], quietly?: boolean): Node[];
+    /** Synchronously fetch the root node of the first KB from cache.
+     * If a KB slice name is given, then load the root node for that
+     * KB instead.
+     *
+     * @method jibo.kb.Model#fetchRoot
+     * @param {string} [kbName] Name of KB slice to load root node
+     * from. Default is first slice.
+     * @param {boolean} [quietly] Suppress warning if root node not
+     * found in cache.
+     * @throws Exception if cache is not enabled.
+     * @returns {jibo.kb.Node} Root node or `null` if not in cache.
+     */
+    fetchRoot(kbName?: string, quietly?: boolean): Node;
+    /** Turn on the cache. Don't call this directly, use begin() instead.
+     * @method jibo.kb.Model#enableCache
+     * @private
+     */
+    protected enableCache(): void;
+    /** Actual load command. Wrapped by interceptLoad when cache is
+     * enabled.
+     *
+     * @method jibo.kb.Model#_load
+     * @param {string} id Id of node to load
+     * @param {Function} callback (err, node) => {}
+     * @private
+     */
+    private _load(id, callback);
+    /** Load a single node by its id. All KBs in this
+     * Model will be searched in order until found. Null returned (via
+     * callback) if not found.
+     *
+     * @method jibo.kb.Model#_loadOne
+     * @param {string} id ID to load.
+     * @param {Function} [callback] (err, node) => {}.
+     * @private
+     */
+    private _loadOne(id, callback);
+    /** Load an array of nodes by id. All KBs in this Model will be
+     * searched, in order, for each id in the array. An empty array is
+     * returned (via callback) if none of the ids are found.
+     *
+     * @method jibo.kb.Model#_loadArray
+     * @param {string[]} ids Array of IDs of nodes to load.
+     * @param {Function} [callback] (err, nodes) => {}.
+     * @private
+     */
+    private _loadArray(ids, callback);
+    /** Look through the pool and return the kb slice
+     * that has the given name
+     *
+     * @method jibo.kb.Model#_getKnowledgeDatabase
+     * @param {string} kbName Name of kb slice to find in pool
+     * @returns {jibo.kb.KnowledgeDatabase} Matching kb slice object, or
+     * undefined if not found
+     * @private
+     */
+    private _getKnowledgeDatabase(kbName);
+    /** check if cache is enabled and throw exception if not
+     *
+     * @method jibo.kb.Model#_assertCache
+     * @private
+     */
+    private _assertCache();
+    /** Convert a single item to an array for arguments that may be a
+     * single thing or an array of things
+     *
+     * @method jibo.kb.Model#<_toArray
+     * @private
+     */
+    private _toArray<T>(items);
+}