mftsccs-browser 2.1.242-dev → 2.1.244-dev

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

@@ -0,0 +1,47 @@
+/**
+ * Deletes a concept from local storage (IndexedDB).
+ *
+ * This function removes a concept from LocalConceptsData, effectively deleting it
+ * from the local IndexedDB cache. This is a local-only delete - it does NOT sync
+ * the deletion to the backend.
+ *
+ * **Important Notes:**
+ * - Only deletes from local storage (IndexedDB)
+ * - Does NOT delete from backend server
+ * - Does NOT automatically delete related connections
+ * - For full deletion including backend, use DeleteConceptById
+ * - Works with both negative (local) and positive (synced) IDs
+ *
+ * **Use Cases:**
+ * - Cleaning up local draft concepts
+ * - Removing concepts before they're synced
+ * - Local cache management
+ * - Testing and development
+ *
+ * **Process:**
+ * 1. Fetches the concept via GetTheConceptLocal
+ * 2. Removes it from LocalConceptsData
+ * 3. Updates IndexedDB
+ *
+ * @param id - The concept ID to delete (negative for local, positive for synced)
+ *
+ * @returns Promise that resolves when deletion is complete
+ *
+ * @example
+ * // Delete a local concept
+ * await DeleteConceptLocal(-12345);
+ * console.log("Local concept deleted");
+ *
+ * @example
+ * // Delete after checking existence
+ * const concept = await GetTheConceptLocal(-67890);
+ * if (concept.id !== 0) {
+ *   await DeleteConceptLocal(concept.id);
+ *   console.log("Deleted:", concept.characterValue);
+ * }
+ *
+ * @see {@link DeleteConceptById} for full deletion including backend
+ * @see {@link GetTheConceptLocal} for retrieving concepts before deletion
+ * @see {@link LocalConceptsData.RemoveConcept} for the underlying removal operation
+ */
+export declare function DeleteConceptLocal(id: number): Promise<any>;

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

@@ -0,0 +1,37 @@
+/**
+ * Retrieves all compositions of a specific type from local storage.
+ *
+ * **Process Flow**:
+ * 1. Finds the type concept by compositionName (e.g., "the_project")
+ * 2. Queries all concepts with that typeId belonging to the user
+ * 3. Fetches full composition for each concept
+ * 4. Returns array of complete compositions
+ *
+ * @param compositionName - The type name of compositions to retrieve (e.g., "the_project", "the_person")
+ * @param userId - User ID to filter compositions by ownership
+ * @returns Array of composition objects (empty array if type not found)
+ * @throws Error if lookup or composition fetching fails
+ *
+ * @example
+ * // Get all local projects for a user
+ * const projects = await GetCompositionListLocal("the_project", 101);
+ * // Returns: [{id: -1, data: {...}}, {id: -2, data: {...}}]
+ */
+export declare function GetCompositionListLocal(compositionName: string, userId: number): Promise<any>;
+/**
+ * Retrieves all compositions of a specific type with DATAID format (includes concept ID).
+ *
+ * Same as GetCompositionListLocal but returns compositions in data-id wrapper format,
+ * which includes both the composition data and its concept ID for easier reference.
+ *
+ * @param compositionName - The type name of compositions to retrieve
+ * @param userId - User ID to filter compositions by ownership
+ * @returns Array of composition objects in {id, data} format
+ * @throws Error if lookup or composition fetching fails
+ *
+ * @example
+ * // Get all local projects with IDs
+ * const projects = await GetCompositionListLocalWithId("the_project", 101);
+ * // Returns: [{id: -1, data: {the_name: "Project A"}}, {id: -2, data: {...}}]
+ */
+export declare function GetCompositionListLocalWithId(compositionName: string, userId: number): Promise<any>;

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

@@ -0,0 +1,97 @@
+/**
+ * Retrieves a complete composition structure from local storage (IndexedDB).
+ *
+ * This function fetches a composition using local-only data, building a hierarchical
+ * structure from local connections and concepts. If the concept has been synced to the
+ * backend, it can automatically fall back to fetching from the server.
+ *
+ * **Process:**
+ * 1. Fetches all local connections for the composition
+ * 2. Identifies all connected concept IDs
+ * 3. Retrieves the main concept from LocalConceptsData
+ * 4. If concept not found locally, checks if it's been synced (TranslateLocalToReal)
+ * 5. Falls back to server GetComposition if concept is synced
+ * 6. Recursively builds composition tree from local data
+ * 7. Organizes output by concept type
+ *
+ * **Local vs Server:**
+ * - Prioritizes local data (IndexedDB)
+ * - Automatic fallback to server if concept synced
+ * - Uses LocalConnectionData for connections
+ * - Uses LocalConceptsData for concepts
+ *
+ * **Output Format (JUSTDATA):**
+ * Returns an object keyed by the main concept's type:
+ * ```
+ * {
+ *   "Person": {
+ *     name: "Alice",
+ *     email: {...},
+ *     projects: {...}
+ *   }
+ * }
+ * ```
+ *
+ * @param id - The concept ID (can be negative for local or positive for synced)
+ *
+ * @returns Promise resolving to composition data organized by concept type
+ *
+ * @example
+ * // Get local composition
+ * const localComp = await GetCompositionLocal(-12345);
+ * console.log(localComp["Project"]);
+ * // Returns all data connected to this local project
+ *
+ * @example
+ * // Get synced concept (automatically falls back to server)
+ * const syncedComp = await GetCompositionLocal(-67890);
+ * // If concept synced to server, fetches from there
+ *
+ * @throws Re-throws errors for handling by caller
+ *
+ * @see {@link GetCompositionLocalWithId} for composition with ID and data wrapper
+ * @see {@link GetComposition} for server-only composition retrieval
+ * @see {@link recursiveFetchLocal} for the recursive building logic
+ */
+export declare function GetCompositionLocal(id: number): Promise<any>;
+/**
+ * Retrieves a local composition with ID and data wrapper (DATAID format).
+ *
+ * This is a variant of GetCompositionLocal that returns the composition data
+ * wrapped in an object that includes both the data and the concept ID. This format
+ * is useful for tracking which concept the data belongs to.
+ *
+ * **Output Format (DATAID):**
+ * ```
+ * {
+ *   data: {
+ *     "Person": {
+ *       name: "Alice",
+ *       email: {...}
+ *     }
+ *   },
+ *   id: 12345
+ * }
+ * ```
+ *
+ * **Differences from GetCompositionLocal:**
+ * - Returns { data, id } wrapper object
+ * - Same local data retrieval process
+ * - Same recursive building logic
+ * - No automatic server fallback
+ *
+ * @param id - The concept ID (negative for local, positive for synced)
+ *
+ * @returns Promise resolving to object with { data, id } structure
+ *
+ * @example
+ * const result = await GetCompositionLocalWithId(-12345);
+ * console.log(result.id);           // -12345
+ * console.log(result.data.Project); // Composition data
+ *
+ * @throws Re-throws errors for handling by caller
+ *
+ * @see {@link GetCompositionLocal} for standard format without ID wrapper
+ * @see {@link GetCompositionWithId} for server version
+ */
+export declare function GetCompositionLocalWithId(id: number): Promise<any>;

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

@@ -0,0 +1,56 @@
+import { Concept } from "../../app";
+/**
+ * Retrieves a local concept by character value with typeId=51 (standard type).
+ *
+ * Simple lookup in LocalConceptsData for concepts matching the character value
+ * and having typeId of 51.
+ *
+ * @param characterValue - The character value to search for
+ * @returns Concept matching the character and type, or empty concept if not found
+ */
+export default function GetConceptByCharacterLocal(characterValue: string): Promise<Concept>;
+/**
+ * Retrieves a local concept by character value, handling hierarchical type names.
+ *
+ * **Complex Logic**: For compound names (e.g., "the_person_email"):
+ * 1. Splits string by underscore
+ * 2. Recursively processes first part to get category ID
+ * 3. Searches using character value and derived category
+ * 4. Falls back to simple character search for single words
+ *
+ * **Special Case**: Returns concept with id=1 for character value "the".
+ *
+ * @param character - The character value to find (e.g., "the_status", "the_person_email")
+ * @returns Concept associated with the character value
+ *
+ * @example
+ * const concept = await GetConceptByCharacterAndCategoryLocal("the_person_email");
+ * // Splits into "the_person" (category) and searches with that context
+ */
+export declare function GetConceptByCharacterAndCategoryLocal(character: string): Promise<any>;
+/**
+ * Retrieves a concept by character value and category ID from local memory.
+ *
+ * Direct lookup in LocalConceptsData without server fallback.
+ *
+ * @param value - The character value to search for
+ * @param categoryId - The category ID to filter by
+ * @returns Concept matching the character and category, or empty concept if not found
+ */
+export declare function GetConceptByCategoryAndCharacterLocalMemory(value: string, categoryId: number): Promise<Concept>;
+/**
+ * Retrieves a concept by character value with automatic server fallback.
+ *
+ * **Complex Logic**:
+ * 1. First checks LocalConceptsData for existing concept
+ * 2. If not found (id==0 or null), fetches from server via GetLocalConceptByCharacterValue
+ * 3. After server fetch, rechecks LocalConceptsData (now populated)
+ * 4. Returns the concept or throws error
+ *
+ * Use this when you need guaranteed concept retrieval with server sync.
+ *
+ * @param characterValue - The character value to search for
+ * @returns Concept from local storage, fetching from server if needed
+ * @throws Error if server fetch fails
+ */
+export declare function GetConceptByCharacterLocalFull(characterValue: string): Promise<Concept>;

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

@@ -0,0 +1,19 @@
+import { Connection } from "../../app";
+/**
+ * Retrieves all connections originating from a specific concept with a given type.
+ *
+ * Searches local storage (IndexedDB) for connections where:
+ * - ofTheConceptId matches the provided concept ID
+ * - typeId matches the provided type
+ *
+ * @param ofTheConcept - The source concept ID (connections originating from this concept)
+ * @param typeId - The connection type ID to filter by
+ * @param userId - User ID (currently not used in filtering)
+ * @returns Array of Connection objects matching the criteria (empty array if none found)
+ * @throws Error if local storage query fails
+ *
+ * @example
+ * // Get all "has_property" connections from a person concept
+ * const connections = await GetConnectionOfTheConceptLocal(personId, 42, userId);
+ */
+export declare function GetConnectionOfTheConceptLocal(ofTheConcept: number, typeId: number, userId: number): Promise<Connection[]>;

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

@@ -0,0 +1,21 @@
+/**
+ * Retrieves all related compositions from local storage by relation name.
+ *
+ * **Process Flow (Complex Logic)**:
+ * 1. Converts relation string to type concept (e.g., "the_email" → type concept)
+ * 2. Finds all connections from source concept with that relation type
+ * 3. For each connection, retrieves the target composition
+ * 4. Returns array of all related compositions
+ *
+ * @param id - The source concept ID to get relations from
+ * @param relation - The relation name (e.g., "the_email", "the_address")
+ * @param userId - User ID for permissions
+ * @returns Array of composition objects representing related entities
+ * @throws Error if relation lookup or composition retrieval fails
+ *
+ * @example
+ * // Get all email addresses related to a person
+ * const emails = await GetRelationLocal(personId, "the_email", userId);
+ * // Returns: [emailComposition1, emailComposition2, ...]
+ */
+export declare function GetRelationLocal(id: number, relation: string, userId: number): Promise<any>;

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

@@ -0,0 +1,63 @@
+/**
+ * Retrieves a concept by ID with support for both local (virtual) and server concepts.
+ *
+ * This is the primary function for fetching concepts in offline/local mode. It intelligently
+ * handles three types of concept IDs and retrieves from appropriate sources:
+ *
+ * **ID Types Handled:**
+ * 1. **Negative IDs (Virtual/Local)**: Concepts created locally not yet synced
+ *    - Stored in LocalConceptsData (IndexedDB)
+ *    - Return negative IDs
+ *
+ * 2. **Synced Virtual IDs**: Originally local concepts now synced to backend
+ *    - Looked up via LocalGhostIdTree (maps negative to positive IDs)
+ *    - Returns positive (real) ID with ghostId reference
+ *
+ * 3. **Positive IDs (Server)**: Real backend concepts
+ *    - Fetched via GetTheConcept from backend
+ *    - Converted to LConcept format
+ *    - May have undefined ghostId
+ *
+ * **Retrieval Strategy:**
+ * - If id < 0: Check LocalConceptsData → Check LocalGhostIdTree
+ * - If id >= 0: Fetch from backend → Convert to LConcept
+ * - Routes through service worker if enabled
+ * - Returns default empty concept if not found
+ *
+ * **Ghost ID System:**
+ * - ghostId: Original negative ID (preserved after sync)
+ * - id: Current ID (negative if local, positive if synced)
+ * - LocalGhostIdTree maintains the mapping
+ *
+ * @param id - The concept ID to retrieve. Can be:
+ *            - Negative (e.g., -12345) for local-only concepts
+ *            - Positive (e.g., 789) for server concepts
+ *
+ * @returns Promise resolving to a Concept object in LConcept format.
+ *         Returns default concept (id=0) if not found.
+ *
+ * @example
+ * // Get a local concept (negative ID)
+ * const localConcept = await GetTheConceptLocal(-12345);
+ * console.log(localConcept.id); // -12345
+ * console.log(localConcept.characterValue); // "Draft Note"
+ *
+ * @example
+ * // Get a synced concept (originally local, now on server)
+ * const syncedConcept = await GetTheConceptLocal(-12345);
+ * console.log(syncedConcept.id); // 789 (now positive, synced)
+ * console.log(syncedConcept.ghostId); // -12345 (original ID preserved)
+ *
+ * @example
+ * // Get a server concept
+ * const serverConcept = await GetTheConceptLocal(456);
+ * console.log(serverConcept.id); // 456
+ * // Converted to LConcept format for consistency
+ *
+ * @throws Logs errors but returns default concept instead of throwing
+ *
+ * @see {@link CreateTheConceptLocal} for creating local concepts
+ * @see {@link GetTheConcept} for fetching server concepts only
+ * @see {@link convertFromConceptToLConcept} for format conversion
+ */
+export declare function GetTheConceptLocal(id: number): Promise<any>;

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

@@ -0,0 +1,22 @@
+import { InnerActions } from "../../app";
+/**
+ * Gets or creates a local concept - implements get-or-create pattern.
+ *
+ * Checks LocalConceptsData for existing concept matching referent and typeId.
+ * If found, returns existing concept. If not found, creates new local concept.
+ *
+ * **Special Case**: If typeCharacter is "the", sets categoryId to 1 (system category).
+ *
+ * @param referent - The character value/name of the concept
+ * @param typeCharacter - Type name string (e.g., "the_name")
+ * @param userId - User ID creating the concept
+ * @param categoryId - Category classification ID
+ * @param typeId - Type classification ID
+ * @param actions - Action tracking for batch operations
+ * @returns Existing or newly created Concept
+ *
+ * @example
+ * const concept = await MakeTheConceptLocal("Active", "the_status", 101, 1, 5);
+ * // Returns existing "Active" status or creates new one
+ */
+export default function MakeTheConceptLocal(referent: string, typeCharacter: string, userId: number, categoryId: number, typeId: number, actions?: InnerActions): Promise<any>;

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

@@ -0,0 +1,164 @@
+import { InnerActions } from "../../Constants/general.const";
+/**
+ * Creates or retrieves an instance concept locally - the core building block of the concept-connection system.
+ *
+ * This is THE fundamental function for creating concepts in local storage. It implements an intelligent
+ * get-or-create pattern that checks for existing concepts before creating new ones, preventing duplicates
+ * while supporting both unique instances and composition concepts.
+ *
+ * **Core Behaviors:**
+ * 1. **Composition Mode (composition=true)**: Always creates a new concept
+ *    - Used for containers/objects that need unique instances
+ *    - Marks concept with isComposition flag
+ *    - Example: Each "Project" is unique, even with same name
+ *
+ * 2. **Instance Mode (composition=false)**: Get-or-create pattern
+ *    - Checks if concept with same type and value exists
+ *    - Returns existing if found (deduplication)
+ *    - Creates new only if not found
+ *    - Example: "Published" status concept reused across items
+ *
+ * 3. **Long Text Handling**: Values >255 characters always create new
+ *    - Prevents expensive lookups on large text
+ *    - Each long text gets unique concept
+ *
+ * **Type String Processing:**
+ * - **Best Practice**: Always pass type with "the_" prefix (e.g., "the_name", "the_email")
+ * - Auto-correction: If missing, "the_" is automatically added internally
+ *   - "name" → "the_name" (auto-corrected)
+ *   - "email" → "the_email" (auto-corrected)
+ *   - "the_status" → "the_status" (already correct)
+ * - Creates type concept if it doesn't exist
+ * - **Recommendation**: Use explicit "the_" prefix for code clarity and consistency
+ *
+ * **Sync and Storage:**
+ * - Adds concept to LocalSyncData queue for backend sync
+ * - Stores in LocalConceptsData (IndexedDB)
+ * - Tracks in actions parameter for batch operations
+ * - Assigns negative ID (virtual/local)
+ *
+ * **Process Flow:**
+ * 1. Normalizes type string (adds "the_" prefix)
+ * 2. Creates/retrieves type concept via MakeTheTypeConceptLocal
+ * 3. If composition=true: Creates new concept immediately
+ * 4. If referent length >255: Creates new concept
+ * 5. If regular instance: Checks for existing by type+value
+ * 6. Returns existing or creates new
+ * 7. Attaches type information
+ * 8. Adds to sync queue
+ *
+ * @param type - The type/key of the concept. **Should follow the format "the_xyz"**.
+ *              Represents what kind of data this is.
+ *              Examples: "the_name", "the_email", "the_status", "the_first_name"
+ *
+ *              **Note**: If you pass without "the_" prefix (e.g., "name"), the code will
+ *              automatically add it internally (becomes "the_name"). However, best practice
+ *              is to always include the "the_" prefix for clarity and consistency.
+ *
+ * @param referent - The actual value/content of the concept.
+ *                  The human-readable data (e.g., "Alice", "alice@example.com", "Active").
+ *                  Can be empty string for composition concepts.
+ *
+ * @param composition - Boolean flag determining creation behavior.
+ *                     - true: Always creates new concept (unique instances)
+ *                     - false: Get-or-create pattern (reuses existing)
+ *                     Defaults to false.
+ *
+ * @param userId - The ID of the user creating this concept. Used for ownership and permissions.
+ *
+ * @param accessId - Access control level. Typically 4 (default internal access).
+ *                  Controls who can view/modify this concept.
+ *
+ * @param sessionInformationId - Session identifier for tracking. Defaults to 999 (system).
+ *                              Used for audit logging and session management.
+ *
+ * @param referentId - Optional reference to another concept ID.
+ *                    Used when this concept is an instance of or refers to another concept.
+ *                    Defaults to 0 (no reference).
+ *
+ * @param actions - Action tracking object that accumulates all created concepts and connections.
+ *                 Used for batch operations, rollback, and sync management.
+ *                 Structure: { concepts: Concept[], connections: Connection[] }
+ *
+ * @returns Promise resolving to the created or retrieved Concept object with:
+ *         - Negative ID if newly created locally
+ *         - Attached type information (concept.type)
+ *         - All standard concept properties
+ *
+ * @example
+ * // Create a reusable status concept (get-or-create)
+ * const status = await MakeTheInstanceConceptLocal(
+ *   "the_status",       // type (with "the_" prefix - best practice)
+ *   "Active",           // value
+ *   false,              // not composition - will reuse if exists
+ *   101,                // userId
+ *   4,                  // accessId
+ *   999,                // sessionId
+ *   0                   // no referent
+ * );
+ * // First call creates, subsequent calls return same concept
+ *
+ * @example
+ * // Create a composition concept (always new)
+ * const project = await MakeTheInstanceConceptLocal(
+ *   "the_project",      // type (with "the_" prefix)
+ *   "Project Alpha",    // value
+ *   true,               // composition - always creates new
+ *   101,
+ *   4,
+ *   999,
+ *   0
+ * );
+ * // Each project is unique, even with same name
+ * console.log(project.isComposition); // true
+ *
+ * @example
+ * // Type prefix is added automatically if missing (but prefer explicit)
+ * const email = await MakeTheInstanceConceptLocal(
+ *   "email",            // Missing "the_" - will become "the_email" internally
+ *   "alice@example.com",
+ *   false,
+ *   101, 4
+ * );
+ * console.log(email.typeCharacter); // "the_email" (auto-prefixed)
+ *
+ * // RECOMMENDED: Always include "the_" prefix explicitly
+ * const emailBetter = await MakeTheInstanceConceptLocal(
+ *   "the_email",        // Explicit prefix - clearer and more consistent
+ *   "bob@example.com",
+ *   false,
+ *   101, 4
+ * );
+ *
+ * @example
+ * // Long text always creates new concept
+ * const longDescription = "Lorem ipsum...".repeat(100); // >255 chars
+ * const concept = await MakeTheInstanceConceptLocal(
+ *   "the_description",  // type with "the_" prefix
+ *   longDescription,
+ *   false,              // Even with false, creates new due to length
+ *   101, 4
+ * );
+ *
+ * @example
+ * // Track actions for batch operations
+ * const actions = { concepts: [], connections: [] };
+ * await MakeTheInstanceConceptLocal("the_name", "Alice", false, 101, 4, 999, 0, actions);
+ * await MakeTheInstanceConceptLocal("the_email", "alice@ex.com", false, 101, 4, 999, 0, actions);
+ * console.log(actions.concepts.length); // 2 (plus any type concepts created)
+ *
+ * @example
+ * // Deduplication in action
+ * const status1 = await MakeTheInstanceConceptLocal("the_status", "Published", false, 101, 4);
+ * const status2 = await MakeTheInstanceConceptLocal("the_status", "Published", false, 101, 4);
+ * console.log(status1.id === status2.id); // true - same concept reused
+ *
+ * @throws Logs errors and re-throws for handling by caller.
+ *        Common issues: Type concept creation failures, IndexedDB errors.
+ *
+ * @see {@link CreateTheConceptLocal} for the underlying creation function
+ * @see {@link MakeTheTypeConceptLocal} for type concept creation/retrieval
+ * @see {@link LocalConceptsData.GetConceptByCharacterAndTypeLocal} for existence check
+ * @see {@link LocalSyncData.AddConcept} for sync queue management
+ */
+export declare function MakeTheInstanceConceptLocal(type: string, referent: string, composition: boolean | undefined, userId: number, accessId: number, sessionInformationId?: number, referentId?: number, actions?: InnerActions): Promise<any>;

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

@@ -0,0 +1,36 @@
+import { Concept } from "../../DataStructures/Concept";
+import { InnerActions } from "../../Constants/general.const";
+/**
+ * Creates or retrieves a type concept locally - handles hierarchical type system.
+ *
+ * Type concepts are placeholders/templates (e.g., "the_first_name", "the_email") that define
+ * what kind of data a concept represents. They have no actual value themselves.
+ *
+ * **Hierarchical Processing (Complex Logic)**:
+ * - Single word (e.g., "status"): Creates simple type concept with typeId=51
+ * - Compound words (e.g., "the_person_email"): Splits into parts and creates hierarchy:
+ *   1. Creates category concept from first part ("the_person")
+ *   2. Creates type concept from second part ("email")
+ *   3. Creates final concept with category and type linked
+ *   **Uses recursion** to build multi-level type hierarchies
+ *
+ * Always checks for existing type concept before creating to prevent duplicates.
+ *
+ * @param typeString - The type name to create (e.g., "the_status", "the_person_email")
+ * @param sessionId - Session identifier (typically 999)
+ * @param sessionUserId - Session user ID (typically 999, not used)
+ * @param userId - User creating the type concept
+ * @param actions - Action tracking for batch operations
+ * @returns Type Concept (existing or newly created)
+ *
+ * @example
+ * // Simple type
+ * const statusType = await MakeTheTypeConceptLocal("the_status", 999, 999, 101);
+ * // Creates: "the_status" type concept
+ *
+ * @example
+ * // Hierarchical type (recursive processing)
+ * const emailType = await MakeTheTypeConceptLocal("the_person_email", 999, 999, 101);
+ * // Creates: "the_person" (category) + "email" (type) + "the_person_email" (combined)
+ */
+export declare function MakeTheTypeConceptLocal(typeString: string, sessionId: number, sessionUserId: number, userId: number, actions?: InnerActions): Promise<Concept>;

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

@@ -0,0 +1,42 @@
+import { PatcherStructure } from "../../DataStructures/PatcherStructure";
+import { InnerActions } from "../../app";
+/**
+ * Updates/patches a composition in local storage with new or modified properties.
+ *
+ * **Complex Patching Logic** (197 lines):
+ * 1. Fetches latest composition data from backend (all connections and concepts)
+ * 2. Iterates through patchObject properties to add/update
+ * 3. For each property:
+ *    - If value is object/array: Creates composition concept and nested composition
+ *    - If value is primitive: Creates instance concept with value
+ *    - Checks if concept type already exists in composition
+ *    - If exists: Marks old connections for deletion (replaces old value)
+ *    - If new: Simply adds new connection
+ * 4. Creates connections between parent composition and new/updated concepts
+ * 5. Deletes old connections (cleanup)
+ * 6. Syncs changes to backend
+ *
+ * **Use Case**: Updating fields in an existing composition without recreating it entirely.
+ *
+ * @param patcherStructure - Object containing:
+ *   - compositionId: The composition to update
+ *   - ofTheCompositionId: Optional parent composition for nested updates
+ *   - patchObject: Object with key-value pairs to add/update
+ *   - userId, sessionId, accessId: User context
+ * @param actions - Action tracking for batch operations and rollback
+ *
+ * @example
+ * // Update a person's email and phone
+ * await UpdateCompositionLocal({
+ *   compositionId: personId,
+ *   patchObject: {
+ *     the_email: "newemail@example.com",
+ *     the_phone: "555-1234"
+ *   },
+ *   userId: 101,
+ *   sessionId: 999,
+ *   accessId: 4
+ * });
+ * // Old email connection deleted, new email connection created
+ */
+export declare function UpdateCompositionLocal(patcherStructure: PatcherStructure, actions?: InnerActions): Promise<any>;

package/dist/types/Services/Logs/LogEvent.d.ts

@@ -0,0 +1 @@
+export declare function LogEvent(EventName: string, EventDescription: string, event: any): void;

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

@@ -0,0 +1,41 @@
+export interface EmailBody {
+    toAddress: string;
+    heading: string;
+    body?: string;
+    attachments?: Array<string>;
+    CaptchaToken?: string;
+    recaptchaAction?: string;
+}
+export interface BulkEmailBody extends Omit<EmailBody, 'toAddress'> {
+    toAddress?: string;
+    ccAddresses: Array<string>;
+}
+export interface RecaptchaOptions {
+    token: string;
+    action?: string;
+    fieldName?: string;
+    actionFieldName?: string;
+    headerName?: string;
+}
+export interface SendEmailOptions {
+    bulk?: boolean;
+    personal?: boolean;
+    recaptcha?: string | RecaptchaOptions;
+}
+/**
+ * Method to send Email to user
+ * @param body FormData | EmailBody
+ * @param token string
+ * @param bulkOrOptions boolean | SendEmailOptions
+ * @param recaptchaToken string
+ * @returns JSON | string | null
+ */
+export declare const sendEmail: (body: FormData | EmailBody | BulkEmailBody, token: string, bulkOrOptions?: boolean | SendEmailOptions, recaptchaToken?: string) => Promise<any>;
+/**
+ * Method to send a personal Email to user.
+ * @param body FormData | EmailBody
+ * @param token string
+ * @param options SendEmailOptions
+ * @returns JSON | string | null
+ */
+export declare const sendPersonalEmail: (body: FormData | EmailBody, token: string, options?: Omit<SendEmailOptions, "personal" | "bulk">) => Promise<any>;

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

@@ -0,0 +1,2 @@
+import { Concept } from "../DataStructures/Concept";
+export default function MakeTheCharacter(the_character_data: string, userId: number, securityId: number, accessId: number, accessUserId: number, sessionId: number): Promise<Concept>;

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

@@ -0,0 +1,2 @@
+import { Returner } from "../DataStructures/Returner";
+export default function MakeTheCharacterData(the_character_data: string, userId: number, securityId: number, accessId: number, sessionId: number): Promise<Returner>;

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

@@ -0,0 +1,2 @@
+import { Concept } from "../DataStructures/Concept";
+export default function MakeTheConcept(referent: string, userId: number, categoryId: number, typeId: number, referentId: number, accessId: number, typeCharacter: string): Promise<Concept>;