mftsccs-browser 2.1.242-dev → 2.1.244-dev

package/dist/types/Helpers/CheckIfExists.d.ts

@@ -0,0 +1,9 @@
+import { Concept } from "../DataStructures/Concept";
+import { Connection } from "../DataStructures/Connection";
+export declare function CheckIfConceptsExistsInArray(conceptList: Concept[] | undefined, concept: Concept): Concept;
+export declare function CheckIfTypeConceptsExistsInArray(conceptList: Concept[] | undefined, concept: Concept): Concept[];
+export declare function CheckIfTypeLConceptsExistsInArray(conceptList: Concept[] | undefined, concept: Concept): Concept[];
+export declare function CheckIfConnectionExistsInArray(connectionList: Connection[] | undefined, connection: Connection): Connection;
+export declare function CheckIfToTheConceptExistsInConnectionArray(connectionList: Connection[] | undefined, conceptId: number): Connection;
+export declare function CheckAllConnectionsConnectedInConnectionArray(connectionList: Connection[] | undefined, conceptId: number): Connection[];
+export declare function CheckAllConnectionsConnectedInLConnectionArray(connectionList: Connection[] | undefined, conceptId: number): Connection[];

package/dist/types/Helpers/RemoveFromArray.d.ts

@@ -0,0 +1,5 @@
+import { Concept } from "../DataStructures/Concept";
+import { Connection } from "../DataStructures/Connection";
+export declare function RemoveConceptFromList(conceptList: Concept[] | undefined, concept: Concept): void;
+export declare function RemoveConnectionFromList(connectionList: Connection[] | undefined, connection: Connection): void;
+export declare function RemoveLConnectionFromList(connectionList: Connection[] | undefined, connection: Connection): void;

package/dist/types/Helpers/UniqueInsert.d.ts

@@ -0,0 +1 @@
+export default function InsertUniqueNumber(Array: number[], toInsert: number): number[];

package/dist/types/Middleware/ApplicationMonitor.d.ts

@@ -0,0 +1,25 @@
+export declare class ApplicationMonitor {
+    private static globalErrorHandlersInitialized;
+    private static consoleErrorPatched;
+    private static errorEventListenerRegistered;
+    private static unhandledErrorListenerRegistered;
+    private static userInteractionListenersRegistered;
+    private static networkRequestsPatched;
+    private static performanceMetricsRegistered;
+    private static routeChangeListenersRegistered;
+    private static webSocketEventsPatched;
+    private static initialLoadTimeout;
+    static initialize(): void;
+    static initGlobalErrorHandlers(): void;
+    static logCatchError(): void;
+    static logErrorEvent(): void;
+    static logUnhandledError(): void;
+    static logUserInteractions(): void;
+    static logNetworkRequests(): void;
+    static logPerformanceMetrics(): void;
+    static logRouteChanges(): void;
+    static logOnWindowLoad(): void;
+    static logSample(): void;
+    static logWebSocketEvents(): void;
+    private static isBrowser;
+}

package/dist/types/Middleware/logger.service.d.ts

@@ -0,0 +1,144 @@
+export declare class Logger {
+    private static isLoggerActive;
+    private static lastCheck;
+    private static checkInterval;
+    private static logLevel;
+    private static packageLogsData;
+    private static applicationLogsData;
+    private static readonly LOG_LEVELS;
+    private static readonly SYNC_INTERVAL_MS;
+    private static nextSyncTime;
+    private static appLogs;
+    private static mftsccsBrowser;
+    static logApplicationActivationStatus: boolean;
+    static logPackageActivationStatus: boolean;
+    private static autoSyncInterval;
+    /**
+     * Automatically starts the auto-sync mechanism.
+     * This is private and does not need external interaction.
+     */
+    static startAutoSync(): void;
+    /**
+     * Automatically stops the auto-sync mechanism when required.
+     */
+    static stopAutoSync(): void;
+    /**
+     * Set the log level (e.g., "DEBUG", "INFO", "WARNING", "ERROR").
+     */
+    static setLogLevel(level: string): void;
+    /**
+     * Determines whether the current log level permits the given level to be logged.
+     */
+    private static shouldLog;
+    /**
+     * Logs a message with optional additional structured data.
+     */
+    static formatLogData(level: string, message: string, data?: LogData): any;
+    static log(level: 'INFO' | 'ERROR' | 'DEBUG' | 'WARNING', message: string, data?: any | null): void;
+    /**
+     * Updates log data with execution details.
+     * @param logData The log data object to be updated.
+    */
+    static logUpdate(logData: LogData): {} | undefined;
+    static logfunction(myFunction: string, ...args: any[]): any;
+    static logError(startTime: number, userId: string | number, operationType?: "read" | "create" | "update" | "delete" | "search", requestFrom?: string, requestIP?: string, responseStatus?: number, responseData?: any, functionName?: string, functionParameters?: any[], userAgent?: string, conceptsUsed?: string[]): void;
+    static logApplication(level: string, message: string, data?: any): void;
+    static checkLoggerServerStatus(): Promise<void>;
+    /**
+     * Helper method to send logs to the server.
+    */
+    static sendApplicationLogsToServer(): Promise<void>;
+    static sendPackageLogsToServer(): Promise<void>;
+    /**
+     * Helper method to save logs to localStorage.
+    */
+    private static saveLogToLocalStorage;
+    private static clearLogsFromLocalStorage;
+}
+/**
+ * Represents the structure of log data used for application monitoring and anomaly detection.
+ */
+export interface LogData {
+    /**
+     * The userId of the request
+     */
+    userId?: string | Number;
+    /**
+     * The type of operation performed (e.g., create, read, update, delete).
+     * @example "create"
+     */
+    operationType?: 'create' | 'read' | 'update' | 'delete' | 'search';
+    /**
+     * The origin of the request (e.g., browser, API client).
+     * @example "Browser"
+     */
+    requestFrom?: string;
+    /**
+     * The IP address of the client making the request.
+     * @example "192.168.1.1"
+     */
+    requestIP?: string;
+    /**
+     * The HTTP status code of the request.
+     * @example "200", "404", "500"
+     */
+    responseStatus?: string | Number;
+    /**
+     * The time taken to execute the function.
+     * @example "150ms"
+     */
+    responseTime?: string;
+    /**
+     * The start and end time
+     */
+    startTime: number;
+    endTime?: number;
+    /**
+     * The size of the response payload.
+     * @example "15KB", "1.2MB"
+     */
+    responseSize?: string;
+    /**
+     * The Session Id
+     */
+    sessionId?: string | number;
+    /**
+     * The name of the function being logged.
+     * @example "fetchUserData"
+     */
+    functionName?: string;
+    applicationId?: number;
+    /**
+     * The error return
+     * @example function could not execute
+     */
+    errorMessage?: string;
+    /**
+     * The parameters used in the function.
+     * This should include all inputs to the function.
+     * @example [ "userId", "concept" ]
+     */
+    functionParameters?: any[];
+    /**
+     * The user agent details for the request.
+     * This includes information such as the browser or device making the request.
+     * @example "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"
+     */
+    userAgent?: string;
+    /**
+     * A list of concepts (features or modules) used during the function execution.
+     * @example [105292435 , 105292431  ]
+     */
+    conceptsUsed?: string[];
+    /**
+     * Service worker
+     * @example boolean
+     */
+    serviceWorker?: boolean;
+}
+/**getCookie
+ *
+ * @param cname The name of the cookie
+ * @returns Cookie value
+ */
+export declare function getCookie(cname: string): string | null;

package/dist/types/ServiceWorker/actions/connectionActions.d.ts

@@ -0,0 +1,2 @@
+import { Actions } from ".";
+export declare const connectionActions: Actions;

package/dist/types/ServiceWorker/actions/createActions.d.ts

@@ -0,0 +1,2 @@
+import { Actions } from ".";
+export declare const createActions: Actions;

package/dist/types/ServiceWorker/actions/deleteActions.d.ts

@@ -0,0 +1,2 @@
+import { Actions } from ".";
+export declare const deleteActions: Actions;

package/dist/types/ServiceWorker/actions/getActions.d.ts

@@ -0,0 +1,2 @@
+import { Actions } from ".";
+export declare const getActions: Actions;

package/dist/types/ServiceWorker/actions/index.d.ts

@@ -0,0 +1,15 @@
+import { InnerActions } from "../../app";
+export { getActions } from '../actions/getActions';
+export { searchActions } from '../actions/searchActions';
+export { createActions } from '../actions/createActions';
+export { updateActions } from '../actions/updateActions';
+export { connectionActions } from '../actions/connectionActions';
+export { deleteActions } from '../actions/deleteActions';
+export { syncActions } from '../actions/syncActions';
+export interface Actions {
+    [key: string]: (payload: any) => Promise<{
+        success: boolean;
+        data?: any;
+        actions?: InnerActions;
+    }>;
+}

package/dist/types/ServiceWorker/actions/searchActions.d.ts

@@ -0,0 +1,2 @@
+import { Actions } from ".";
+export declare const searchActions: Actions;

package/dist/types/ServiceWorker/actions/syncActions.d.ts

@@ -0,0 +1,2 @@
+import { Actions } from ".";
+export declare const syncActions: Actions;

package/dist/types/ServiceWorker/actions/updateActions.d.ts

@@ -0,0 +1,2 @@
+import { Actions } from ".";
+export declare const updateActions: Actions;

package/dist/types/ServiceWorker/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Method to handle message event in service worker
+ * @param event any
+ * @returns Promise<void>
+ */
+export declare function handleMessageEvent(event: any): Promise<void>;
+/**
+ * Method to check and inform main thread if sw is not initialized
+ * @returns boolean
+ */
+export declare const checkSWInitialization: () => boolean;

package/dist/types/Services/AccessControl/APIClientService.d.ts

@@ -0,0 +1,167 @@
+/**
+ * APIClientService
+ *
+ * API client service for Access Control endpoints.
+ * Provides typed HTTP methods for all access control API operations.
+ *
+ * This is the TypeScript equivalent of the C# APIClientService class.
+ */
+import { AccessRequest, AccessResult, AccessControlAPIResponse, BulkAccessRequest, BulkCheckAccessRequest, AccessInheritanceRequest, SuperAdminRequest, BulkConceptAccessRequest, ConceptAccessRequest, ParentAccessInheritanceRequest, ParentAccessInheritanceWithConceptRequest, BulkParentAccessInheritanceWithConceptRequest, BulkParentAccessInheritanceResult, SuperAdminWithConceptRequest, AccessInheritanceWithConceptRequest } from '../../DataStructures/AccessControl/AccessControlModels';
+export interface IAPIClientService {
+    assignAccessAsync(request: AccessRequest): Promise<AccessControlAPIResponse<AccessResult>>;
+    checkAccessAsync(request: AccessRequest): Promise<AccessControlAPIResponse<AccessResult>>;
+    revokeAccessAsync(request: AccessRequest): Promise<AccessControlAPIResponse<AccessResult>>;
+    assignAccessBulkAsync(request: BulkAccessRequest): Promise<AccessControlAPIResponse<AccessResult[]>>;
+    assignConceptAccessBulkAsync(request: BulkConceptAccessRequest): Promise<AccessControlAPIResponse<AccessResult[]>>;
+    revokeAccessBulkAsync(request: BulkAccessRequest): Promise<AccessControlAPIResponse<AccessResult[]>>;
+    revokeConceptAccessBulkAsync(request: BulkConceptAccessRequest): Promise<AccessControlAPIResponse<AccessResult[]>>;
+    checkAccessBulkAsync(request: BulkCheckAccessRequest): Promise<AccessControlAPIResponse<AccessResult[]>>;
+    getAccessByIdAsync(accessId: number): Promise<AccessControlAPIResponse<AccessResult[]>>;
+    setAccessInheritanceAsync(request: AccessInheritanceRequest): Promise<AccessControlAPIResponse>;
+    getAccessInheritanceStatusAsync(accessId: number, connectionTypeId?: number): Promise<AccessControlAPIResponse>;
+    assignSuperAdminAccessAsync(request: SuperAdminRequest): Promise<AccessControlAPIResponse>;
+    revokeSuperAdminAccessAsync(request: SuperAdminRequest): Promise<AccessControlAPIResponse>;
+    checkSuperAdminStatusAsync(accessId: number): Promise<AccessControlAPIResponse>;
+    setParentAccessInheritanceAsync(request: ParentAccessInheritanceRequest): Promise<AccessControlAPIResponse>;
+    removeParentAccessInheritanceAsync(accessId: number, parentAccessId?: number): Promise<AccessControlAPIResponse>;
+    hasParentAccessInheritanceAsync(accessId: number, parentAccessId?: number): Promise<AccessControlAPIResponse>;
+    getParentAccessIdAsync(accessId: number): Promise<AccessControlAPIResponse>;
+    setParentAccessInheritanceByConceptAsync(request: ParentAccessInheritanceWithConceptRequest): Promise<AccessControlAPIResponse>;
+    setParentAccessInheritanceBulkByConceptAsync(request: BulkParentAccessInheritanceWithConceptRequest): Promise<AccessControlAPIResponse<BulkParentAccessInheritanceResult[]>>;
+    removeParentAccessInheritanceByConceptAsync(childConceptId: number, parentConceptId?: number): Promise<AccessControlAPIResponse>;
+    removeParentAccessInheritanceBulkByConceptAsync(request: BulkParentAccessInheritanceWithConceptRequest): Promise<AccessControlAPIResponse<BulkParentAccessInheritanceResult[]>>;
+    hasParentAccessInheritanceByConceptAsync(childConceptId: number, parentConceptId?: number): Promise<AccessControlAPIResponse>;
+    getParentAccessIdByConceptAsync(childConceptId: number): Promise<AccessControlAPIResponse>;
+    assignSuperAdminByConceptAsync(request: SuperAdminWithConceptRequest): Promise<AccessControlAPIResponse>;
+    revokeSuperAdminByConceptAsync(request: SuperAdminWithConceptRequest): Promise<AccessControlAPIResponse>;
+    checkSuperAdminByConceptAsync(conceptId: number): Promise<AccessControlAPIResponse>;
+    setAccessInheritanceByConceptAsync(request: AccessInheritanceWithConceptRequest): Promise<AccessControlAPIResponse>;
+    getAccessInheritanceStatusByConceptAsync(conceptId: number, connectionTypeId?: number): Promise<AccessControlAPIResponse>;
+}
+export declare class APIClientService implements IAPIClientService {
+    private static get baseUrl();
+    private static getAsync;
+    private static postAsync;
+    private static deleteAsync;
+    /**
+     * Assign access to an entity
+     */
+    assignAccessAsync(request: AccessRequest): Promise<AccessControlAPIResponse<AccessResult>>;
+    /**
+     * Check if an entity has access
+     */
+    checkAccessAsync(request: AccessRequest): Promise<AccessControlAPIResponse<AccessResult>>;
+    /**
+     * Revoke access from an entity
+     */
+    revokeAccessAsync(request: AccessRequest): Promise<AccessControlAPIResponse<AccessResult>>;
+    /**
+     * Assign access to multiple targets in bulk
+     */
+    assignAccessBulkAsync(request: BulkAccessRequest): Promise<AccessControlAPIResponse<AccessResult[]>>;
+    /**
+     * Revoke access from multiple targets in bulk
+     */
+    revokeAccessBulkAsync(request: BulkAccessRequest): Promise<AccessControlAPIResponse<AccessResult[]>>;
+    /**
+     * Check access for multiple targets in bulk
+     */
+    checkAccessBulkAsync(request: BulkCheckAccessRequest): Promise<AccessControlAPIResponse<AccessResult[]>>;
+    /**
+     * Get all access entries for a specific accessId
+     */
+    getAccessByIdAsync(accessId: number): Promise<AccessControlAPIResponse<AccessResult[]>>;
+    /**
+     * Set access inheritance for an access ID
+     */
+    setAccessInheritanceAsync(request: AccessInheritanceRequest): Promise<AccessControlAPIResponse>;
+    /**
+     * Get access inheritance status
+     */
+    getAccessInheritanceStatusAsync(accessId: number, connectionTypeId?: number): Promise<AccessControlAPIResponse>;
+    /**
+     * Assign super admin access
+     */
+    assignSuperAdminAccessAsync(request: SuperAdminRequest): Promise<AccessControlAPIResponse>;
+    /**
+     * Revoke super admin access
+     */
+    revokeSuperAdminAccessAsync(request: SuperAdminRequest): Promise<AccessControlAPIResponse>;
+    /**
+     * Check super admin status
+     */
+    checkSuperAdminStatusAsync(accessId: number): Promise<AccessControlAPIResponse>;
+    /**
+     * Create a new standalone access record for a concept
+     */
+    assignConceptAccessAsync(request: ConceptAccessRequest): Promise<AccessControlAPIResponse<AccessResult>>;
+    /**
+     * Create new standalone access records for multiple concepts in bulk
+     */
+    assignConceptAccessBulkAsync(request: BulkConceptAccessRequest): Promise<AccessControlAPIResponse<AccessResult[]>>;
+    /**
+     * Revoke access records for multiple concepts in bulk
+     */
+    revokeConceptAccessBulkAsync(request: BulkConceptAccessRequest): Promise<AccessControlAPIResponse<AccessResult[]>>;
+    /**
+     * Set parent access inheritance link
+     */
+    setParentAccessInheritanceAsync(request: ParentAccessInheritanceRequest): Promise<AccessControlAPIResponse>;
+    /**
+     * Remove parent access inheritance link
+     */
+    removeParentAccessInheritanceAsync(accessId: number, parentAccessId?: number): Promise<AccessControlAPIResponse>;
+    /**
+     * Check if parent access inheritance link exists
+     */
+    hasParentAccessInheritanceAsync(accessId: number, parentAccessId?: number): Promise<AccessControlAPIResponse>;
+    /**
+     * Get the parent access ID for a given access ID
+     */
+    getParentAccessIdAsync(accessId: number): Promise<AccessControlAPIResponse>;
+    /**
+     * Set parent access inheritance by concept IDs (server resolves conceptId → accessId)
+     */
+    setParentAccessInheritanceByConceptAsync(request: ParentAccessInheritanceWithConceptRequest): Promise<AccessControlAPIResponse>;
+    /**
+     * Set parent access inheritance for multiple children with one parent (concept-based)
+     */
+    setParentAccessInheritanceBulkByConceptAsync(request: BulkParentAccessInheritanceWithConceptRequest): Promise<AccessControlAPIResponse<BulkParentAccessInheritanceResult[]>>;
+    /**
+     * Remove parent access inheritance by concept IDs
+     */
+    removeParentAccessInheritanceByConceptAsync(childConceptId: number, parentConceptId?: number): Promise<AccessControlAPIResponse>;
+    /**
+     * Remove parent access inheritance for multiple children (concept-based)
+     */
+    removeParentAccessInheritanceBulkByConceptAsync(request: BulkParentAccessInheritanceWithConceptRequest): Promise<AccessControlAPIResponse<BulkParentAccessInheritanceResult[]>>;
+    /**
+     * Check if parent access inheritance exists by concept IDs
+     */
+    hasParentAccessInheritanceByConceptAsync(childConceptId: number, parentConceptId?: number): Promise<AccessControlAPIResponse>;
+    /**
+     * Get the parent access ID by child concept ID
+     */
+    getParentAccessIdByConceptAsync(childConceptId: number): Promise<AccessControlAPIResponse>;
+    /**
+     * Assign super admin by concept ID
+     */
+    assignSuperAdminByConceptAsync(request: SuperAdminWithConceptRequest): Promise<AccessControlAPIResponse>;
+    /**
+     * Revoke super admin by concept ID
+     */
+    revokeSuperAdminByConceptAsync(request: SuperAdminWithConceptRequest): Promise<AccessControlAPIResponse>;
+    /**
+     * Check super admin status by concept ID
+     */
+    checkSuperAdminByConceptAsync(conceptId: number): Promise<AccessControlAPIResponse>;
+    /**
+     * Set access inheritance by concept ID
+     */
+    setAccessInheritanceByConceptAsync(request: AccessInheritanceWithConceptRequest): Promise<AccessControlAPIResponse>;
+    /**
+     * Get access inheritance status by concept ID
+     */
+    getAccessInheritanceStatusByConceptAsync(conceptId: number, connectionTypeId?: number): Promise<AccessControlAPIResponse>;
+}
+export default APIClientService;

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

@@ -0,0 +1,114 @@
+/**
+ * AccessControlService
+ *
+ * This service provides access control functionality including:
+ * - 5-phase bulk access check with BFS inheritance graph traversal
+ * - Assign and revoke access permissions
+ * - Bulk operations for access management
+ * - Super admin checks
+ * - Access inheritance management (including parent access inheritance)
+ *
+ * This is the TypeScript equivalent of the C# AccessControlService class (v3.4.0).
+ */
+import { AccessResult, BulkConceptAccessRequest, BulkParentAccessInheritanceResult } from '../../DataStructures/AccessControl/AccessControlModels';
+import { IAPIClientService } from './APIClientService';
+/**
+ * Interface for the Access Control Service
+ */
+export interface IAccessControlService {
+    checkAccess(conceptId: number, permission: string, entityId?: number | null): Promise<boolean>;
+    checkAccessBulk(conceptIds: number[], permission: string, entityId?: number | null): Promise<Map<number, boolean>>;
+    getConceptIdsWithPermission(permission: string, conceptIdsFilter: number[], entityId?: number | null): Promise<number[]>;
+    assignAccess(request: BulkConceptAccessRequest): Promise<AccessResult[]>;
+    revokeAccess(conceptId: number, permission: string, entityId?: number | null): Promise<boolean>;
+    revokeAccessBulk(request: BulkConceptAccessRequest): Promise<AccessResult[]>;
+    setAccessInheritance(conceptId: number): Promise<boolean>;
+    getAccessInheritanceStatus(conceptId: number, connectionTypeId?: number): Promise<boolean>;
+    setAccessInheritanceStatus(conceptId: number, isEnabled: boolean, connectionTypeId?: number): Promise<boolean>;
+    setParentAccessInheritance(conceptId: number, parentConceptId: number): Promise<number>;
+    setParentAccessInheritanceBulk(childConceptIds: number[], parentConceptId: number): Promise<BulkParentAccessInheritanceResult[]>;
+    removeParentAccessInheritance(conceptId: number, parentConceptId?: number): Promise<string>;
+    removeParentAccessInheritanceBulk(childConceptIds: number[], parentConceptId?: number): Promise<BulkParentAccessInheritanceResult[]>;
+    hasParentAccessInheritance(conceptId: number, parentConceptId?: number): Promise<boolean>;
+    getParentAccessId(conceptId: number): Promise<number | null>;
+    isSuperAdmin(entityId: number): Promise<boolean>;
+    assignSuperAdmin(entityId: number): Promise<number>;
+    revokeSuperAdmin(entityId: number): Promise<string>;
+}
+export declare class AccessControlService implements IAccessControlService {
+    private readonly apiClient;
+    constructor(apiClient?: IAPIClientService);
+    /**
+     * Check whether a user/entity has the specified permission on a single concept.
+     * Delegates to checkAccessBulk for full inheritance + group resolution.
+     */
+    checkAccess(conceptId: number, permission: string, entityId?: number | null): Promise<boolean>;
+    /**
+     * 5-phase bulk access check algorithm.
+     * Matches the C# AccessControlService.CheckAccessBulk implementation.
+     *
+     * Phase 1: Super-admin short-circuit
+     * Phase 2: Fast-path classification (owner, public, type concepts)
+     * Phase 3: BFS inheritance graph resolution (3 sources)
+     * Phase 4: Bulk access decision resolution (API)
+     * Phase 5: Grant-only merge per concept
+     */
+    checkAccessBulk(conceptIds: number[], permission: string, entityId?: number | null): Promise<Map<number, boolean>>;
+    /**
+     * Get all conceptIds which have a certain permission for an entity.
+     * Delegates to checkAccessBulk for full inheritance support.
+     */
+    getConceptIdsWithPermission(permission: string, conceptIdsFilter: number[], entityId?: number | null): Promise<number[]>;
+    /**
+     * Resolve inheritance graph via 3-source BFS, depth-limited to MAX_BFS_DEPTH.
+     *
+     * Source 1: FreeSchema internal connections ("the_parent_access_inheritance")
+     * Source 2: Explicit parent access links (via Access API)
+     * Source 3: Concept-connection access inheritance
+     */
+    private resolveBulkInheritanceGraph;
+    private resolveBulkDecisions;
+    private resolveSubjects;
+    private hasAnyGrant;
+    assignAccess(request: BulkConceptAccessRequest): Promise<AccessResult[]>;
+    revokeAccess(conceptId: number, permission: string, entityId?: number | null): Promise<boolean>;
+    revokeAccessBulk(request: BulkConceptAccessRequest): Promise<AccessResult[]>;
+    setAccessInheritance(conceptId: number): Promise<boolean>;
+    getAccessInheritanceStatus(conceptId: number, connectionTypeId?: number): Promise<boolean>;
+    setAccessInheritanceStatus(conceptId: number, isEnabled: boolean, connectionTypeId?: number): Promise<boolean>;
+    setParentAccessInheritance(conceptId: number, parentConceptId: number): Promise<number>;
+    setParentAccessInheritanceBulk(childConceptIds: number[], parentConceptId: number): Promise<BulkParentAccessInheritanceResult[]>;
+    removeParentAccessInheritance(conceptId: number, parentConceptId?: number): Promise<string>;
+    removeParentAccessInheritanceBulk(childConceptIds: number[], parentConceptId?: number): Promise<BulkParentAccessInheritanceResult[]>;
+    hasParentAccessInheritance(conceptId: number, parentConceptId?: number): Promise<boolean>;
+    getParentAccessId(conceptId: number): Promise<number | null>;
+    isSuperAdmin(entityId: number): Promise<boolean>;
+    assignSuperAdmin(entityId: number): Promise<number>;
+    revokeSuperAdmin(entityId: number): Promise<string>;
+    makeConceptPrivate(conceptId: number): Promise<boolean>;
+    private static parseBoolData;
+    private static parseIntData;
+    static isSuperAdmin(entityId: number): Promise<boolean>;
+    static assignSuperAdmin(entityId: number): Promise<number>;
+    static revokeSuperAdmin(entityId: number): Promise<string>;
+    static checkAccess(conceptId: number, permission: string, entityId?: number | null): Promise<boolean>;
+    static checkAccessBulk(conceptIds: number[], permission: string, entityId?: number | null): Promise<Map<number, boolean>>;
+    static assignAccess(request: BulkConceptAccessRequest): Promise<AccessResult[]>;
+    static revokeAccess(conceptId: number, permission: string, entityId?: number | null): Promise<boolean>;
+    static revokeAccessBulk(request: BulkConceptAccessRequest): Promise<AccessResult[]>;
+    static setParentAccessInheritance(conceptId: number, parentConceptId: number): Promise<number>;
+    static setParentAccessInheritanceBulk(childConceptIds: number[], parentConceptId: number): Promise<BulkParentAccessInheritanceResult[]>;
+    static removeParentAccessInheritance(conceptId: number, parentConceptId?: number): Promise<string>;
+    static removeParentAccessInheritanceBulk(childConceptIds: number[], parentConceptId?: number): Promise<BulkParentAccessInheritanceResult[]>;
+    static hasParentAccessInheritance(conceptId: number, parentConceptId?: number): Promise<boolean>;
+    static getParentAccessId(conceptId: number): Promise<number | null>;
+}
+/**
+ * Get the default singleton instance of AccessControlService
+ */
+export declare function getAccessControlService(): AccessControlService;
+/**
+ * Initialize the default singleton instance with custom configuration
+ */
+export declare function initializeAccessControlService(apiClient?: IAPIClientService): AccessControlService;
+export default AccessControlService;

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

@@ -0,0 +1,7 @@
+/**
+ * Clears all application caches (both in-memory and IndexedDB).
+ *
+ * Call this on user logout or when you need to force-refresh all cached data.
+ * Clears widget caches (standard, latest, recent) and query caches.
+ */
+export declare function clearAllCaches(): void;

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

@@ -0,0 +1,3 @@
+import { Connection } from "../DataStructures/Connection";
+export declare function CheckForConnectionDeletion(newConnections?: Connection[], oldConnections?: Connection[]): void;
+export declare function CheckForConnectionDeletionWithIds(newConnectionIds?: number[], oldConnections?: Connection[]): void;

package/dist/types/Services/Common/DecodeCountInfo.d.ts

@@ -0,0 +1,3 @@
+import { CountInfo } from "../../DataStructures/Count/CountInfo";
+export declare function DecodeCountInfo(countStrings?: string[]): CountInfo[];
+export declare function GetConnectionTypeForCount(countInfos: CountInfo[]): Promise<any>;

package/dist/types/Services/Common/DelayFunction.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * @param ms The time required to wait before executing this function
+ * @param callback This is the function that needs to be executed
+ * @returns returns a promise for the resolve
+ */
+export declare function DelayFunctionExecution(ms: number, callback: any): Promise<unknown>;

package/dist/types/Services/Common/ErrorPosting.d.ts

@@ -0,0 +1,10 @@
+export declare function HandleHttpError(response: Response): void;
+export declare function HandleHttpErrorObject(response: Response, output?: any): void;
+export declare function HandleInternalError(error: any, url?: string): void;
+/**
+ * Handle errors inside package functions
+ * @updateLog existing function log at start
+ * @param functionName name of the function that encountered the error
+ * @param error error appeared
+ */
+export declare function UpdatePackageLogWithError(logData: any, functionName: string, error: any): void;

package/dist/types/Services/Common/MergeArrays.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * @param array1 The array you want to merge into
+ * @param array2 The array you want to merge
+ * @returns array1 with the elements of array 2
+ */
+export declare function MergeTwoArrays(array1: any, array2: any): any;

package/dist/types/Services/Common/RegexFunction.d.ts

@@ -0,0 +1 @@
+export declare function removeThePrefix(inputString: string): string;

package/dist/types/Services/Common/RemoveAllChild.d.ts

@@ -0,0 +1 @@
+export declare function removeAllChildren(parent: HTMLElement): void;

package/dist/types/Services/Composition/BuildComposition.d.ts

@@ -0,0 +1,3 @@
+import { Connection } from '../../DataStructures/Connection';
+import { Concept } from '../../DataStructures/Concept';
+export declare function recursiveFetchNew(id: number, connectionList: Connection[], conceptList: Concept[], compositionList: number[], visitedConcepts?: number[]): Promise<any>;

package/dist/types/Services/Composition/CompositionCache.d.ts

@@ -0,0 +1,4 @@
+import { Connection } from '../../DataStructures/Connection';
+export declare function GetCompositionWithCache(id: number, connectionListPassed?: Connection[]): Promise<any>;
+export declare function GetCompositionWithDataIdWithCache(id: number, connectionListPassed?: Connection[]): Promise<any>;
+export declare function GetCompositionWithDataIdBulk(ids: number[], connections: number[]): Promise<any[]>;

package/dist/types/Services/Composition/CreateCompositionCache.d.ts

@@ -0,0 +1,3 @@
+import { Concept } from '../../DataStructures/Concept';
+import { Composition } from '../../DataStructures/Composition/Composition';
+export declare function CreateTheCompositionWithCache(json: any, ofTheConceptId?: number | null, ofTheConceptUserId?: number | null, mainKey?: number | null, userId?: number | null, accessId?: number | null, sessionInformationId?: number | null, composition?: Composition | null): Promise<Concept>;

package/dist/types/Services/ConceptFinding/GetConceptByCharacterAndCategory.d.ts

@@ -0,0 +1,5 @@
+import { Concept } from "../../app";
+export declare function GetConceptByCharacterAndCategory(character: string): Promise<Concept>;
+export declare function GetTypeConceptsByCharacterAndCategoryBulk(typeConcepts: string[]): Promise<Concept[]>;
+export declare function GetConceptByCharacter(characterValue: string): Promise<Concept>;
+export declare function GetConceptByCharacterAndCategoryFromMemory(character: string, category: number): Promise<Concept>;

package/dist/types/Services/Conversion/ConvertConcepts.d.ts

@@ -0,0 +1,5 @@
+import { Concept } from "../../DataStructures/Concept";
+import { Connection } from "../../DataStructures/Connection";
+export declare function convertFromConceptToLConcept(concept: Concept): Concept;
+export declare function convertFromLConceptToConcept(lconcept: Concept): Concept;
+export declare function convertFromConnectionToLConnection(connection: Connection): Connection;

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

@@ -0,0 +1,5 @@
+/**
+ * This function builds up the binary tree on startup from the indexdb.
+ * Processes records in chunks to avoid blocking the main thread.
+ */
+export default function CreateConceptBinaryTreeFromIndexDb(): Promise<void>;

package/dist/types/Services/CreateConnection/CreateConnectionEntity.d.ts

@@ -0,0 +1,2 @@
+import { Concept, InnerActions } from "../../app";
+export declare function CreateConnectionBetweenEntityLocal(concept1Data: Concept, concept2Data: Concept, linker: string, actions?: InnerActions): Promise<any>;

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

@@ -0,0 +1,5 @@
+import { Concept } from "../DataStructures/Concept";
+import { Connection } from "../DataStructures/Connection";
+export declare function CreateConnectionBetweenTwoConcepts(ofTheConcept: Concept, toTheConcept: Concept, linker: string, both?: boolean, count?: boolean): Promise<any>;
+export declare function CountRelationship(linker: string, concept: Concept, passedUserId?: number | null): Promise<void>;
+export declare function CreateConnectionBetweenTwoConceptsGeneral(ofTheConcept: Concept, toTheConcept: Concept, linker: string, both?: boolean, count?: boolean): Promise<Connection>;

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

@@ -0,0 +1,3 @@
+import { Concept } from "../DataStructures/Concept";
+export declare function CreateDefaultConcept(): Concept;
+export declare function formatDate(date: Date): string;