mftsccs-node 0.2.3 → 0.2.4

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

@@ -1,27 +1,23 @@
 import { Concept } from "./Concept";
 export declare class Connection {
     id: number;
+    count: 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;
+    typeCharacter: string;
     localSyncTime: Date;
     isTemp: boolean;
     toUpdate: boolean;
+    applicationId: number;
     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);
+    ofConcept: Concept;
+    toConcept: Concept;
+    constructor(id: number | undefined, ofTheConceptId: number, toTheConceptId: number, userId: number, typeId: number, orderId: number, accessId: number);
 }

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

@@ -4,8 +4,10 @@ export declare class ConnectionBinaryTree {
     static connectionroot: ConnectionNode | null;
     static addNodeToTree(node: ConnectionNode): ConnectionNode | undefined;
     static addConnectionToTree(connection: Connection): void;
+    static traverse(): number | undefined;
     static waitForDataToLoad(): Promise<unknown>;
     static checkFlag(resolve: any): any;
     static removeNodeFromTree(id: number): Promise<void>;
-    static getNodeFromTree(id: number): Promise<ConnectionNode | null>;
+    static getNodeFromTree(id: number): Promise<ConnectionNode | null | undefined>;
+    static getConnectionListFromIds(ids: number[], connectionArray: Connection[], remainingIds: any): Promise<void>;
 }

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

@@ -10,6 +10,7 @@ export declare class ConnectionNode {
     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;
+    getMax(a: number, b: number): number;
     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;
@@ -18,6 +19,8 @@ export declare class ConnectionNode {
     getBalanceFactor(N: ConnectionNode | null): number;
     getFromNode(id: number, node: ConnectionNode | null): ConnectionNode | null;
     getCharacterFromNode(value: string, node: ConnectionNode | null): ConnectionNode | null;
+    checkIfIdsInNode(node: ConnectionNode | null, ids: number[], connectionArray: Connection[], remainingIds: any): void;
+    traverse(node: ConnectionNode | null): number;
     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/ConnectionOfNode.d.ts

@@ -0,0 +1,10 @@
+import { NodePrimitive } from "./NodePrimitive";
+export declare class ConnectionOfNode extends NodePrimitive {
+    key: string;
+    value: number[];
+    height: number;
+    leftNode: ConnectionOfNode | null;
+    rightNode: ConnectionOfNode | null;
+    constructor(key: any, value: number[], leftNode: ConnectionOfNode | null, rightNode: ConnectionOfNode | null);
+    addNode(passedNode: ConnectionOfNode, node: ConnectionOfNode | null, height: number): any;
+}

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

@@ -0,0 +1,24 @@
+import { Connection } from "../Connection";
+import { ConnectionOfNode } from "./ConnectionOfNode";
+/**
+ * This is a binary tree that is used to store the reference to the main connection of the concept.
+ */
+export declare class ConnectionOfTheTree {
+    static node: ConnectionOfNode | null;
+    static CreateCompositionKey(ofTheConceptId: number, typeId: number): number;
+    static GetConnectionByOfTheConceptAndTypeId(ofTheConceptId: number, typeId: number): any;
+    /**
+     * This function lets you add a connection by composite key with of the concept id and type id.
+     * This function checks if the connection already exists and then updates in the case that it does not
+     * If the connection of the concept id and type id combination is encountered first time then a node is created.
+     * @param connection connection that needs to be added.
+     */
+    static addConnection(connection: Connection): void;
+    /**
+     * This is a function to add the connectionNode to the existing tree
+     * @param connectionOfNode This is the node that needs to be added to the tree.
+     * @returns ConnectionOfNode
+     */
+    static addNodeToTree(connectionOfNode: ConnectionOfNode): Promise<ConnectionOfNode | null>;
+    static removeNodeFromTree(id: number): Promise<void>;
+}

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

@@ -0,0 +1,10 @@
+import { NodePrimitive } from "./NodePrimitive";
+export declare class ConnectionTypeNode extends NodePrimitive {
+    key: string;
+    value: number[];
+    height: number;
+    leftNode: ConnectionTypeNode | null;
+    rightNode: ConnectionTypeNode | null;
+    constructor(key: any, value: number[], leftNode: ConnectionTypeNode | null, rightNode: ConnectionTypeNode | null);
+    addNode(passedNode: ConnectionTypeNode, node: ConnectionTypeNode | null, height: number): any;
+}

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

@@ -1,13 +1,20 @@
 import { Connection } from "../../DataStructures/Connection";
-import { ConnectionNode } from "./ConnectionNode";
+import { ConnectionTypeNode } from "./ConnectionTypeNode";
 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 connectionTypeRoot: ConnectionTypeNode | null;
+    static CreateCompositionKey(typeId: number): number;
+    /**
+     * This is a function to add the connectionNode to the existing tree
+     * @param connectionOfNode This is the node that needs to be added to the tree.
+     * @returns ConnectionOfNode
+     */
+    static addNodeToTree(connectionOfNode: ConnectionTypeNode): Promise<ConnectionTypeNode | null>;
+    /**
+     * This function lets you add a connection by composite key with of the concept id and type id.
+     * This function checks if the connection already exists and then updates in the case that it does not
+     * If the connection of the concept id and type id combination is encountered first time then a node is created.
+     * @param connection connection that needs to be added.
+     */
     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[]>;
+    static GetConnectionByOfTheConceptAndTypeId(ofTheConceptId: number, typeId: number): any;
 }

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

@@ -0,0 +1,15 @@
+export declare class NodePrimitive {
+    key: string;
+    value: number[];
+    height: number;
+    leftNode: any | null;
+    rightNode: any | null;
+    constructor(key: any, value: number[], leftNode: NodePrimitive | null, rightNode: NodePrimitive | null);
+    getFromNode(id: any, node: any | null): any | null;
+    rightRotate(y: NodePrimitive | null): any;
+    leftRotate(x: NodePrimitive | null): any;
+    getHeight(node: NodePrimitive | null): number;
+    getBalanceFactor(N: NodePrimitive | null): number;
+    removeNode(passedNode: any | null, id: number): any;
+    inOrderSuccessor(root: any): any;
+}

package/dist/types/DataStructures/ConnectionByType/GetConnectionByType.d.ts

@@ -0,0 +1,4 @@
+export declare class GetConnectionsByTypes {
+    ofTheConceptId: number;
+    connectionTypes: string[];
+}

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

@@ -2,17 +2,25 @@ import { Connection } from "./Connection";
 export declare class ConnectionData {
     name: string;
     constructor();
+    static deletedConnections: number[];
     static connectionArray: Connection[];
     static connectionDictionary: Connection[];
     static CheckContains(connection: Connection): boolean;
     static AddConnectionToStorage(connection: Connection): void;
+    static AddNpConn(id: number): void;
+    static GetNpConn(id: number): boolean;
     static AddConnection(connection: Connection): void;
     static AddConnectionToMemory(connection: Connection): void;
     static AddToDictionary(connection: Connection): void;
     static RemoveConnection(connection: Connection): void;
+    static GetConnectionTypeOfTree(): void;
+    static GetConnectionByOfTheConceptAndType(ofTheConceptId: number, typeId: number): Promise<any>;
+    static GetConnectionByOfType(ofTheConceptId: number, typeId: number): any;
     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[]>;
+    static GetConnectionTypeTree(): import("./ConnectionBinaryTree/ConnectionTypeNode").ConnectionTypeNode | null;
+    static GetConnectionBulkData(ids: number[], connectionArray: Connection[], remainingIds: any): Promise<void>;
+    static GetConnection(id: number): Promise<any>;
+    static GetConnectionsOfCompositionLocal(id: number): Promise<any>;
+    static GetConnectionsOfConcept(id: number): Promise<any>;
     getName(): string;
 }

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

@@ -1,6 +1,7 @@
 import { Concept } from "../Concept";
 export declare class LConcept {
     id: number;
+    structureType: string;
     ghostId: number;
     userId: number;
     typeId: number;
@@ -8,14 +9,15 @@ export declare class LConcept {
     accessId: number;
     characterValue: string;
     typeCharacter: string;
-    entryTimeStamp: Date | string;
+    entryTimeStamp: Date;
     referentId: number;
-    updatedTimeStamp: Date | string;
+    updatedTimeStamp: Date;
     type: LConcept | null | void | Concept;
     isNew: boolean;
     isComposition: boolean;
     isTemp: boolean;
+    isSynced: 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);
+    constructor(id: number, userId: number, typeId: number, categoryId: number, accessId: number, characterValue: string, typeCharacter: string, isNew: boolean | undefined, entryTimeStamp: Date, updatedTimeStamp: Date, referentId: number);
     getType(): void;
 }

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

@@ -1,4 +1,4 @@
-import { LConcept } from "./LConcept";
+import { Concept } from "../Concept";
 export declare class LConnection {
     id: number;
     ghostId: number;
@@ -13,6 +13,6 @@ export declare class LConnection {
     localSyncTime: Date;
     isTemp: boolean;
     applicationId: number;
-    type: LConcept;
-    constructor(id: number | undefined, ofTheConceptId: number, toTheConceptId: number, typeId: number, orderId: number, accessId: number, applicationId?: number);
+    type: Concept;
+    constructor(id: number, ofTheConceptId: number, toTheConceptId: number, typeId: number, orderId: number, accessId: number);
 }

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

@@ -1,13 +1,13 @@
-import { LConcept } from "./LConcept";
+import { Concept } from "./../Concept";
 export declare class LNode {
     key: any;
-    value: LConcept;
+    value: Concept;
     leftNode: LNode | null;
     rightNode: LNode | null;
     currentNode: LNode | null;
     variants: LNode[];
     height: number;
-    constructor(key: any, value: LConcept, leftNode: LNode | null, rightNode: LNode | null);
+    constructor(key: any, value: Concept, 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;
@@ -18,8 +18,10 @@ export declare class LNode {
     getHeight(node: LNode | null): number;
     getBalanceFactor(N: LNode | null): number;
     getFromNode(id: number, node: LNode | null): LNode | null;
+    updateNodeSyncStatus(id: number, value: any, node: LNode | null): LNode | null;
     getCharacterFromNode(value: string, node: LNode | null): LNode | null;
     getFromNodeWithCharacterAndType(value: string, typeId: number, node: LNode | null): LNode | null;
+    getFromNodeWithCharacterAndCategory(value: string, categoryId: 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;

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

@@ -1,12 +1,13 @@
-import { LConcept } from "../../DataStructures/Local/LConcept";
+import { Concept } from "../../DataStructures/Concept";
 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 addConceptToTree(concept: Concept): void;
     static getNodeFromTree(value: string): LNode | null;
     static getCharacterAndTypeFromTree(value: string, typeId: number): Promise<LNode | null>;
+    static getCharacterAndCategoryFromTree(value: string, categoryId: number): Promise<LNode | null>;
     static removeConceptType(character: string, id: number): void;
 }

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

@@ -1,12 +1,13 @@
-import { LConcept } from "../../DataStructures/Local/LConcept";
+import { Concept } from "../../DataStructures/Concept";
 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 addConceptToTree(concept: Concept): 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 updateSyncStatus(id: number): LNode | null;
     static removeNodeFromTree(id: number): Promise<void>;
 }

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

@@ -1,13 +1,13 @@
-import { LConcept } from "../../DataStructures/Local/LConcept";
+import { Concept } from "../../DataStructures/Concept";
 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 addConceptToTree(concept: Concept): void;
     static removeConceptType(typeId: number, id: number): void;
     static getNodeFromTree(id: number): LNode | null;
-    static getTypeVariantsFromTree(typeId: number): LConcept[] | undefined;
+    static getTypeVariantsFromTree(typeId: number): Concept[] | undefined;
     static waitForDataToLoad(): Promise<unknown>;
     static checkFlag(resolve: any): any;
-    static getTypeVariantsFromTreeWithUserId(typeId: number, userId: number): Promise<LConcept[]>;
+    static getTypeVariantsFromTreeWithUserId(typeId: number, userId: number): Promise<Concept[]>;
 }

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

@@ -1,14 +1,21 @@
-import { LConcept } from "./../Local/LConcept";
+import { Concept } from "./../Concept";
 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[]>;
+    static localconceptsArray: Concept[];
+    static AddConcept(concept: Concept): void;
+    static AddPermanentConcept(concept: Concept): void;
+    static RemoveConcept(concept: Concept): Promise<void>;
+    static RemoveConceptById(conceptId: number): Promise<void>;
+    static AddConceptToMemory(concept: Concept): void;
+    static GetConcept(id: number): Promise<Concept>;
+    static UpdateConceptSyncStatus(id: number): Promise<void>;
+    static GetConceptByGhostId(id: number): Promise<Concept>;
+    static GetConceptByCharacter(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 ClearData(): Promise<void>;
     getName(): string;
 }

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

@@ -1,16 +1,20 @@
-import { LConnection } from "./LConnection";
+import { Connection } from "../Connection";
 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 connectionArray: Connection[];
+    static connectionDictionary: Connection[];
+    static CheckContains(connection: Connection): boolean;
+    static AddConnection(connection: Connection): void;
+    static AddConnectionToMemory(connection: Connection): void;
+    static AddToDictionary(connection: Connection): void;
+    static RemoveConnection(connection: Connection): void;
+    static RemoveConnectionById(connectionId: number): void;
+    static AddPermanentConnection(connection: Connection): void;
+    static GetConnection(id: number): Connection | null;
     static waitForDataToLoad(): Promise<unknown>;
     static checkFlag(resolve: any): any;
-    static GetConnectionsOfCompositionLocal(id: number): Promise<LConnection[]>;
+    static GetConnectionsOfCompositionLocal(id: number): Promise<Connection[]>;
+    static GetConnectionOfCompositionAndTypeLocal(typeId: number, ofTheConceptId: number): Promise<Connection[]>;
     getName(): string;
 }

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

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

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

@@ -0,0 +1,19 @@
+export declare class LocalId {
+    static localId: number;
+    static localConnectionId: number;
+    static ReservedLocalId: number[];
+    static ReservedConnectionId: number[];
+    static AddConceptId(id: any): void;
+    /**
+     *
+     * This function will get the local concept id from the indexdb
+     * @returns the local concept id
+     */
+    static getConceptId(): Promise<number>;
+    /**
+     *
+     * @param object This is the object that needs to be updated
+     */
+    static AddConnectionId(object: any): void;
+    static getConnectionId(): Promise<number>;
+}

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

@@ -1,14 +1,33 @@
-import { LConcept } from "./LConcept";
-import { LConnection } from "./LConnection";
+import { Concept } from "./../Concept";
+import { Connection } from "../Connection";
+import { InnerActions } from "../../app";
+type syncContainer = {
+    id: string;
+    data: InnerActions;
+    createdDate: string;
+};
 export declare class LocalSyncData {
-    static conceptsSyncArray: LConcept[];
-    static connectionSyncArray: LConnection[];
-    static CheckContains(concept: LConcept): boolean;
+    static conceptsSyncArray: Concept[];
+    static connectionSyncArray: Connection[];
+    static ghostIdMap: Map<any, any>;
+    static transactionCollections: syncContainer[];
+    static CheckContains(concept: Concept): 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 CheckContainsConnection(connection: Connection): boolean;
+    static AddConcept(concept: Concept): void;
+    static RemoveConcept(concept: Concept): void;
+    static SyncDataOnlineWithoutAuth(transactionId?: string, actions?: InnerActions, withAuth?: boolean): Promise<any>;
+    static SyncDataOnline(transactionId?: string, actions?: InnerActions, withAuth?: boolean): Promise<any>;
+    static ConvertGhostIdsInConnections(connectionArray: Connection[]): void;
+    static UpdateConceptListToIncludeRelatedConcepts(connectionArray: Connection[], conceptsArray: Concept[]): Promise<void>;
+    static AddConceptIfDoesNotExist(concept: Concept, conceptList?: Concept[]): void;
+    static CheckIfTheConceptIdExists(id: number, conceptList?: Concept[]): Concept;
+    static AddConnection(connection: Connection): void;
+    static RemoveConnection(connection: Connection): void;
+    static RemoveConnectionById(connectionId: number): void;
     static syncDataLocalDb(): Promise<string>;
+    static initializeTransaction(transactionId: string): Promise<any>;
+    static markTransactionActions(transactionId: string, actions: InnerActions): Promise<any>;
+    static rollbackTransaction(transactionId: string, actions: InnerActions): Promise<any>;
 }
+export {};

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

@@ -11,6 +11,7 @@ export declare class Node {
     addCurrentNode(passedNode: Node, node: Node | null): Node;
     addCurrentNodeType(passedNode: Node, node: Node | null): Node;
     addNode(passedNode: Node, node: Node | null, height: number): Node | null;
+    checkIfIdsInNode(node: Node | null, ids: number[], connectionArray: Concept[], remainingIds: any): void;
     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;

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

@@ -0,0 +1,19 @@
+import { Concept } from "../Concept";
+import { Connection } from "../Connection";
+import { PrototypeOption } from "./PrototypeOption";
+import { QuerySelector } from "./QuerySelector";
+export declare class Prototype {
+    prototype: string;
+    required: string[];
+    optional: string[];
+    field: string;
+    childPrototypes: Prototype[];
+    isCompositional: boolean;
+    options: PrototypeOption[];
+    isQueryType: boolean;
+    querySelector: QuerySelector | null;
+    concepts: Concept[];
+    connections: Connection[];
+    addedConcepts: Concept[];
+    addedConnections: Connection[];
+}

package/dist/types/DataStructures/Prototype/PrototypeOption.d.ts

@@ -0,0 +1,4 @@
+export declare class PrototypeOption {
+    type: string;
+    value: string;
+}

package/dist/types/DataStructures/Prototype/QuerySelector.d.ts

@@ -0,0 +1,4 @@
+export declare class QuerySelector {
+    filterType: string;
+    selector: string;
+}

package/dist/types/DataStructures/Search/FreeschemaQuery.d.ts

@@ -14,9 +14,10 @@ export declare class FreeschemaQuery {
     order: string;
     outputFormat: number;
     name: string;
+    filterAncestor: string;
     reverse: boolean;
     limit: boolean;
-    filterAncestor: string;
+    isSecure: boolean;
     includeInFilter: boolean;
     isOldConnectionType: boolean;
 }

package/dist/types/DataStructures/Search/SearchStructure.d.ts

@@ -6,4 +6,5 @@ export declare class SearchStructure {
     userId: number;
     inpage: number;
     page: number;
+    auth: boolean;
 }

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

@@ -13,4 +13,5 @@ export declare class SearchQuery {
     doFilter: boolean;
     filterSearches: FilterSearch[];
     selectors: string[];
+    ofCompositions: number[];
 }

package/dist/types/DataStructures/Security/TokenStorage.d.ts

@@ -1,4 +1,5 @@
 export declare class TokenStorage {
     static BearerAccessToken: string;
-    static JwtSecret: string;
+    static sessionId: number;
+    static setSession(sessionId: any): void;
 }

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

@@ -1,15 +1,8 @@
 import { Concept } from "./Concept";
 import { Connection } from "./Connection";
-import { InnerActions } from "./Transaction/Transaction";
-type syncContainer = {
-    id: string;
-    data: InnerActions;
-    createdDate: string;
-};
 export declare class SyncData {
     static conceptsSyncArray: Concept[];
     static connectionSyncArray: Connection[];
-    static transactionCollections: syncContainer[];
     static CheckContains(concept: Concept): boolean;
     static SyncDataDelete(id: number): void;
     static CheckContainsConnection(connection: Connection): boolean;
@@ -17,10 +10,5 @@ export declare class SyncData {
     static RemoveConcept(concept: Concept): void;
     static AddConnection(connection: Connection): void;
     static RemoveConnection(connection: Connection): void;
-    static SyncDataOnline(transactionId?: string): Promise<"done" | undefined>;
-    static initializeTransaction(transactionId: string): Promise<void>;
-    static markTransactionActions(transactionId: string, actions: InnerActions): Promise<void>;
-    static rollbackTransaction(transactionId: string, actions: InnerActions): Promise<void>;
-    static syncDataLocalDb(): Promise<string>;
+    static SyncDataOnline(): Promise<any>;
 }
-export {};

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

@@ -0,0 +1,19 @@
+export type TLibrary = {
+    order: number;
+    url: string;
+};
+export type TMainLibrary = {
+    css: TLibrary[];
+    js: TLibrary[];
+};
+export type TAssistant = {
+    id: string;
+    input: string;
+    type: string;
+};
+export type TCustomFunction = {
+    id?: number;
+    code: string;
+    name: string;
+    slug: string;
+};

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

@@ -0,0 +1,18 @@
+export declare class TypeNode {
+    key: any;
+    value: number[];
+    leftNode: TypeNode | null;
+    rightNode: TypeNode | null;
+    currentNode: TypeNode | null;
+    height: number;
+    constructor(key: any, value: number);
+    addType(node: TypeNode | null, key: number, value: number): TypeNode | null;
+    rightRotate(y: TypeNode | null): TypeNode | null;
+    leftRotate(x: TypeNode | null): TypeNode | null;
+    getHeight(node: TypeNode | null): number;
+    getBalanceFactor(N: TypeNode | null): number;
+    getFromNode(id: number, node: TypeNode | null): TypeNode | null;
+    removeNodeWithVariants(passedNode: TypeNode | null, key: any, conceptId: number): TypeNode | null;
+    countNodeBelow(root: TypeNode | null): number;
+    inOrderSuccessor(root: TypeNode): TypeNode;
+}

package/dist/types/DataStructures/User/UserBinaryTree.d.ts

@@ -1,15 +1,13 @@
-import { LConcept } from "../../DataStructures/Local/LConcept";
+import { Concept } from "../../DataStructures/Concept";
 import { UserNode } from "./UserNode";
-import { LConnection } from "../Local/LConnection";
 export declare class UserBinaryTree {
     static root: UserNode | null;
-    static compositeKey(userId: number, sessionId: number, randomizer?: number): string;
+    static compositeKey(userId: number, sessionId: number): string;
     static addNodeToTree(node: UserNode): UserNode | undefined;
     static waitForDataToLoad(): Promise<unknown>;
     static checkFlag(resolve: any): any;
-    static addConceptToTree(concept: LConcept, userId: number, sessionId?: number): void;
-    static addConnectionToTree(connection: LConnection, userId: number, sessionId?: number): void;
-    static getNodeFromTree(userId: number, sessionId: number, randomizer?: number): Promise<UserNode | null>;
-    static removeNodeFromTree(userId: number, sessionId?: number, randomizer?: number): Promise<void>;
+    static addConceptToTree(concept: Concept, userId: number, sessionId?: number): void;
+    static getNodeFromTree(userId: number, sessionId: number): Promise<UserNode | null>;
+    static removeNodeFromTree(userId: number, sessionId?: number): Promise<void>;
     static countNumberOfNodes(): number;
 }