mftsccs-node 0.2.3 → 0.2.4

package/dist/types/Visualize/ConceptCircle.d.ts

@@ -0,0 +1,35 @@
+import { Concept, Connection } from "../app";
+export declare class ConceptCircle {
+    concept: Concept;
+    x: number;
+    y: number;
+    radius: number;
+    selected: boolean;
+    detailsVisible: boolean;
+    quadrant: number;
+    color: string;
+    isComposition: boolean;
+    parent: ConceptCircle | null;
+    isMoved: boolean;
+    childCount: number;
+    order: number;
+    ctx: null;
+    dataConnections: Connection[];
+    childrenConcepts: ConceptCircle[];
+    isGrouped: boolean;
+    canvas: any;
+    active: boolean;
+    constructor(concept: Concept, ctx: any);
+    realign(): void;
+    addDataConnections(connections: Connection[]): void;
+    setInPlace(newX: any, newY: any, ctx: any): void;
+    draw(ctx: any): void;
+    drawAsPerParent(): void;
+    drawNumber(ctx: any): void;
+    activate(): void;
+    select(): void;
+    makeComposition(): void;
+    showDetails(): Promise<void>;
+    getQuadrant(ctx: any): void;
+    checkWithAnotherConcept(conceptToCheck: ConceptCircle): boolean;
+}

package/dist/types/Visualize/ConceptCircleList.d.ts

@@ -0,0 +1,9 @@
+import { ConceptCircle } from "./ConceptCircle";
+export declare class ConceptCircleList {
+    static drawList: ConceptCircle[];
+    static addNewConceptCircle(conceptCircle: ConceptCircle): boolean;
+    static removeConceptCircle(conceptCircle: ConceptCircle): void;
+    static getConceptCircle(conceptId: number, ctx: any): Promise<ConceptCircle | undefined>;
+    static getConceptCircleFromList(conceptId: number): ConceptCircle | null;
+    static addConceptCircle(conceptId: number, ctx: any): Promise<ConceptCircle>;
+}

package/dist/types/Visualize/ConnectionLine.d.ts

@@ -0,0 +1,21 @@
+import { Connection, Concept } from "../app";
+import { ConceptCircle } from "./ConceptCircle";
+export declare class ConnectionLine {
+    concept: Concept;
+    ofConcept: ConceptCircle | undefined;
+    toConcept: ConceptCircle | undefined;
+    selected: boolean;
+    quadrant: number;
+    type: null;
+    id: number;
+    canvas: any;
+    ctx: any;
+    connection: Connection;
+    active: boolean;
+    constructor(connection: Connection, ctx: any);
+    updateConcept(connection: Connection): Promise<void>;
+    draw(ctx: any): void;
+    drawNumber(ctx: any): void;
+    activate(): void;
+    select(): void;
+}

package/dist/types/Visualize/ConnectionLineList.d.ts

@@ -0,0 +1,6 @@
+import { ConnectionLine } from "./ConnectionLine";
+export declare class ConnectionLineList {
+    static drawList: ConnectionLine[];
+    static addNewConnectionLine(connectionLine: ConnectionLine): void;
+    static removeConnectionLine(connectionLine: ConnectionLine): void;
+}

package/dist/types/Visualize/drawExistingConcepts.d.ts

@@ -0,0 +1,8 @@
+import { Connection } from "../app";
+export declare function printAllConcepts(ctx: any): Promise<void>;
+export declare function getLinkData(connection: Connection, ctx: any): Promise<void>;
+export declare function getLinkDataOf(connection: Connection, ctx: any): Promise<void>;
+export declare function printAllConceptsOfIdWithoutData(ctx: any, id: number): Promise<void>;
+export declare function printConcept(ctx: any, id: number): Promise<void>;
+export declare function printAllConceptsOfId(ctx: any, id: number): Promise<void>;
+export declare function checkIfExists(id: number, conceptIds: number[]): boolean;

package/dist/types/Visualize/helper.d.ts

@@ -0,0 +1,15 @@
+export declare function drawCircle(ctx: any, x: any, y: any, radius: any, color: any): void;
+export declare function drawTriangle(ctx: any, x: any, y: any, radius: any, color: any): void;
+export declare function drawLine(ctx: any, x1: any, y1: any, x2: any, y2: any, color: any): void;
+export declare function drawArrow(ctx: any, fromx: any, fromy: any, tox: any, toy: any, arrowWidth: any, color: any): void;
+export declare function drawArc(ctx: any, x1: any, y1: any, x2: any, y2: any, color: any): void;
+export declare function getMouseCoords(canvas: any, event: any): {
+    x: number;
+    y: number;
+};
+export declare function randomIntFromInterval(min: any, max: any): number;
+export declare function getOffsetCoords(mouse: any, conceptCircle: any): {
+    x: number;
+    y: number;
+};
+export declare function cursorInRect(mouseX: any, mouseY: any, rectX: any, rectY: any, radius: any): boolean;

package/dist/types/Widgets/BaseObserver.d.ts

@@ -0,0 +1,22 @@
+export declare class BaseObserver {
+    /**
+     * This is where the data of the widget needs to be stored.
+     */
+    data: any;
+    inDevelopment: boolean;
+    /**
+     * This is the subscribers of the data. If any thing on this widget changes then all the functions
+     * in the subscribers are called.
+     */
+    subscribers: any;
+    /**
+    * This is called by any data change. So that any data change will notify all the callback functions to execute.
+    */
+    notify(passedData?: any): void;
+    /**
+     * This function is used to register the callback into the function in case of any dataChange.
+     * @param callback sets this callback to the subscribers list in the widget. So that in any change we can call this callback
+     * @returns execution of the callback passed.
+     */
+    dataChange(callback: any): void;
+}

package/dist/types/Widgets/BaseWidget.d.ts

@@ -0,0 +1,24 @@
+import { BaseObserver } from "./BaseObserver";
+export declare class BaseWidget extends BaseObserver {
+    /**
+     * This is the element that is a copy of the element that is mounted.
+     */
+    element: HTMLElement | null;
+    /**
+     * This is a random identifier to the widget that is used to identify the widget and other elements
+     * inside of it.
+     */
+    elementIdentifier: number;
+    /**
+     * This flag is set to denote that that widget has been mounted
+     */
+    widgetMounted: boolean;
+    getComponent(): HTMLElement | null;
+    getElementById(identifier: string): HTMLElement | null;
+    /**
+     *
+     * @returns random number that will be used to put into the main widget div so that we can uniqely identify
+     * the widget and its children from others.
+     */
+    createWidgetWrapperIdentifier(): string;
+}

package/dist/types/Widgets/BuilderSpeceficFunctions.d.ts

@@ -0,0 +1,2 @@
+import { BuilderStatefulWidget } from "./BuilderStatefulWidget";
+export declare function TypeEditor(event: any, that: BuilderStatefulWidget): void;

package/dist/types/Widgets/BuilderStatefulWidget.d.ts

@@ -0,0 +1,42 @@
+import { StatefulWidget } from "./StatefulWidget";
+import { Concept } from "../app";
+import { TCustomFunction } from "../DataStructures/TypeLibrary";
+export declare class BuilderStatefulWidget extends StatefulWidget {
+    childComponents: any;
+    componentMounted: boolean;
+    oldHtml: HTMLElement | null;
+    onmountVal: any;
+    addEventVal: any;
+    phonebooks: any;
+    childrenData: any;
+    addEventFunction: any;
+    componentDidMountFunction: any;
+    mountChildWidgetsFunction: any;
+    childWidgets: any;
+    typeValueList: any;
+    widgetType: string;
+    parentConceptList: any;
+    customFunctions: TCustomFunction[];
+    widgetDependenciesData: string;
+    getUserId(): Promise<any>;
+    getTypeValueList(typeName?: string): Promise<unknown>;
+    setTitle(title: string): void;
+    getHtml(): string;
+    createRandomNumber(): number;
+    mount_child(): Promise<void>;
+    setProperty(widgetTypeName: any): Promise<this>;
+    createTypeEditor(event: any): void;
+    /**
+     *
+     * @param parent This is the function that creates a new div and then mounts the html element to the parent.
+     */
+    mount(parent: HTMLElement): Promise<void>;
+    render_widgetDependencies(): void;
+    render_custom_functions(): void;
+    /**
+     * This function will be called after the component mounts.
+     */
+    before_render(): void;
+    after_render(): void;
+    CreateConnectionBetweenEntityLocal(concept1Data: Concept, concept2Data: Concept, linker: string): Promise<string>;
+}

package/dist/types/Widgets/CacheWidget.service.d.ts

@@ -0,0 +1,17 @@
+export interface CacheStats {
+    cacheSize: number;
+    pendingRequests: number;
+    keys: string[];
+}
+export declare class DataCache<T = any> {
+    static cache: Map<string, any>;
+    static promises: Map<string, Promise<any>>;
+    static get<K>(key: string, fetcher: () => Promise<K>): Promise<K>;
+    static has(key: string): boolean;
+    static peek<K>(key: string): K | undefined;
+    static invalidate(key: string): void;
+    static clear(): void;
+    static set<K>(key: string, data: K): Promise<K>;
+    static stats(): CacheStats;
+}
+export declare function initWidgetCache(): DataCache<any>;

package/dist/types/Widgets/NormalizeStyles.service.d.ts

@@ -0,0 +1 @@
+export declare function normalizeCSS(cssString: string): Promise<string | null>;

package/dist/types/Widgets/RenderPage.service.d.ts

@@ -0,0 +1,12 @@
+/**
+ *
+ * @param pageData
+ */
+export declare function applyPageProperties(pageData: any): Promise<void>;
+/**
+ *
+ * @param property
+ * @param value
+ * @returns
+ */
+export declare function applyPageProperty(property: string, value: any): Promise<void>;

package/dist/types/Widgets/RenderWidgetLibrary.service.d.ts

@@ -0,0 +1,14 @@
+import { WidgetTree } from "./WidgetTree";
+export declare function initializeLibraries(widgetTree: WidgetTree): Promise<void>;
+/**
+ *
+ * @param cssClassName
+ * @returns
+ */
+export declare function removeCSSLibrariesFromHead(cssClassName: string): void;
+/**
+ *
+ * @param jsClassName
+ * @returns
+ */
+export declare function removeJSLibrariesFromHead(jsClassName: string): void;

package/dist/types/Widgets/RenderWidgetService.d.ts

@@ -0,0 +1,50 @@
+import { BuilderStatefulWidget, StatefulWidget, WidgetTree } from "../app";
+export declare function renderPage(pageId: number, attachNode: HTMLElement, props?: any, showDocumentation?: boolean): Promise<void>;
+export declare function importLatestWidget(widgetId: number, attachNode?: HTMLElement, props?: any, showDocumentation?: boolean): Promise<WidgetTree | undefined>;
+export declare function renderImportedWidget(widgetId: number, attachNode: HTMLElement, props?: any, showDocumentation?: boolean): Promise<BuilderStatefulWidget | undefined>;
+export declare function renderLatestWidget(widgetId: number, attachNode: HTMLElement, props?: any, showDocumentation?: boolean): Promise<BuilderStatefulWidget | undefined>;
+export declare function renderWidget(widgetId: number, attachNode: HTMLElement, props?: any, showDocumentation?: boolean): Promise<BuilderStatefulWidget | undefined>;
+export declare function materializeWidget(widgetId: number, bulkWidget: any, attachNode: HTMLElement, props?: any, showDocumentation?: boolean): Promise<BuilderStatefulWidget | undefined>;
+export declare function getWidgetFromId(widgetId: number, visitedWidgets?: number[], token?: string): Promise<WidgetTree>;
+/**
+ * This function builds a widget tree. This tree is built fully along with its children
+ * This tree can then be used to build the whole dom for the widget.
+ * This has recursive property so that the recursion can be used to build this tree.
+ * @param widgetId the id of the widget
+ * @returns WidgetTree.
+ */
+export declare function getWidgetBulkFromId(widgetId: number, visitedWidgets: number[] | undefined, bulkWidget: any, token?: string): Promise<WidgetTree>;
+/**
+ *
+ * @param tree Widget tree from getWidgetFromId(widgetId);
+ * @param parentElement this is the dom element on which we want to add our widget
+ * @returns the widgetree with widgets attached inside of it.
+ * Also this will add the tree to the dom.
+ */
+export declare function convertWidgetTreeToWidget(tree: WidgetTree, parentElement: HTMLElement, isMain?: boolean, props?: any, state?: any, parentWidget?: StatefulWidget | null): Promise<BuilderStatefulWidget>;
+export declare function makeShallow(input: any): any;
+/**
+*
+* @param tree Widget tree from getWidgetFromId(widgetId);
+* @param parentElement this is the dom element on which we want to add our widget
+* @returns the widgetree with widgets attached inside of it.
+* Also this will add the tree to the dom.
+*/
+export declare function convertWidgetTreeToWidgetWithWrapper(tree: WidgetTree, parentElement: HTMLElement, isMain?: boolean, state?: object, isInDevelopment?: boolean, parentWidget?: StatefulWidget | null): Promise<BuilderStatefulWidget>;
+export declare function unwrapContainers(parentElement: HTMLElement, selector: string): Promise<void>;
+/**
+ * Opens documentation modal
+ * @param widgetId
+ */
+export declare function openDocumentationPreviewModal(widgetId: number): Promise<void>;
+export declare function showWidgetDocumentation(widgetDocumentData: any, widgetId: number): Promise<void>;
+/**
+ * Opens modal
+ * @param modalId
+ */
+export declare function openModal(modalId: string): Promise<void>;
+/**
+ * Closes modal
+ * @param modalId
+ */
+export declare function closeModal(modalId: string): Promise<void>;

package/dist/types/Widgets/StatefulWidget.d.ts

@@ -0,0 +1,102 @@
+import { BaseWidget } from "./BaseWidget";
+/**
+ * Implementation of a widget system. If you need to create a widget that is compatible with the concept connection
+ * system them extend this class and populate the functions such as getHtml() and widgetDidMount()
+ */
+export declare class StatefulWidget extends BaseWidget {
+    params: any;
+    html: string;
+    css: string;
+    js: string;
+    state: {
+        [key: string]: any;
+    };
+    previousState: {
+        [key: string]: any;
+    };
+    /**
+     * These are the child widgets that need to be added to  this widget
+     */
+    childWidgets: any;
+    childWidgetElement: any;
+    parentWidget: any;
+    /**
+     * store widget state datas to pass through child widgets
+     */
+    widgetState: {
+        [key: string]: any;
+    };
+    /**
+     * This is the id of the parentElement of this widget.
+     */
+    parentElement: string;
+    querySelector(selector: string): Element | null;
+    querySelectorAll(selector: string): NodeListOf<Element> | null;
+    getElement(): HTMLElement | null;
+    setTitle(title: string): void;
+    /**
+     *
+     * @returns the html string that needs to be mounted to the DOM.
+     */
+    getHtml(): string;
+    /**
+     * This will help us update the data of the child widget. This will also call another function inside of the child widget
+     * called udpateWidget which the user can call after some data is udpated.
+     * @param value
+     * @param widget
+     */
+    UpdateChildData(value: any, widget: StatefulWidget): void;
+    /**
+     * This is called after the data has been udpated by some other component.
+     */
+    update(): void;
+    /**
+     *
+     * @param newState
+     */
+    setState(newState: any): void;
+    setStateProperty(newProperty: Object): void;
+    hasStateChanged(): boolean;
+    private isPropertyEqual;
+    /**
+     * If any child widgets are registered in the widget. Then without any other changes to the contents and state
+     * this loadChildWidgets will be called which will help the child widgets be rendered to their respective positions.
+     */
+    loadChildWidgets(): void;
+    /**
+     * This is the main function that adds the html of the component to the element.
+     * The element is the mounted widget
+     */
+    render(): void;
+    getElementByClassName(identifier: string): never[] | NodeListOf<Element>;
+    /**
+     * This is the function that needs to be called.
+     */
+    mount_child(): void;
+    /**
+     *
+     * @param parent This is the function that creates a new div and then mounts the html element to the parent.
+     */
+    mount(parent: HTMLElement): Promise<void>;
+    /**
+     * This function will be called after the component mounts.
+     */
+    before_render(): void;
+    /**
+     * This is called after the render function has been called. So this is used for the user functions to be added
+     * for the widget and its html element. User can add any logic here.
+     */
+    after_render(): void;
+    /**
+     * render child widgets
+     */
+    renderChildWidgets(): void;
+    /**
+     * save widget state data as key and value pair.
+     */
+    setWidgetState(key: string, value: any): void;
+    /**
+     * get the saved widget state from stateful widget
+     */
+    getWidgetState(key: string, defaultValue: any): object;
+}

package/dist/types/Widgets/WidgetBuild.d.ts

@@ -0,0 +1,4 @@
+export declare function BuildWidgetFromId(id: number): Promise<any>;
+export declare function BuildWidgetFromCache(id: number): Promise<any>;
+export declare function BuildWidgetFromIdForLatest(id: number): Promise<any>;
+export declare function GetWidgetForTree(data: any, id: number): any;

package/dist/types/Widgets/WidgetTree.d.ts

@@ -0,0 +1,29 @@
+import { TAssistant, TCustomFunction, TMainLibrary } from "../DataStructures/TypeLibrary";
+import { BuilderStatefulWidget } from "./BuilderStatefulWidget";
+export declare class WidgetTree {
+    id: number;
+    name: string;
+    html: string;
+    css: string;
+    js: string;
+    library: TMainLibrary;
+    assistant: TAssistant;
+    timestamp: string;
+    widgetId: number;
+    type: string;
+    clean: string;
+    after_render: string;
+    before_render: string;
+    custom_functions: TCustomFunction[];
+    update: string;
+    origin: number;
+    version: number;
+    mount_child: string;
+    children: WidgetTree[];
+    wrapper: string;
+    widget: BuilderStatefulWidget;
+    sChildId?: number;
+    isPublished?: boolean;
+    useLatest?: boolean;
+    dependency: string;
+}

package/dist/types/Widgets/mainView.class.d.ts

@@ -0,0 +1,6 @@
+export default class {
+    params: any;
+    constructor(params: any);
+    setTitle(title: string): void;
+    getHtml(): Promise<string>;
+}

package/dist/types/WrapperFunctions/DepenedencyObserver.d.ts

@@ -0,0 +1,73 @@
+/**
+ * This is the class that helps us observe anything that the function is doing
+ * This wrapper will allow all the concepts and connections to be tracked inside of the called function
+ * This function helps us manage state using the concept connection system.
+ */
+export declare class DependencyObserver {
+    subscribers: any[];
+    mainConcept: number;
+    compositionIds: number[];
+    conceptIds: number[];
+    internalConnections: number[];
+    reverse: number[];
+    linkers: number[];
+    newIds: number[];
+    dependency: number[];
+    isDataLoaded: boolean;
+    isUpdating: boolean;
+    data: any;
+    fetched: boolean;
+    format: number;
+    eventHandlers: {
+        [key: number]: (event: Event) => void;
+    };
+    /**
+     * This function will be called when there is a need to listen to a certain type of concept that will update
+     *  the ui.
+     * @param id this is the type id which needs to be tracked
+     */
+    listenToEventType(id: number): void;
+    /**
+     * This is the of the concept id that needs to be listened . If this is called. All the connections that are
+     * created with of the concepts id with this passed id then the event is fired.
+     *
+     * @param id Of the concept id that needs to be listened.
+     */
+    listenToEvent(id: number): void;
+    removeListenToEvent(id: number): void;
+    /**
+ * This is the of the concept id that needs to be listened . If this is called. All the connections that are
+ * created with of the concepts id with this passed id then the event is fired.
+ *
+ * @param id Of the concept id that needs to be listened.
+ */
+    listenToEventConnectionType(id: number, connectionType: number): void;
+    /**
+     * This function will bind the actual data to the widget or the function.
+     */
+    bind(): Promise<void>;
+    run(): Promise<void>;
+    update(): Promise<void>;
+    /**
+     *
+     * @param callback the function that needs to be called with the data.
+     * @returns returns the callback with this data as the state.
+     */
+    subscribe(callback: any): Promise<any>;
+    /**
+*
+*
+* @returns data
+*/
+    execute(): Promise<void>;
+    /**
+     *
+     * @param callback function that you need to remove from the subscribers list.
+     * @returns
+     */
+    unsubscribe(callback: any): number;
+    /**
+     * This function will call all the subscribers that are registered in this wrapper.
+     */
+    notify(): void;
+}

package/dist/types/WrapperFunctions/GetCompositionListObservable.d.ts

@@ -0,0 +1,19 @@
+import { DependencyObserver } from "./DepenedencyObserver";
+/**
+ * This wrapper will wrap the listing function and then allow users to return the list.
+ */
+export declare class GetCompositionListObservable extends DependencyObserver {
+    compositionName: string;
+    userId: number;
+    inpage: number;
+    page: number;
+    data: any;
+    startPage: number;
+    constructor(compositionName: string, userId: number, inpage: number, page: number, format: number);
+    bind(): Promise<any>;
+    build(): Promise<any>;
+}
+/**
+ * This function will give you the list of the concepts by composition name with a listener to any data change.
+ */
+export declare function GetCompositionListListener(compositionName: string, userId: number, inpage: number, page: number, format?: number): GetCompositionListObservable;

package/dist/types/WrapperFunctions/GetCompositionObservable.d.ts

@@ -0,0 +1,13 @@
+import { DependencyObserver } from "./DepenedencyObserver";
+export declare class GetCompositionObservable extends DependencyObserver {
+    id: number;
+    constructor(id: number, format?: number);
+    bind(): Promise<any>;
+    build(): Promise<any>;
+}
+/**
+ *
+ * @param id Id of the composition
+ * @returns composition of the id given in the json form.
+ */
+export declare function GetCompositionListener(id: number, format?: number): GetCompositionObservable;

package/dist/types/WrapperFunctions/GetLinkListObservable.d.ts

@@ -0,0 +1,28 @@
+import { SearchQuery, SearchStructure } from "../app";
+import { DependencyObserver } from "./DepenedencyObserver";
+export declare class GetLinkListObservable extends DependencyObserver {
+    searchQuery: SearchQuery[];
+    searchStructure: SearchStructure;
+    format: number;
+    mainCompositionIds: number[];
+    searchCharacter: string;
+    token: string;
+    constructor(searchStructure: SearchStructure, searchQuery: SearchQuery[], token: string, format?: number);
+    /**
+ * This function will be called when there is a need to listen to a certain type of concept that will update
+ *  the ui.
+ * @param id this is the type id which needs to be tracked
+ */
+    listenToEventType(id: number): void;
+    bind(): Promise<any>;
+    build(): Promise<any>;
+}
+/**
+ *
+ * @param id this is the id whose links need to be found
+ * @param linker this is the type connection that is connected to the mainConcept(id)
+ * @param inpage number of outputs that has to be displayed
+ * @param page the page which needs to be displayed as per the inpage parameter
+ * @param format the format in which the output should be displayed (NORMAL, DATAID,JUSTDATA,DATAIDDATE)
+ */
+export declare function GetLinkListListener(searchStructure: SearchStructure, searchQuery: SearchQuery[], token: string, format?: number): GetLinkListObservable;

package/dist/types/WrapperFunctions/GetLinkObservable.d.ts

@@ -0,0 +1,32 @@
+import { Connection } from "../app";
+import { DependencyObserver } from "./DepenedencyObserver";
+/**
+ * This is a class that will give you the observable for the links from a certain concept.
+ */
+export declare class GetLinkObservable extends DependencyObserver {
+    linker: string;
+    inpage: number;
+    page: number;
+    connections: Connection[];
+    data: any;
+    /**
+     *
+     * @param id this is the id whose links need to be found
+     * @param linker this is the type connection that is connected to the mainConcept(id)
+     * @param inpage number of outputs that has to be displayed
+     * @param page the page which needs to be displayed as per the inpage parameter
+     * @param format the format in which the output should be displayed (NORMAL, DATAID,JUSTDATA,DATAIDDATE)
+     */
+    constructor(id: number, linker: string, inpage: number, page: number, format: number);
+    bind(): Promise<any>;
+    build(): Promise<any>;
+}
+/**
+ *
+ * @param id this is the id whose links need to be found
+ * @param linker this is the type connection that is connected to the mainConcept(id)
+ * @param inpage number of outputs that has to be displayed
+ * @param page the page which needs to be displayed as per the inpage parameter
+ * @param format the format in which the output should be displayed (NORMAL, DATAID,JUSTDATA,DATAIDDATE)
+ */
+export declare function GetLinkListener(id: number, linker: string, inpage: number, page: number, format?: number): GetLinkObservable;

package/dist/types/WrapperFunctions/RecursiveSearchObservable.d.ts

@@ -0,0 +1,37 @@
+import { Connection, DependencyObserver } from "../app";
+declare class RecursiveSearchObservable extends DependencyObserver {
+    searchLinkers: string[];
+    searchText: string;
+    textSearch: string;
+    connections: Connection[];
+    externalConnectionIds: number[];
+    data: any;
+    /**
+     *
+     * @param id this is the id whose links need to be found
+     * @param linker this is the type connection that is connected to the mainConcept(id)
+     * @param inpage number of outputs that has to be displayed
+     * @param page the page which needs to be displayed as per the inpage parameter
+     * @param format the format in which the output should be displayed (RAW, undefined)
+     */
+    constructor(id: number, linkers: string[], textSearch?: string, format?: number);
+    /**
+     * This is the of the concept id that needs to be listened . If this is called. All the connections that are
+     * created with of the concepts id with this passed id then the event is fired.
+     *
+     * @param id Of the concept id that needs to be listened.
+     */
+    listenToEvent(id: number): void;
+    bind(): Promise<any>;
+    build(): Promise<any>;
+}
+/**
+ * Method to listen the changes in recursive search data
+ * @param id this is the id whose links need to be found
+ * @param linker this is the type connection that is connected to the mainConcept(id)
+ * @param inpage number of outputs that has to be displayed
+ * @param page the page which needs to be displayed as per the inpage parameter
+ * @param format the format in which the output should be displayed (RAW, undefined)
+ */
+export declare function RecursiveSearchListener(id: number, linkers: string[], searchText?: string, format?: number): RecursiveSearchObservable;
+export {};