mftsccs-node 0.0.56 → 0.0.57

package/dist/types/Constants/ApiConstants.d.ts

@@ -0,0 +1,23 @@
+export declare const config: {
+    BASE_URL: string;
+};
+export declare const BASE_URL: string;
+export declare const GetConceptUrl: string;
+export declare const GetConceptBulkUrl: string;
+export declare const GetAllConceptsOfUserUrl: string;
+export declare const GetAllConnectionsOfUserUrl: string;
+export declare const GetAllConnectionsOfCompositionUrl: string;
+export declare const GetAllConnectionsOfCompositionBulkUrl: string;
+export declare const GetConceptByCharacterValueUrl: string;
+export declare const GetConceptByCharacterAndTypeUrl: string;
+export declare const GetCharacterByCharacterUrl: string;
+export declare const GetAllConceptsByTypeUrl: string;
+export declare const GetAllConnectionsOfConceptUrl: string;
+export declare const GetAllAiData: string;
+export declare const GetReservedIdUrl: string;
+export declare const CreateTheTextDataUrl: string;
+export declare const CreateTheCharacterDataUrl: string;
+export declare const CreateTheConceptUrl: string;
+export declare const CreateTheConnectionUrl: string;
+export declare function changeBaseUrl(url: string): void;
+export declare function getBaseUrl(): string;

package/dist/types/Constants/FormatConstants.d.ts

@@ -0,0 +1,7 @@
+export declare const NORMAL = 1;
+export declare const DATAID = 2;
+export declare const JUSTDATA = 3;
+export declare const DATAIDDATE = 4;
+export declare const RAW = 5;
+export declare const ALLID = 6;
+export declare const LISTNORMAL = 7;

package/dist/types/DataStructures/BaseUrl.d.ts

@@ -0,0 +1,52 @@
+export declare class BaseUrl {
+    static BASE_URL: string;
+    static AI_URL: string;
+    static MQTT_URL: string;
+    static NODE_URL: string;
+    static MQTT_CONNECTION: any;
+    static GetConceptUrl(): string;
+    static GetConnectionUrl(): string;
+    static GetConceptBulkUrl(): string;
+    static GetConnectionBulkUrl(): string;
+    static GetAllConceptsOfUserUrl(): string;
+    static GetAllConnectionsOfUserUrl(): string;
+    static GetAllConnectionsOfCompositionUrl(): string;
+    static GetAllConnectionsOfCompositionBulkUrl(): string;
+    static GetConceptByCharacterValueUrl(): string;
+    static GetConceptByCharacterAndTypeUrl(): string;
+    static GetConceptByCharacterAndCategoryUrl(): string;
+    static GetConceptByCharacterAndCategoryDirectUrl(): string;
+    static GetCharacterByCharacterUrl(): string;
+    static GetAllConceptsByTypeUrl(): string;
+    static GetAllConnectionsOfConceptUrl(): string;
+    static GetAllConnectionsToConceptUrl(): string;
+    static GetAllAiData(): string;
+    static GetAllPrefetchConnectionsUrl(): string;
+    static GetAllLinkerConnectionOfConceptUrl(): string;
+    static GetAllLinkerConnectionToConceptUrl(): string;
+    static DeleteConceptUrl(): string;
+    static RecursiveSearchUrl(): string;
+    static SearchLinkMultipleAllApiUrl(): string;
+    static MakeTheNameInBackendUrl(): string;
+    static LoginUrl(): string;
+    static SignupUrl(): string;
+    static GetCompositionConnectionBetweenTwoConceptsUrl(): string;
+    static SearchCompositionsUrl(): string;
+    static SearchLinkMultipleAll(): string;
+    static CreateSessionId(): string;
+    static CreateSessionVisitUrl(): string;
+    static ViewInternalDataUrl(): string;
+    static SearchInternalWithAuthenticatedCcsUrl(): string;
+    static GetReservedIdUrl(): string;
+    static GetReservedConnectionIdUrl(): string;
+    static CreateTheTextDataUrl(): string;
+    static CreateTheCharacterDataUrl(): string;
+    static CreateTheConceptUrl(): string;
+    static CreateTheConnectionUrl(): string;
+    static CreateTheConnectionNewUrl(): string;
+    static MakeTheTypeConceptUrl(): string;
+    static DeleteTheConnectionUrl(): string;
+    static DeleteTheConnectionBulkUrl(): string;
+    static FreeschemaQueryUrl(): string;
+    static GetConceptConnectionByType(): string;
+}

package/dist/types/DataStructures/BinaryCharacterTree.d.ts

@@ -0,0 +1,16 @@
+import { Concept } from "../DataStructures/Concept";
+import { Node } from "./Node";
+export declare class BinaryCharacterTree {
+    static characterRoot: Node | null;
+    static waitForDataToLoad(): Promise<unknown>;
+    static checkFlag(resolve: any): any;
+    static addNodeToTree(node: Node): Promise<Node | null>;
+    static removeNodeByCharacter(character: string, id: number): Promise<void>;
+    static countNumberOfNodes(): number;
+    static addConceptToTree(concept: Concept): void;
+    static getNodeFromTree(value: string): Node | null;
+    static getNodeFromTreeUpdated(value: string): Node | null;
+    static getCharacterAndTypeFromTree(value: string, typeId: number): Promise<Node | null>;
+    static getCharacterAndCategoryFromTree(value: string, categoryId: number): Promise<Node | null>;
+    static removeConceptCharacter(id: number): void;
+}

package/dist/types/DataStructures/BinaryTree.d.ts

@@ -0,0 +1,12 @@
+import { Concept } from "../DataStructures/Concept";
+import { Node } from "./Node";
+export declare class BinaryTree {
+    static root: Node | null;
+    static addNodeToTree(node: Node): Node | undefined;
+    static waitForDataToLoad(): Promise<unknown>;
+    static checkFlag(resolve: any): any;
+    static addConceptToTree(concept: Concept): void;
+    static getNodeFromTree(id: number): Promise<Node | null>;
+    static removeNodeFromTree(id: number): Promise<void>;
+    static countNumberOfNodes(): number;
+}

package/dist/types/DataStructures/BinaryTypeTree.d.ts

@@ -0,0 +1,15 @@
+import { Concept } from "../DataStructures/Concept";
+import { Node } from "./Node";
+export declare class BinaryTypeTree {
+    static typeRoot: Node | null;
+    static addNodeToTree(node: Node): Promise<Node | null>;
+    static addConceptToTree(concept: Concept): void;
+    static removeTypeConcept(typeId: number, id: number): void;
+    static getNodeFromTree(id: number): Node | null;
+    static getTypeVariantsFromTree(typeId: number): Concept[] | undefined;
+    static waitForDataToLoad(): Promise<unknown>;
+    static checkFlag(resolve: any): any;
+    static getTypeVariantsFromTreeWithUserId(typeId: number, userId: number): Promise<Concept[]>;
+    static getTypeVariantsWithCharacterValue(characterValue: string, typeId: number): Promise<Concept>;
+    static countNumberOfNodes(): number;
+}

package/dist/types/DataStructures/CharacterRepository.d.ts

@@ -0,0 +1,8 @@
+import { TheCharacter } from "./TheCharacter";
+export declare class CharacterRepository {
+    name: string;
+    constructor();
+    static characterData: TheCharacter[];
+    static AddCharacter(character: TheCharacter): void;
+    static GetCharacter(value: string): TheCharacter;
+}

package/dist/types/DataStructures/Composition/Composition.d.ts

@@ -0,0 +1,14 @@
+import { Connection } from '../../DataStructures/Connection';
+import { Concept } from '../../DataStructures/Concept';
+export declare class Composition {
+    id: number;
+    mainConcept: Concept;
+    connections: Connection[];
+    concepts: Concept[];
+    subcompositions: number[];
+    cached: any;
+    updateCache(): Promise<void>;
+    UpdateAcrossDistributedSystem(): void;
+    isUpdating(): void;
+    GetDataCache(): any;
+}

package/dist/types/DataStructures/Composition/CompositionBinaryTree.d.ts

@@ -0,0 +1,10 @@
+import { Composition } from './Composition';
+import { CompositionNode } from './CompositionNode';
+export declare class CompositionBinaryTree {
+    static root: CompositionNode | null;
+    static addNodeToTree(node: CompositionNode): CompositionNode | undefined;
+    static addCompositionToTree(composition: Composition): void;
+    static getNodeFromTree(id: number): Promise<CompositionNode | null>;
+    static removeNodeFromTree(id: number): Promise<void>;
+    static countNumberOfNodes(): number;
+}

package/dist/types/DataStructures/Composition/CompositionNode.d.ts

@@ -0,0 +1,21 @@
+import { Composition } from './Composition';
+export declare class CompositionNode {
+    expiryTime: Date;
+    key: number;
+    value: Composition;
+    leftNode: CompositionNode | null;
+    rightNode: CompositionNode | null;
+    height: number;
+    constructor(key: number, value: Composition, leftNode: CompositionNode | null, rightNode: CompositionNode | null);
+    isValid(): boolean;
+    saveToCache(data: any): void;
+    addNode(passedNode: CompositionNode, node: CompositionNode | null, height: number): CompositionNode | null;
+    rightRotate(y: CompositionNode | null): CompositionNode | null;
+    leftRotate(x: CompositionNode | null): CompositionNode | null;
+    getHeight(node: CompositionNode | null): number;
+    getBalanceFactor(N: CompositionNode | null): number;
+    getFromNode(id: number, node: CompositionNode | null): CompositionNode | null;
+    removeNode(passedNode: CompositionNode | null, id: number): CompositionNode | null;
+    countNodeBelow(root: CompositionNode | null): number;
+    inOrderSuccessor(root: CompositionNode): CompositionNode;
+}

package/dist/types/DataStructures/Concept.d.ts

@@ -0,0 +1,29 @@
+export declare class Concept {
+    x: number;
+    y: number;
+    id: number;
+    ghostId: number;
+    userId: number;
+    typeId: number;
+    typeUserId: number;
+    categoryId: number;
+    categoryUserId: number;
+    referentId: number;
+    referentUserId: number;
+    characterValue: string;
+    securityId: number;
+    securityUserId: number;
+    accessId: number;
+    accessUserId: number;
+    sessionInformationId: number;
+    sessionInformationUserId: number;
+    entryTimeStamp: Date | string;
+    updatedTimeStamp: Date | string;
+    referent: Concept | null | void;
+    type: Concept | null | void;
+    isNew: boolean;
+    updateRecursion: boolean;
+    isTemp: boolean;
+    constructor(id: number, userId: number, typeId: number, typeUserId: number, categoryId: number, categoryUserId: number, referentId: number, referentUserId: number, characterValue: string, securityId: number, securityUserId: number, accessId: number, accessUserId: number, sessionId: number, sessionUserId: number, isNew: boolean | undefined, entryTimeStamp: Date | string, updatedTimeStamp: Date | string);
+    getType(): void;
+}

package/dist/types/DataStructures/ConceptData.d.ts

@@ -0,0 +1,25 @@
+import { Concept } from "./Concept";
+export declare class ConceptsData {
+    name: string;
+    constructor();
+    static conceptsArray: Concept[];
+    static NPC: number[];
+    static conceptDictionary: Concept[];
+    static CheckContains(concept: Concept): boolean;
+    static AddNpc(id: number): void;
+    static GetNpc(id: number): boolean;
+    static AddConceptToStorage(concept: Concept): void;
+    static AddConcept(concept: Concept): void;
+    static AddConceptToMemory(concept: Concept): void;
+    static AddConceptTemporary(concept: Concept): void;
+    static RemoveConcept(concept: Concept): void;
+    static GetConcept(id: number): Promise<Concept>;
+    static GetConceptByCharacter(characterValue: string): Promise<Concept>;
+    static GetConceptByCharacterUpdated(characterValue: string): Promise<Concept>;
+    static GetConceptByCharacterAndTypeLocal(character_value: string, typeId: number): Promise<Concept>;
+    static GetConceptByCharacterAndCategoryLocal(character_value: string, categoryId: number): Promise<Concept>;
+    static GetConceptsByTypeId(typeId: number): Concept[];
+    static GetConceptsByTypeIdAndUser(typeId: number, userId: number): Promise<Concept[]>;
+    static GetBinaryCharacterTree(): import("./Node").Node | null;
+    getName(): string;
+}

package/dist/types/DataStructures/ConceptsToDraw.d.ts

@@ -0,0 +1,11 @@
+import { Concept } from "./Concept";
+export declare class ConceptsToDraw {
+    name: string;
+    constructor();
+    static conceptsArray: Concept[];
+    static CheckContains(concept: Concept): boolean;
+    static AddConcept(concept: Concept): void;
+    static RemoveConcept(concept: Concept): void;
+    static GetConcept(id: number): Concept | null;
+    getName(): string;
+}

package/dist/types/DataStructures/Connection.d.ts

@@ -0,0 +1,27 @@
+import { Concept } from "./Concept";
+export declare class Connection {
+    id: number;
+    userId: number;
+    ghostId: number;
+    ofTheConceptId: number;
+    toTheConceptId: number;
+    ofTheConceptUserId: number;
+    toTheConceptUserId: number;
+    entryTimeStamp: Date | string;
+    terminationDateTime: Date;
+    typeId: number;
+    typeUserId: number;
+    orderId: number;
+    orderUserId: number;
+    securityId: number;
+    securityUserId: number;
+    accessId: number;
+    accessUserId: number;
+    sessionInformationId: number;
+    sessionInformationUserId: number;
+    localSyncTime: Date;
+    isTemp: boolean;
+    toUpdate: boolean;
+    type: Concept;
+    constructor(id: number | undefined, ofTheConceptId: number, toTheConceptId: number, ofTheConceptUserId: number, toTheConceptUserId: number, userId: number, typeId: number, typeUserId: number, orderId: number, orderUserId: number, securityId: number, securityUserId: number, accessId: number, accessUserId: number, sessionInformationId: number, sessionInformationUserId: number);
+}

package/dist/types/DataStructures/ConnectionBinaryTree/ConnectionBinaryTree.d.ts

@@ -0,0 +1,11 @@
+import { Connection } from "../../DataStructures/Connection";
+import { ConnectionNode } from "./ConnectionNode";
+export declare class ConnectionBinaryTree {
+    static connectionroot: ConnectionNode | null;
+    static addNodeToTree(node: ConnectionNode): ConnectionNode | undefined;
+    static addConnectionToTree(connection: Connection): void;
+    static waitForDataToLoad(): Promise<unknown>;
+    static checkFlag(resolve: any): any;
+    static removeNodeFromTree(id: number): Promise<void>;
+    static getNodeFromTree(id: number): Promise<ConnectionNode | null>;
+}

package/dist/types/DataStructures/ConnectionBinaryTree/ConnectionNode.d.ts

@@ -0,0 +1,24 @@
+import { Connection } from "./../Connection";
+export declare class ConnectionNode {
+    key: any;
+    value: Connection;
+    leftNode: ConnectionNode | null;
+    rightNode: ConnectionNode | null;
+    currentNode: ConnectionNode | null;
+    variants: ConnectionNode[];
+    height: number;
+    constructor(key: any, value: Connection, leftNode: ConnectionNode | null, rightNode: ConnectionNode | null);
+    addCurrentNode(passedNode: ConnectionNode, node: ConnectionNode | null): ConnectionNode;
+    addCurrentNodeType(passedNode: ConnectionNode, node: ConnectionNode | null): ConnectionNode;
+    addNode(passedNode: ConnectionNode, node: ConnectionNode | null, height: number): ConnectionNode | null;
+    addTypeNode(passedNode: ConnectionNode, node: ConnectionNode | null, height: number): ConnectionNode | null;
+    rightRotate(y: ConnectionNode | null): ConnectionNode | null;
+    leftRotate(x: ConnectionNode | null): ConnectionNode | null;
+    getHeight(node: ConnectionNode | null): number;
+    getBalanceFactor(N: ConnectionNode | null): number;
+    getFromNode(id: number, node: ConnectionNode | null): ConnectionNode | null;
+    getCharacterFromNode(value: string, node: ConnectionNode | null): ConnectionNode | null;
+    removeNode(passedNode: ConnectionNode | null, id: number): ConnectionNode | null;
+    removeNodeWithVariants(passedNode: ConnectionNode | null, typeIdentifier: any, conceptId: number): ConnectionNode | null;
+    inOrderSuccessor(root: ConnectionNode): ConnectionNode;
+}

package/dist/types/DataStructures/ConnectionBinaryTree/ConnectionTypeTree.d.ts

@@ -0,0 +1,13 @@
+import { Connection } from "../../DataStructures/Connection";
+import { ConnectionNode } from "./ConnectionNode";
+export declare class ConnectionTypeTree {
+    static connectionTypeRoot: ConnectionNode | null;
+    static addNodeToTree(node: ConnectionNode): Promise<ConnectionNode | null>;
+    static waitForDataToLoad(): Promise<unknown>;
+    static checkFlag(resolve: any): any;
+    static addConnectionToTree(connection: Connection): void;
+    static removeTypeConcept(typeId: number, id: number): void;
+    static getNodeFromTree(id: number): ConnectionNode | null;
+    static getTypeVariantsFromTree(typeId: number): Promise<Connection[] | undefined>;
+    static getTypeVariantsFromTreeWithUserId(typeId: number, userId: number): Promise<Connection[]>;
+}

package/dist/types/DataStructures/ConnectionData.d.ts

@@ -0,0 +1,18 @@
+import { Connection } from "./Connection";
+export declare class ConnectionData {
+    name: string;
+    constructor();
+    static connectionArray: Connection[];
+    static connectionDictionary: Connection[];
+    static CheckContains(connection: Connection): boolean;
+    static AddConnectionToStorage(connection: Connection): void;
+    static AddConnection(connection: Connection): void;
+    static AddConnectionToMemory(connection: Connection): void;
+    static AddToDictionary(connection: Connection): void;
+    static RemoveConnection(connection: Connection): void;
+    static GetConnectionTree(): import("./ConnectionBinaryTree/ConnectionNode").ConnectionNode | null;
+    static GetConnectionTypeTree(): import("./ConnectionBinaryTree/ConnectionNode").ConnectionNode | null;
+    static GetConnection(id: number): Promise<Connection>;
+    static GetConnectionsOfCompositionLocal(id: number): Promise<Connection[]>;
+    getName(): string;
+}

package/dist/types/DataStructures/Count/CountInfo.d.ts

@@ -0,0 +1,6 @@
+export declare class CountInfo {
+    conceptId: number;
+    connectionTypeId: number;
+    connectionType: string;
+    count: number;
+}

package/dist/types/DataStructures/FilterSearch.d.ts

@@ -0,0 +1,9 @@
+export declare class FilterSearch {
+    type: string;
+    search: string;
+    logicoperator: string;
+    index: number;
+    composition: boolean;
+    name: string;
+    operateon: string;
+}

package/dist/types/DataStructures/IdentifierFlags.d.ts

@@ -0,0 +1,11 @@
+export declare class IdentifierFlags {
+    static isTypeLoaded: boolean;
+    static isCharacterLoaded: boolean;
+    static isDataLoaded: boolean;
+    static isLocalDataLoaded: boolean;
+    static isLocalCharacterLoaded: boolean;
+    static isLocalTypeLoaded: boolean;
+    static isConnectionLoaded: boolean;
+    static isConnectionTypeLoaded: boolean;
+    static isLocalConnectionLoaded: boolean;
+}

package/dist/types/DataStructures/Local/LConcept.d.ts

@@ -0,0 +1,21 @@
+import { Concept } from "../Concept";
+export declare class LConcept {
+    id: number;
+    ghostId: number;
+    userId: number;
+    typeId: number;
+    categoryId: number;
+    accessId: number;
+    characterValue: string;
+    typeCharacter: string;
+    entryTimeStamp: Date | string;
+    referentId: number;
+    updatedTimeStamp: Date | string;
+    type: LConcept | null | void | Concept;
+    isNew: boolean;
+    isComposition: boolean;
+    isTemp: boolean;
+    applicationId: number;
+    constructor(id: number, userId: number, typeId: number, categoryId: number, accessId: number, characterValue: string, typeCharacter: string, isNew: boolean | undefined, entryTimeStamp: Date | string, updatedTimeStamp: Date | string, referentId: number, applicationId?: number);
+    getType(): void;
+}

package/dist/types/DataStructures/Local/LConnection.d.ts

@@ -0,0 +1,18 @@
+import { LConcept } from "./LConcept";
+export declare class LConnection {
+    id: number;
+    ghostId: number;
+    ofTheConceptId: number;
+    toTheConceptId: number;
+    entryTimeStamp: Date | string;
+    terminationDateTime: Date;
+    accessId: number;
+    typeId: number;
+    orderId: number;
+    typeCharacter: string;
+    localSyncTime: Date;
+    isTemp: boolean;
+    applicationId: number;
+    type: LConcept;
+    constructor(id: number | undefined, ofTheConceptId: number, toTheConceptId: number, typeId: number, orderId: number, accessId: number, applicationId?: number);
+}

package/dist/types/DataStructures/Local/LNode.d.ts

@@ -0,0 +1,27 @@
+import { LConcept } from "./LConcept";
+export declare class LNode {
+    key: any;
+    value: LConcept;
+    leftNode: LNode | null;
+    rightNode: LNode | null;
+    currentNode: LNode | null;
+    variants: LNode[];
+    height: number;
+    constructor(key: any, value: LConcept, leftNode: LNode | null, rightNode: LNode | null);
+    addCurrentNode(passedNode: LNode, node: LNode | null): LNode;
+    addCurrentNodeType(passedNode: LNode, node: LNode | null): LNode;
+    addNode(passedNode: LNode, node: LNode | null, height: number): LNode | null;
+    addCharacterNode(passedNode: LNode, node: LNode | null, height: number): LNode | null;
+    addTypeNode(passedNode: LNode, node: LNode | null, height: number): LNode | null;
+    rightRotate(y: LNode | null): LNode | null;
+    leftRotate(x: LNode | null): LNode | null;
+    getHeight(node: LNode | null): number;
+    getBalanceFactor(N: LNode | null): number;
+    getFromNode(id: number, node: LNode | null): LNode | null;
+    getCharacterFromNode(value: string, node: LNode | null): LNode | null;
+    getFromNodeWithCharacterAndType(value: string, typeId: number, node: LNode | null): LNode | null;
+    removeNode(passedNode: LNode | null, id: number): LNode | null;
+    removeNodeWithVariants(passedNode: LNode | null, typeIdentifier: any, conceptId: number): LNode | null;
+    countNodeBelow(root: LNode | null): number;
+    inOrderSuccessor(root: LNode): LNode;
+}

package/dist/types/DataStructures/Local/LocalBinaryCharacterTree.d.ts

@@ -0,0 +1,12 @@
+import { LConcept } from "../../DataStructures/Local/LConcept";
+import { LNode } from "./../Local/LNode";
+export declare class LocalBinaryCharacterTree {
+    static LocalCharacterRoot: LNode | null;
+    static waitForDataToLoad(): Promise<unknown>;
+    static checkFlag(resolve: any): any;
+    static addNodeToTree(node: LNode): Promise<LNode | null>;
+    static addConceptToTree(concept: LConcept): void;
+    static getNodeFromTree(value: string): LNode | null;
+    static getCharacterAndTypeFromTree(value: string, typeId: number): Promise<LNode | null>;
+    static removeConceptType(character: string, id: number): void;
+}

package/dist/types/DataStructures/Local/LocalBinaryTree.d.ts

@@ -0,0 +1,12 @@
+import { LConcept } from "../../DataStructures/Local/LConcept";
+import { LNode } from "./../Local/LNode";
+export declare class LocalBinaryTree {
+    static root: LNode | null;
+    static addNodeToTree(node: LNode): LNode | undefined;
+    static addConceptToTree(concept: LConcept): void;
+    static waitForDataToLoad(): Promise<unknown>;
+    static checkFlag(resolve: any): any;
+    static getNodeFromTree(id: number): Promise<LNode | null>;
+    static getCharacterAndTypeFromTree(value: string, typeId: number): LNode | null;
+    static removeNodeFromTree(id: number): Promise<void>;
+}

package/dist/types/DataStructures/Local/LocalBinaryTypeTree.d.ts

@@ -0,0 +1,13 @@
+import { LConcept } from "../../DataStructures/Local/LConcept";
+import { LNode } from "./LNode";
+export declare class LocalBinaryTypeTree {
+    static LocalTypeRoot: LNode | null;
+    static addNodeToTree(node: LNode): Promise<LNode | null>;
+    static addConceptToTree(concept: LConcept): void;
+    static removeConceptType(typeId: number, id: number): void;
+    static getNodeFromTree(id: number): LNode | null;
+    static getTypeVariantsFromTree(typeId: number): LConcept[] | undefined;
+    static waitForDataToLoad(): Promise<unknown>;
+    static checkFlag(resolve: any): any;
+    static getTypeVariantsFromTreeWithUserId(typeId: number, userId: number): Promise<LConcept[]>;
+}

package/dist/types/DataStructures/Local/LocalConceptData.d.ts

@@ -0,0 +1,14 @@
+import { LConcept } from "./../Local/LConcept";
+export declare class LocalConceptsData {
+    name: string;
+    constructor();
+    static localconceptsArray: LConcept[];
+    static AddConcept(concept: LConcept): void;
+    static AddConceptToMemory(concept: LConcept): void;
+    static GetConcept(id: number): Promise<LConcept>;
+    static GetConceptByCharacter(characterValue: string): Promise<LConcept>;
+    static GetConceptByCharacterAndTypeLocal(character_value: string, typeId: number): Promise<LConcept>;
+    static GetConceptsByTypeId(typeId: number): LConcept[];
+    static GetConceptsByTypeIdAndUser(typeId: number, userId: number): Promise<LConcept[]>;
+    getName(): string;
+}

package/dist/types/DataStructures/Local/LocalConnectionData.d.ts

@@ -0,0 +1,16 @@
+import { LConnection } from "./LConnection";
+export declare class LocalConnectionData {
+    name: string;
+    constructor();
+    static connectionArray: LConnection[];
+    static connectionDictionary: LConnection[];
+    static CheckContains(connection: LConnection): boolean;
+    static AddConnection(connection: LConnection): void;
+    static AddToDictionary(connection: LConnection): void;
+    static RemoveConnection(connection: LConnection): void;
+    static GetConnection(id: number): LConnection | null;
+    static waitForDataToLoad(): Promise<unknown>;
+    static checkFlag(resolve: any): any;
+    static GetConnectionsOfCompositionLocal(id: number): Promise<LConnection[]>;
+    getName(): string;
+}

package/dist/types/DataStructures/Local/LocalSyncData.d.ts

@@ -0,0 +1,14 @@
+import { LConcept } from "./LConcept";
+import { LConnection } from "./LConnection";
+export declare class LocalSyncData {
+    static conceptsSyncArray: LConcept[];
+    static connectionSyncArray: LConnection[];
+    static CheckContains(concept: LConcept): boolean;
+    static SyncDataDelete(id: number): void;
+    static CheckContainsConnection(connection: LConnection): boolean;
+    static AddConcept(concept: LConcept): void;
+    static RemoveConcept(concept: LConcept): void;
+    static AddConnection(connection: LConnection): void;
+    static RemoveConnection(connection: LConnection): void;
+    static syncDataLocalDb(): Promise<string>;
+}

package/dist/types/DataStructures/Node.d.ts

@@ -0,0 +1,29 @@
+import { Concept } from "./Concept";
+export declare class Node {
+    key: any;
+    value: Concept;
+    leftNode: Node | null;
+    rightNode: Node | null;
+    currentNode: Node | null;
+    variants: Node[];
+    height: number;
+    constructor(key: any, value: Concept, leftNode: Node | null, rightNode: Node | null);
+    addCurrentNode(passedNode: Node, node: Node | null): Node;
+    addCurrentNodeType(passedNode: Node, node: Node | null): Node;
+    addNode(passedNode: Node, node: Node | null, height: number): Node | null;
+    addCharacterNode(passedNode: Node, node: Node | null, height: number): Node | null;
+    addTypeNode(passedNode: Node, node: Node | null, height: number): Node | null;
+    rightRotate(y: Node | null): Node | null;
+    leftRotate(x: Node | null): Node | null;
+    getHeight(node: Node | null): number;
+    getBalanceFactor(N: Node | null): number;
+    getFromNode(id: number, node: Node | null): Node | null;
+    getCharacterFromNode(value: string, node: Node | null): Node | null;
+    getCharacterFromNodeUpdated(value: string, node: Node | null): Node | null;
+    getFromNodeWithCharacterAndType(value: string, typeId: number, node: Node | null): Node | null;
+    getFromNodeWithCharacterAndCategory(value: string, categoryId: number, node: Node | null): Node | null;
+    removeNode(passedNode: Node | null, id: number): Node | null;
+    removeNodeWithVariants(passedNode: Node | null, typeIdentifier: any, conceptId: number): Node | null;
+    countNodeBelow(root: Node | null): number;
+    inOrderSuccessor(root: Node): Node;
+}

package/dist/types/DataStructures/PatcherStructure.d.ts

@@ -0,0 +1,8 @@
+export declare class PatcherStructure {
+    compositionId: number;
+    userId: number;
+    sessionId: number;
+    accessId: number;
+    ofTheCompositionId: number;
+    patchObject: any;
+}

package/dist/types/DataStructures/ReferentInfo.d.ts

@@ -0,0 +1,7 @@
+export declare class ReferentInfo {
+    conceptDataId: number;
+    conceptDataUserId: number;
+    characterDataId: number;
+    characterDataUserId: number;
+    constructor(conceptDataId: number, conceptDataUserId: number, characterDataId: number, characterDataUserId: number);
+}

package/dist/types/DataStructures/ReservedIds.d.ts

@@ -0,0 +1,10 @@
+export declare class ReservedIds {
+    static ids: number[];
+    static getId(): Promise<number>;
+    static AddId(id: number): void;
+}
+export declare class ReservedConnectionIds {
+    static connectionIds: number[];
+    static getId(): Promise<number>;
+    static AddId(id: number): void;
+}