mftsccs-browser 2.2.42-beta → 2.2.43-beta

package/dist/types/Api/GetConnections/GetConnectionsBetweenApi.d.ts

@@ -0,0 +1,40 @@
+import { FetchConnection } from "../../DataStructures/FetchConnection";
+/**
+ * Fetches connections matching the given criteria from POST /api/get-connection-between.
+ *
+ * Accepts an array so multiple independent queries can be resolved in one HTTP request.
+ * Each item in the array is resolved independently by the backend; results are returned
+ * in the same order with `connectionIds` and the resolved `typeId` populated.
+ *
+ * **Supported query permutations (per item):**
+ * 1. `ofTheConceptId` + `toTheConceptId` + `type` — connections between two specific concepts of that type
+ * 2. `ofTheConceptId` + `type`                    — all connections FROM a concept of that type
+ * 3. `toTheConceptId` + `type`                    — all connections TO a concept of that type
+ * 4. `typeId` + `isComposition: true`             — all internal connections of a composition
+ *
+ * Fields not relevant to the chosen permutation should be left at their zero/empty defaults.
+ * Use {@link buildFetchConnection} to build items without specifying every field manually.
+ *
+ * @param fetchConnections - Array of query objects; each item is resolved independently.
+ * @returns The same array with `connectionIds` and resolved `typeId` populated by the backend.
+ *          Returns an empty array on error (error is logged internally).
+ *
+ * @example
+ * // Single query — connections between two concepts
+ * const results = await GetConnectionsBetweenApi([
+ *     buildFetchConnection({ ofTheConceptId: 103927382, toTheConceptId: 103927389, type: "the_project_s_page" })
+ * ]);
+ * console.log(results[0].connectionIds); // [18161211]
+ *
+ * @example
+ * // Multiple queries in one request
+ * const results = await GetConnectionsBetweenApi([
+ *     buildFetchConnection({ ofTheConceptId: 103927382, type: "the_project_s_page" }),
+ *     buildFetchConnection({ typeId: 101490186, isComposition: true }),
+ * ]);
+ * const allIds = results.flatMap(r => r.connectionIds);
+ *
+ * @see {@link buildFetchConnection} for constructing query items without filling all defaults
+ * @see {@link FetchConnection} for the full field reference
+ */
+export declare function GetConnectionsBetweenApi(fetchConnections: FetchConnection[]): Promise<FetchConnection[]>;

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

@@ -82,6 +82,7 @@ export declare class BaseUrl {
     static getLatestWidgetData(): string;
     static getRecentWidgetData(): string;
     static getConnectionsByTypes(): string;
+    static GetConnectionsBetweenUrl(): string;
     static CreatePrototypeUrl(): string;
     static GetCachedImage(ImageName: string): string;
 }

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

@@ -0,0 +1,64 @@
+/**
+ * Request/response shape for the POST /api/get-connection-between endpoint.
+ *
+ * Use only the fields relevant to your query permutation and leave the rest at their
+ * zero/empty defaults. The backend resolves `typeId` from the `type` string when
+ * `typeId` is 0, so you never need to supply both.
+ *
+ * **Query permutations:**
+ * 1. `ofTheConceptId` + `toTheConceptId` + `type` — connections between two specific concepts of that type
+ * 2. `ofTheConceptId` + `type`                    — all connections FROM a concept of that type
+ * 3. `toTheConceptId` + `type`                    — all connections TO a concept of that type
+ * 4. `typeId` + `isComposition: true`             — all internal connections of a composition
+ *
+ * After the request, the backend populates `connectionIds` and the resolved `typeId`
+ * on each item and returns the same array.
+ */
+export interface FetchConnection {
+    /** Source concept ID. 0 means "not specified". */
+    ofTheConceptId: number;
+    /** Target concept ID. 0 means "not specified". */
+    toTheConceptId: number;
+    /** Resolved type concept ID. Set directly or leave 0 — backend resolves it from `type`. */
+    typeId: number;
+    /** Human-readable type string (e.g. "the_project_s_page"). Used when typeId is 0. */
+    type: string;
+    /** Legacy type string resolved relative to the source concept's type. Leave empty unless required. */
+    oldType: string;
+    /** When true, searches for connections in the reverse direction (toTheConceptId → ofTheConceptId). */
+    reverse: boolean;
+    /** When true, treats typeId as a composition ID and returns its internal connections. */
+    isComposition: boolean;
+    /** Populated by the backend after the request — the matching connection IDs. */
+    connectionIds: number[];
+}
+/**
+ * Input-only shape for building a FetchConnection query.
+ * Omits `connectionIds` since that is an output field populated by the backend.
+ */
+export type FetchConnectionQuery = Omit<FetchConnection, 'connectionIds'>;
+/**
+ * Builds a complete FetchConnection request object from a partial query,
+ * filling unspecified fields with their zero/empty defaults.
+ *
+ * Use this instead of constructing FetchConnection manually so you only
+ * need to specify the fields relevant to your query permutation.
+ *
+ * @param query - Partial query with only the fields you need.
+ * @returns A fully initialised FetchConnection ready to send to the API.
+ *
+ * @example
+ * // Between two concepts
+ * buildFetchConnection({ ofTheConceptId: 1, toTheConceptId: 2, type: "the_project_s_page" })
+ *
+ * @example
+ * // All connections from a concept
+ * buildFetchConnection({ ofTheConceptId: 1, type: "the_project_s_page" })
+ *
+ * @example
+ * // All internal connections of a composition
+ * buildFetchConnection({ typeId: 101490186, isComposition: true })
+ *
+ * @see {@link GetConnectionsBetweenApi} to send the built query to the backend
+ */
+export declare function buildFetchConnection(query: Partial<FetchConnectionQuery>): FetchConnection;

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

@@ -1,5 +1,48 @@
+/**
+ * Static key-value store for runtime configuration values.
+ *
+ * Used throughout the package for feature flags and settings that need to be
+ * readable anywhere without passing parameters down the call stack.
+ *
+ * **Built-in keys:**
+ * - `'enableCache'` — controls widget and query caching (default `true`).
+ *   Set via `init()` parameters or toggled at runtime. Checked on every
+ *   cache read/write in `QueryCacheManager` and `WidgetCacheManager`.
+ *
+ * @example
+ * // Disable cache at runtime
+ * Environments.setValue('enableCache', false)
+ *
+ * @example
+ * // Read with a default value (returned when key has never been set)
+ * const cacheOn = Environments.getValue('enableCache', true)
+ */
 export declare class Environments {
     static environments: Record<string, any>;
-    static getValue(key: string): any;
+    /**
+     * Retrieves a stored value by key.
+     *
+     * @param key - The key to look up.
+     * @param defaultValue - Value returned when the key has never been set. Defaults to `null`.
+     * @returns The stored value, or `defaultValue` if the key is absent.
+     *
+     * @example
+     * Environments.getValue('enableCache', true)   // true if never set
+     * Environments.getValue('myFlag', false)        // false if never set
+     */
+    static getValue(key: string, defaultValue?: any): any;
+    /**
+     * Stores a value under the given key. Overwrites any existing value.
+     * Takes effect immediately — the next call to `getValue` with the same key
+     * returns the new value.
+     *
+     * @param key - The key to store under.
+     * @param value - The value to store.
+     * @returns The `Environments` class itself for chaining.
+     *
+     * @example
+     * Environments.setValue('enableCache', false)
+     * Environments.setValue('myFlag', true).setValue('otherFlag', 42)
+     */
     static setValue(key: string, value: any): typeof Environments;
 }

package/dist/types/Services/Transaction/LocalTransaction.d.ts

@@ -1,8 +1,10 @@
 import { Concept, InnerActions } from "../../app";
+import { FetchConnectionQuery } from "../../DataStructures/FetchConnection";
 export declare class LocalTransaction {
     protected transactionId: string;
     actions: InnerActions;
     protected success: boolean;
+    protected pendingConnectionDeletions: number[];
     constructor();
     /**
      * Method to initialize the transactions for specified transaction
@@ -12,9 +14,6 @@ export declare class LocalTransaction {
      * Method to commi the created Transactions
      */
     commitTransaction(): Promise<void>;
-    /**
-   * Method to commi the created Transactions
-   */
     commitTransactionWithoutAuth(): Promise<void>;
     /**
      * Method to rollback all the tranctions occured
@@ -25,6 +24,79 @@ export declare class LocalTransaction {
      * @param concept Concept
      */
     protected markAction(): Promise<void>;
+    /**
+     * Deletions
+     */
+    /**
+     * Queries the backend for connections matching the given criteria and queues all
+     * returned connection IDs for bulk deletion when commitTransaction() is called.
+     *
+     * **Nothing is deleted until commitTransaction() is called.**
+     * Calling rollbackTransaction() discards the queue without touching the backend.
+     *
+     * Supported query permutations:
+     * 1. `ofTheConceptId` + `toTheConceptId` + `type` — connections between two specific concepts
+     * 2. `ofTheConceptId` + `type`                    — all connections FROM a concept of that type
+     * 3. `toTheConceptId` + `type`                    — all connections TO a concept of that type
+     * 4. `typeId` + `isComposition: true`             — all internal connections of a composition
+     *
+     * For multiple queries in one go use {@link DeleteConnectionsBetweenBulk} — it sends
+     * all queries in a single HTTP request.
+     *
+     * @param query - Partial FetchConnectionQuery with only the fields relevant to your permutation.
+     * @returns The connection IDs queued for deletion by this call.
+     *
+     * @example
+     * // Delete all connections of type "the_project_s_page" from concept 103927382
+     * const ids = await transaction.DeleteConnectionsBetween({
+     *     ofTheConceptId: 103927382,
+     *     type: "the_project_s_page"
+     * });
+     * await transaction.commitTransaction(); // deletion fires here
+     *
+     * @example
+     * // Delete connections between two specific concepts
+     * await transaction.DeleteConnectionsBetween({
+     *     ofTheConceptId: 103927382,
+     *     toTheConceptId: 103927389,
+     *     type: "the_project_s_page"
+     * });
+     *
+     * @example
+     * // Delete all internal connections of a composition
+     * await transaction.DeleteConnectionsBetween({
+     *     typeId: 101490186,
+     *     isComposition: true
+     * });
+     *
+     * @see {@link DeleteConnectionsBetweenBulk} for sending multiple queries in one HTTP request
+     * @see {@link commitTransaction} where the queued deletions are executed via bulk delete
+     */
+    DeleteConnectionsBetween(query: Partial<FetchConnectionQuery>): Promise<number[]>;
+    /**
+     * Same as {@link DeleteConnectionsBetween} but resolves multiple queries in a single
+     * HTTP request to POST /api/get-connection-between.
+     *
+     * Prefer this over looping DeleteConnectionsBetween — all queries go to the backend
+     * in one round trip, and all returned IDs are merged into the same pending-deletion queue.
+     * The actual deletion still fires as a single bulk call inside commitTransaction().
+     *
+     * @param queries - Array of partial FetchConnectionQuery objects, one per query permutation.
+     * @returns All connection IDs queued for deletion across every query in this call.
+     *
+     * @example
+     * // Three different queries → one HTTP request to get IDs → one bulk delete on commit
+     * await transaction.DeleteConnectionsBetweenBulk([
+     *     { ofTheConceptId: 103927382, type: "the_project_s_page" },
+     *     { ofTheConceptId: 103927382, type: "the_project_s_tag" },
+     *     { typeId: 101490186, isComposition: true },
+     * ]);
+     * await transaction.commitTransaction();
+     *
+     * @see {@link DeleteConnectionsBetween} for the single-query convenience wrapper
+     * @see {@link commitTransaction} where the queued deletions are executed via bulk delete
+     */
+    DeleteConnectionsBetweenBulk(queries: Partial<FetchConnectionQuery>[]): Promise<number[]>;
     /**
      * Concepts
      */

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

@@ -24,18 +24,24 @@ export declare class WidgetCacheManager {
     private static recentMap;
     /**
      * Loads all persisted widget cache data from IndexedDB into memory.
-     * Call this once during app initialization (e.g. in init() or initConceptConnection()).
+     * Called automatically during `init()` / `initConceptConnection()`.
      * Safe to call multiple times — just overwrites the Maps.
+     *
+     * Skips entirely when `Environments.getValue('enableCache', true)` is `false`,
+     * keeping all three maps empty so no stale data is ever served.
      */
     static init(): Promise<void>;
     /**
      * Retrieves cached widget data by widget ID (synchronous, from memory).
+     * Returns `null` when cache is disabled via `Environments.setValue('enableCache', false)`,
+     * causing `BuildWidgetFromId` to always fetch fresh from the backend.
      * @param id - The widget ID to look up
-     * @returns The cached data object, or null if not cached
+     * @returns The cached data object, or null if not cached or cache is disabled
      */
     static getWidget(id: number): any | null;
     /**
      * Stores widget data in memory and persists to IndexedDB in the background.
+     * No-ops when cache is disabled via `Environments.setValue('enableCache', false)`.
      * Skips if data is identical to what's already cached (dedup guard).
      * @param id - The widget ID
      * @param data - The widget data object to cache
@@ -48,13 +54,14 @@ export declare class WidgetCacheManager {
     static removeWidget(id: number): void;
     /**
      * Retrieves cached latest-version widget data (synchronous, from memory).
+     * Returns `null` when cache is disabled, causing a live backend fetch.
      * @param id - The origin widget ID
-     * @returns The cached data object, or null if not cached
+     * @returns The cached data object, or null if not cached or cache is disabled
      */
     static getLatest(id: number): any | null;
     /**
      * Stores latest-version widget data in memory and persists to IndexedDB.
-     * Skips if data is identical to what's already cached.
+     * No-ops when cache is disabled. Skips if data is identical to what's already cached.
      * @param id - The origin widget ID
      * @param data - The latest widget data to cache
      */
@@ -66,13 +73,14 @@ export declare class WidgetCacheManager {
     static removeLatest(id: number): void;
     /**
      * Retrieves cached recent-version widget data (synchronous, from memory).
+     * Returns `null` when cache is disabled, causing a live backend fetch.
      * @param id - The origin widget ID
-     * @returns The cached data object, or null if not cached
+     * @returns The cached data object, or null if not cached or cache is disabled
      */
     static getRecent(id: number): any | null;
     /**
      * Stores recent-version widget data in memory and persists to IndexedDB.
-     * Skips if data is identical to what's already cached.
+     * No-ops when cache is disabled. Skips if data is identical to what's already cached.
      * @param id - The origin widget ID
      * @param data - The recent widget data to cache
      */

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

@@ -26,8 +26,11 @@ export declare class QueryCacheManager {
     private static cacheMap;
     /**
      * Loads all persisted query cache data from IndexedDB into memory.
-     * Call this once during app initialization.
+     * Call this once during app initialization (handled automatically by `init()`).
      * Safe to call multiple times — just overwrites the Map.
+     *
+     * Skips entirely when `Environments.getValue('enableCache', true)` is `false`,
+     * which is set by the `enableCache` parameter passed to `init()`.
      */
     static init(): Promise<void>;
     /**
@@ -43,8 +46,11 @@ export declare class QueryCacheManager {
     /**
      * Retrieves cached query results by hash key (synchronous, from memory).
      *
+     * Returns `null` immediately when `Environments.getValue('enableCache', true)` is `false`,
+     * causing `FreeschemaQueryApi` to fall through to a live backend fetch.
+     *
      * @param hash - The SHA-256 hash of the query (from getHash)
-     * @returns The cached result data, or null if not found
+     * @returns The cached result data, or null if not found or cache is disabled
      */
     static get(hash: string): any | null;
     /**
@@ -54,6 +60,9 @@ export declare class QueryCacheManager {
      * what's already in memory, the write and event dispatch are both skipped.
      * This prevents infinite revalidation loops (set → event → fetch → set → ...).
      *
+     * No-ops entirely when `Environments.getValue('enableCache', true)` is `false`
+     * so neither memory nor IndexedDB is written to.
+     *
      * @param hash - The SHA-256 hash key for this query
      * @param data - The query result data to cache
      */

package/dist/types/app.d.ts

@@ -115,6 +115,8 @@ export { createFormFieldData } from './Validator/utils';
 export { BaseUrl } from './DataStructures/BaseUrl';
 export { StatefulWidget } from './Widgets/StatefulWidget';
 export { DeleteConnectionByType, DeleteConnectionByTypeBulk, GetAllTheConnectionsByTypeAndOfTheConcept } from './Services/DeleteConnectionByType';
+export { GetConnectionsBetweenApi } from './Api/GetConnections/GetConnectionsBetweenApi';
+export { FetchConnection, FetchConnectionQuery, buildFetchConnection } from './DataStructures/FetchConnection';
 export { FreeschemaQuery } from './DataStructures/Search/FreeschemaQuery';
 export { FreeschemaQueryApi } from './Api/Search/FreeschemaQueryApi';
 export { SchemaQueryListener, SchemaQuery } from './WrapperFunctions/SchemaQueryObservable';
@@ -283,6 +285,12 @@ declare function updateAccessToken(accessToken?: string, session?: any): void;
  *
  * @param parameters - Additional configuration parameters:
  *                    - logserver: string - Custom log server URL (default: "https://logdev.freeschema.com")
+ *                    - isPwa: boolean - Enable PWA offline persistence to IndexedDB (default: false)
+ *                    - enableCache: boolean - Enable/disable widget and FreeschemaQuery caching.
+ *                      When false, QueryCacheManager and WidgetCacheManager skip all reads and writes
+ *                      (memory and IndexedDB). Stored in Environments under key 'enableCache' so it
+ *                      can be read or changed at runtime via Environments.getValue/setValue.
+ *                      Default: true.
  *
  * @returns Promise<boolean> - Returns true if initialization succeeds, undefined if it fails.
  *         On failure, falls back to main thread operation and logs warnings.
@@ -351,6 +359,7 @@ declare function init(url?: string, aiurl?: string, accessToken?: string, nodeUr
 }, parameters?: {
     logserver?: string;
     isPwa?: boolean;
+    enableCache?: boolean;
 }, accessControlUrl?: string): Promise<true | undefined>;
 /**
  * Method to send message to the service worker from main thread

package/package.json

@@ -1,21 +1,24 @@
 {
   "name": "mftsccs-browser",
-  "version": "2.2.42-beta",
+  "version": "2.2.43-beta",
   "environment": "production",
   "description": "Full Pack of concept and connection system",
   "main": "dist/main.bundle.js",
   "types": "dist/types/app.d.ts",
   "files": [
     "dist",
-    "scripts",
-    "LICENSE",
+    "scripts/postinstall.js",
     "README.md",
     "package.json"
   ],
   "scripts": {
+    "generate-autocomplete-metadata": "node ./scripts/generate-autocomplete-metadata.cjs",
     "start": "npx webpack",
     "dev": "webpack --env NODE_ENV=development --mode development",
     "build": "webpack --config webpack.config.js",
+    "prebuild:wico": "npm run generate-autocomplete-metadata",
+    "build:wico": "webpack --config webpack.wico.config.js",
+    "postbuild:wico": "node ./scripts/create-wico-package.cjs",
     "postinstall": "node ./scripts/postinstall.js",
     "test": "jest"
   },
@@ -48,4 +51,4 @@
   "dependencies": {
     "ncp": "^2.0.0"
   }
-}
+}

package/dist/types/Api/GetAllConcepts.d.ts

@@ -1,11 +0,0 @@
-/**
- * Retrieves all concepts belonging to a specific user.
- * Fetches user's concepts from backend and caches them in ConceptsData.
- *
- * @param userId - ID of the user whose concepts to retrieve
- * @returns void - Updates ConceptsData cache with user's concepts
- *
- * @example
- * await GetAllUserConcepts(123); // Loads all concepts for user 123
- */
-export declare function GetAllUserConcepts(userId: number): Promise<void>;

package/dist/types/Api/GetAllConnections.d.ts

@@ -1,11 +0,0 @@
-/**
- * Retrieves all connections belonging to a specific user.
- * Fetches user's connections from backend and caches them in ConnectionData.
- *
- * @param userId - ID of the user whose connections to retrieve
- * @returns void - Updates ConnectionData cache with user's connections
- *
- * @example
- * await GetAllUserConnections(123); // Loads all connections for user 123
- */
-export declare function GetAllUserConnections(userId: number): Promise<void>;

package/dist/types/Api/GetAllPrefetchConnections.d.ts

@@ -1,12 +0,0 @@
-/**
- * Prefetches connections for a user with pagination.
- * Loads connections into local storage for improved performance.
- *
- * @param userId - ID of the user whose connections to prefetch
- * @param inpage - Number of connections per page
- * @returns void - Updates ConnectionData storage with prefetched connections
- *
- * @example
- * await GetAllPrefetchConnections(123, 50); // Prefetch 50 connections for user 123
- */
-export declare function GetAllPrefetchConnections(userId: number, inpage: number): Promise<void>;

package/dist/types/Api/Prototype/CreatePrototype.d.ts

@@ -1,14 +0,0 @@
-import { Prototype } from "../../DataStructures/Prototype/Prototype";
-/**
- * Creates a new prototype in the backend.
- * Prototypes serve as templates for creating similar concepts.
- *
- * @param prototype - Prototype object containing template definition
- * @returns Created Concept object representing the prototype, or undefined on error
- *
- * @example
- * const prototype = new Prototype();
- * prototype.name = "PersonTemplate";
- * const result = await CreatePrototypeApi(prototype);
- */
-export declare function CreatePrototypeApi(prototype: Prototype): Promise<any>;

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

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

package/dist/types/Drawing/ConceptDraw.d.ts

@@ -1 +0,0 @@
-export declare function DrawingLoop(): void;

package/dist/types/Drawing/ConceptEvents.d.ts

@@ -1 +0,0 @@
-export declare function selectConceptObject(mouse_x_coordinate: number, mouse_y_coordinate: number): import("../app").Concept | null;

package/dist/types/Services/CreateCharacterBinaryTreeFromData.d.ts

@@ -1,5 +0,0 @@
-/**
- * This function creates a binary character tree in the memory from which we can search for concepts using character key
- * This helps us in searching concept by character faster.
- */
-export declare function CreateCharacterBinaryTreeFromData(): Promise<void>;

package/dist/types/Services/CreateTypeTreeFromData.d.ts

@@ -1 +0,0 @@
-export declare function CreateTypeTreeFromData(): Promise<void>;

package/dist/types/Services/GenerateHexNumber.d.ts

@@ -1 +0,0 @@
-export declare function genHexString(len: number): number;

package/dist/types/Services/GetMaximumConnectionSyncTime.d.ts

@@ -1,2 +0,0 @@
-import { Connection } from "../DataStructures/Connection";
-export declare function GetMaximumConnectionSyncTime(connections: Connection[]): Date;

package/dist/types/Services/GetTheReferent.d.ts

@@ -1,2 +0,0 @@
-import { Concept } from "../DataStructures/Concept";
-export default function GetTheReferent(id: number, userId: number, referentId: number): Promise<Concept>;

package/dist/types/Services/Local/CreateLocalBinaryTypeTreeFromData.d.ts

@@ -1,9 +0,0 @@
-/**
- * Builds a binary search tree indexed by typeId for fast type-based concept lookup.
- *
- * Loads all local concepts from IndexedDB and organizes them into a binary tree
- * structure where each node is keyed by typeId. Enables O(log n) lookups by type.
- *
- * @throws Error if IndexedDB read or tree construction fails
- */
-export declare function CreateLocalBinaryTypeTreeFromData(): Promise<void>;

package/dist/types/Services/Local/CreateLocalCharacterBinaryTree.d.ts

@@ -1,9 +0,0 @@
-/**
- * Builds a binary search tree indexed by characterValue for fast text-based concept lookup.
- *
- * Loads all local concepts from IndexedDB and organizes them into a binary tree
- * structure where each node is keyed by characterValue. Enables O(log n) lookups by text.
- *
- * @throws Error if IndexedDB read or tree construction fails
- */
-export declare function CreateLocalCharacterBinaryTreeFromData(): Promise<void>;

package/dist/types/Services/PatchComposition.d.ts

@@ -1,2 +0,0 @@
-import { Concept } from "../DataStructures/Concept";
-export default function PatchComposition(ofConcept: Concept, MainConcept: Concept, toConcept: Concept): void;

package/dist/types/Services/Visualizations/VisualTree.d.ts

@@ -1,9 +0,0 @@
-import { Concept, Connection, LocalTransaction } from "../../app";
-export declare class VisualTree {
-    static concepts: Concept[];
-    static connections: Connection[];
-    static transactions: LocalTransaction[];
-    static setTransaction(transaction: LocalTransaction): void;
-    static renderVisualTree(): void;
-    static getLocalConcepts(): Promise<void>;
-}

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

@@ -1,27 +0,0 @@
-/**
- * Base view class for page-level components.
- *
- * Provides basic page functionality including title management and HTML generation.
- */
-export default class {
-    /** Parameters passed to the view */
-    params: any;
-    /**
-     * Creates a new view instance.
-     *
-     * @param params - Configuration parameters for the view
-     */
-    constructor(params: any);
-    /**
-     * Sets the browser document title.
-     *
-     * @param title - The new document title
-     */
-    setTitle(title: string): void;
-    /**
-     * Generates the HTML content for this view.
-     *
-     * @returns HTML string for the view
-     */
-    getHtml(): Promise<string>;
-}

package/dist/types/prototype/getPrototype.service.d.ts

@@ -1,2 +0,0 @@
-import { Prototype } from "../DataStructures/Prototype/Prototype";
-export declare function CreatePrototype(prototype: Prototype): Promise<any>;