mftsccs-browser 2.2.20-beta → 2.2.22-beta

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

@@ -1 +1,78 @@
+/**
+ * Authenticates a user with the backend API and obtains an access token.
+ *
+ * This is the primary authentication function that validates user credentials against the backend
+ * server and retrieves a JWT bearer token for subsequent API requests.
+ *
+ * **Authentication Flow:**
+ * 1. Sends email and password to backend login endpoint
+ * 2. Receives JWT token in response
+ * 3. Automatically stores token in TokenStorage.BearerAccessToken
+ * 4. Token is used for all subsequent authenticated API calls
+ * 5. Logs the authentication attempt for audit purposes
+ *
+ * **Features:**
+ * - Automatic token storage (no manual handling required)
+ * - Error handling and logging
+ * - Application-specific authentication
+ * - Performance and audit logging
+ *
+ * **Security Notes:**
+ * - Credentials are sent over HTTPS (ensure BaseUrl uses HTTPS)
+ * - Token is stored in memory (TokenStorage)
+ * - Token should be refreshed before expiration
+ * - Never log or expose the token in client-side code
+ *
+ * @param email - The user's email address. Must be a valid registered email.
+ *               Used as the primary login identifier.
+ * @param password - The user's password. Sent to backend for verification.
+ *                  Should meet password complexity requirements.
+ * @param application - The application identifier for multi-tenant authentication.
+ *                     Defaults to "boomconsole.com". Used to scope authentication
+ *                     to specific applications in the system.
+ *
+ * @returns Promise resolving to the authentication result object containing:
+ *         - data.token: The JWT bearer token
+ *         - user information
+ *         - session details
+ *         Returns undefined on error
+ *
+ * @example
+ * // Basic login
+ * const result = await LoginToBackend(
+ *   "user@example.com",
+ *   "securePassword123"
+ * );
+ * if (result) {
+ *   console.log("Logged in successfully");
+ *   console.log("Token:", result.data.token); // Now stored in TokenStorage
+ * }
+ *
+ * @example
+ * // Login for specific application
+ * const result = await LoginToBackend(
+ *   "admin@company.com",
+ *   "adminPass",
+ *   "admin.company.com"  // Custom application
+ * );
+ *
+ * @example
+ * // Use with other authenticated operations
+ * const loginResult = await LoginToBackend("user@example.com", "pass123");
+ * if (loginResult) {
+ *   // Token is automatically available for subsequent calls
+ *   const concepts = await SearchAllConcepts("", "search term", "", TokenStorage.BearerAccessToken);
+ * }
+ *
+ * @throws Does not throw but logs errors. Returns undefined on failure.
+ *        Error scenarios include:
+ *        - Invalid credentials (401 Unauthorized)
+ *        - Network errors
+ *        - Server errors (5xx)
+ *        - Malformed request
+ *
+ * @see {@link Signin} for alternative sign-in function
+ * @see {@link Signup} for user registration
+ * @see {@link updateAccessToken} for manually updating the stored token
+ */
 export declare function LoginToBackend(email: string, password: string, application?: string): Promise<any>;

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

@@ -1 +1,14 @@
+/**
+ * Creates a name/referent association for a concept in the backend.
+ * Associates a human-readable name with a concept ID.
+ *
+ * @param newConceptId - ID of the concept to name
+ * @param referent - Human-readable name/referent string
+ * @param typeId - Type ID for the name association
+ * @param typeUserId - User ID who owns the type
+ * @returns void
+ *
+ * @example
+ * await MakeTheNameInBackend(123, "John Doe", 5, 456);
+ */
 export declare function MakeTheNameInBackend(newConceptId: number, referent: string, typeId: number, typeUserId: number): Promise<void>;

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

@@ -1,2 +1,14 @@
 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/Api/Prototype/Selector.d.ts

@@ -1,4 +1,15 @@
 import { StatefulWidget } from "../../app";
+/**
+ * Selector widget for searchable dropdown selection.
+ * Provides a UI component with search filtering and freeschema query integration.
+ *
+ * **Complex Logic**: Builds a searchable select element that queries data using
+ * FreeschemaQuery, filters results dynamically, and populates options based on
+ * nested data structures.
+ *
+ * @example
+ * const selector = new Selector("person", "has_name", parentElement, "text", 10);
+ */
 export declare class Selector extends StatefulWidget {
     selector: string;
     mainType: string;

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

@@ -1,6 +1,67 @@
+/**
+ * Performs recursive search through composition hierarchy.
+ * Searches through nested compositions using linker relationships.
+ *
+ * **Complex Logic**: Constructs SearchQuery, fetches composition IDs and connections,
+ * processes internal/external connections, and builds composition objects from results.
+ *
+ * @param composition - Root composition ID to start search from (default: 0)
+ * @param listLinkers - Array of linker strings to traverse (default: [])
+ * @param textSearch - Text search filter (default: "")
+ * @param fullLinkers - Array of full linker paths (default: [])
+ * @returns Array of composition objects with connections
+ *
+ * @example
+ * const results = await RecursiveSearchApi(123, ["has_child", "has_property"], "search text");
+ */
 export declare function RecursiveSearchApi(composition?: number, listLinkers?: string[], textSearch?: string, fullLinkers?: string[]): Promise<any>;
+/**
+ * Performs recursive search returning results with internal connections.
+ * Similar to RecursiveSearchApi but uses different connection formatting.
+ *
+ * @param composition - Root composition ID to start search from (default: 0)
+ * @param listLinkers - Array of linker strings to traverse (default: [])
+ * @param textSearch - Text search filter (default: "")
+ * @returns Array of composition objects with internal connections
+ */
 export declare function RecursiveSearchApiWithInternalConnections(composition?: number, listLinkers?: string[], textSearch?: string): Promise<any>;
+/**
+ * Performs recursive search returning raw API response.
+ * Returns unprocessed result with composition IDs and connection arrays.
+ *
+ * @param composition - Root composition ID (default: 0)
+ * @param listLinkers - Array of linker strings (default: [])
+ * @param textSearch - Text search filter (default: "")
+ * @param fullLinkers - Array of full linker paths (default: [])
+ * @returns Raw API response object with compositionIds, internalConnections, externalConnections
+ */
 export declare function RecursiveSearchApiRaw(composition?: number, listLinkers?: string[], textSearch?: string, fullLinkers?: string[]): Promise<any>;
+/**
+ * Performs recursive search using full linker paths, returning raw response.
+ * Uses complete linker path specifications instead of partial linkers.
+ *
+ * @param composition - Root composition ID (default: 0)
+ * @param fullLinkers - Array of complete linker path strings (default: [])
+ * @param textSearch - Text search filter (default: "")
+ * @returns Raw API response object with compositionIds and connections
+ */
 export declare function RecursiveSearchApiRawFullLinker(composition?: number, fullLinkers?: string[], textSearch?: string): Promise<any>;
+/**
+ * New version of recursive search with full linker paths.
+ * Alternative implementation of RecursiveSearchApiRawFullLinker.
+ *
+ * @param composition - Root composition ID (default: 0)
+ * @param fullLinkers - Array of complete linker path strings (default: [])
+ * @param textSearch - Text search filter (default: "")
+ * @returns Raw API response object with compositionIds and connections
+ */
 export declare function RecursiveSearchApiNewRawFullLinker(composition?: number, fullLinkers?: string[], textSearch?: string): Promise<any>;
+/**
+ * Performs recursive search using local data only.
+ * Placeholder for local-only search implementation.
+ *
+ * @param composition - Root composition ID
+ * @param listLinkers - Array of linker strings (default: [])
+ * @param textSearch - Text search filter (default: "")
+ */
 export declare function RecursiveSearchLocal(composition: number, listLinkers?: string[], textSearch?: string): Promise<void>;

package/dist/types/Api/Search/FreeschemaQueryApi.d.ts

@@ -1,2 +1,18 @@
 import { FreeschemaQuery } from "../../app";
+/**
+ * Executes a freeschema query for flexible, schema-free data retrieval.
+ * Supports custom query structures with filters, pagination, and nested queries.
+ *
+ * @param query - FreeschemaQuery object containing query parameters, filters, and nested queries
+ * @param token - Authentication token (optional, defaults to empty string)
+ * @returns Query results array or empty array on error
+ *
+ * @example
+ * const results = await FreeschemaQueryApi({
+ *   type: "person",
+ *   filters: [{ field: "name", operator: "like", value: "John" }],
+ *   inpage: 10,
+ *   page: 1
+ * }, "auth-token");
+ */
 export declare function FreeschemaQueryApi(query: FreeschemaQuery, token?: string): Promise<any>;

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

@@ -1 +1,73 @@
+/**
+ * Searches for concepts matching specified criteria with pagination support.
+ *
+ * This is the primary search function for querying concepts in the system. It performs a
+ * backend API search with multiple filter parameters and returns paginated results.
+ *
+ * **Search Capabilities:**
+ * - Text-based search on concept character values
+ * - Type filtering (search within specific concept types)
+ * - Composition filtering (search within specific compositions)
+ * - Pagination support (page size and page number)
+ * - Authenticated requests (requires valid access token)
+ *
+ * **Use Cases:**
+ * - Finding concepts by name or partial text match
+ * - Filtering results by concept type (e.g., only "Person" concepts)
+ * - Searching within a specific composition context
+ * - Building paginated search UIs
+ *
+ * @param type - The type filter for the search. Can be a type name (e.g., "Person", "Document")
+ *              or empty string to search all types. Used to narrow results to specific concept types.
+ * @param search - The search query string. Searches against concept character values (names/titles).
+ *                Can be partial matches depending on backend implementation.
+ * @param composition - Composition context filter. Can be a composition ID or identifier to limit
+ *                     search scope to concepts within a specific composition. Use empty string for global search.
+ * @param token - The JWT authentication token. Required for authorized access to backend search API.
+ *               Should be the BearerAccessToken from TokenStorage.
+ * @param inpage - Number of results per page. Controls page size for pagination. Defaults to 10.
+ *                Must be a positive integer.
+ * @param page - The page number to retrieve (1-indexed). Defaults to 1 (first page).
+ *              Use for pagination: page 1, page 2, etc.
+ *
+ * @returns Promise resolving to an array of matching Concept objects, or empty array on error/no results
+ *
+ * @example
+ * // Simple search for all concepts containing "Alice"
+ * const results = await SearchAllConcepts(
+ *   "",              // all types
+ *   "Alice",         // search term
+ *   "",              // all compositions
+ *   accessToken,     // auth token
+ *   10,              // 10 per page
+ *   1                // first page
+ * );
+ *
+ * @example
+ * // Search for "Person" type concepts with "Smith" in name
+ * const people = await SearchAllConcepts(
+ *   "Person",        // only Person types
+ *   "Smith",         // search term
+ *   "",              // all compositions
+ *   accessToken,
+ *   20,              // 20 per page
+ *   1
+ * );
+ *
+ * @example
+ * // Paginated search - get second page
+ * const page2 = await SearchAllConcepts(
+ *   "",
+ *   "Project",
+ *   "",
+ *   accessToken,
+ *   10,
+ *   2                // second page
+ * );
+ *
+ * @throws Returns empty array on error. Errors are logged via HandleHttpError and HandleInternalError
+ *
+ * @see {@link SearchWithLinker} for search with relationship filtering
+ * @see {@link SearchWithTypeAndLinker} for advanced search with type and linker filters
+ */
 export declare function SearchAllConcepts(type: string, search: string, composition: string, token: string, inpage?: number, page?: number): Promise<any>;

package/dist/types/Api/Search/SearchInternalApi.d.ts

@@ -1,3 +1,28 @@
 import { SearchStructure } from "../../app";
+/**
+ * Searches internal compositions with authentication using query parameters.
+ * Performs authenticated search within a composition's internal data structure.
+ *
+ * @param search - Search structure containing composition, search text, internal composition, type, pagination
+ * @param token - Authentication token (optional, defaults to empty string)
+ * @returns Array of search results or empty array on error
+ *
+ * @example
+ * const results = await SearchInternalApi({
+ *   composition: 123,
+ *   search: "example",
+ *   internalComposition: 456,
+ *   type: "text",
+ *   inpage: 10,
+ *   page: 1
+ * }, "auth-token");
+ */
 export declare function SearchInternalApi(search: SearchStructure, token?: string): Promise<any>;
+/**
+ * Searches internal compositions without authentication.
+ * Similar to SearchInternalApi but for public/unauthenticated searches.
+ *
+ * @param search - Search structure containing composition, search text, internal composition, type, pagination
+ * @returns Array of search results or empty array on error
+ */
 export declare function SearchInternalAllApi(search: SearchStructure): Promise<any>;

package/dist/types/Api/Search/SearchLinkMultipleApi.d.ts

@@ -1,2 +1,15 @@
 import { SearchQuery } from '../../DataStructures/SearchQuery';
+/**
+ * Searches for concepts using multiple linked queries with performance tracking.
+ * Executes complex multi-criteria searches across concept relationships.
+ *
+ * @param searchQuery - Array of SearchQuery objects defining linked search criteria
+ * @param token - Authentication token (optional, defaults to empty string)
+ * @returns Array of search results or empty array on error
+ *
+ * @example
+ * const results = await SearchLinkMultipleApi([
+ *   { composition: 123, linker: "has_property", value: "example" }
+ * ], "auth-token");
+ */
 export declare function SearchLinkMultipleApi(searchQuery: SearchQuery[], token?: string): Promise<any>;

package/dist/types/Api/Search/SearchWithLinker.d.ts

@@ -1,2 +1,16 @@
 import { SearchQuery } from '../../DataStructures/SearchQuery';
+/**
+ * Searches concepts using multiple linker queries with authentication.
+ * Allows complex searches by combining multiple search query conditions.
+ *
+ * @param searchQuery - Array of search query objects defining search criteria
+ * @param token - Authentication token (optional, defaults to empty string)
+ * @returns Array of matching search results or empty array on error
+ *
+ * @example
+ * const results = await SearchWithLinker([
+ *   { linker: "has_name", value: "John" },
+ *   { linker: "has_age", value: "30" }
+ * ], "auth-token");
+ */
 export declare function SearchWithLinker(searchQuery: SearchQuery[], token?: string): Promise<any>;

package/dist/types/Api/Search/SearchWithTypeAndLinker.d.ts

@@ -1,2 +1,14 @@
 import { SearchQuery, SearchStructure } from "../../app";
+/**
+ * Searches concepts by type with additional linker query filters.
+ * Combines type-based search with linker queries for refined results.
+ *
+ * **Complex Logic**: Constructs URL with search structure parameters, then applies
+ * linker queries as POST body for multi-dimensional filtering.
+ *
+ * @param searchStructure - Structure containing search text, type, pagination, and auth flag
+ * @param searchQuery - Array of linker query objects for additional filtering
+ * @param token - Authentication token (optional, defaults to empty string)
+ * @returns Array of concepts matching both type and linker criteria, or empty array on error
+ */
 export declare function SearchWithTypeAndLinkerApi(searchStructure: SearchStructure, searchQuery: SearchQuery[], token?: string): Promise<any>;

package/dist/types/Api/SearchConcept/GetConceptByCharacterAndCategoryApi.d.ts

@@ -1,2 +1,12 @@
 import { Concept } from "../../DataStructures/Concept";
+/**
+ * Retrieves a concept by character value with category filtering.
+ * Fetches concept matching character and adds type information.
+ *
+ * @param characterValue - Character value string to search for
+ * @returns Concept object or default concept if not found
+ *
+ * @example
+ * const concept = await GetConceptByCharacterAndCategoryApi("the_person");
+ */
 export declare function GetConceptByCharacterAndCategoryApi(characterValue: string): Promise<Concept | undefined>;

package/dist/types/Api/SearchConcept/GetConceptByCharacterAndCategoryDirect.d.ts

@@ -1,2 +1,13 @@
 import { Concept } from "./../../DataStructures/Concept";
+/**
+ * Retrieves a concept by character value and specific category ID.
+ * Direct API call with explicit category filtering.
+ *
+ * @param characterValue - Character value string to search for
+ * @param category_id - Category ID to filter by
+ * @returns Promise resolving to Concept object or default concept if not found
+ *
+ * @example
+ * const concept = await GetConceptByCharacterAndCategoryDirectApi("the_person", 5);
+ */
 export declare function GetConceptByCharacterAndCategoryDirectApi(characterValue: string, category_id: number): Promise<Concept>;

package/dist/types/Api/SearchConcept/GetTypeConceptByBulk.d.ts

@@ -1,2 +1,15 @@
 import { Concept } from "../../app";
+/**
+ * Retrieves type concepts for multiple character values in bulk.
+ * Optimizes fetching by batching character lookups in one request.
+ *
+ * **Complex Logic**: First fetches concept IDs for all character strings,
+ * then bulk-fetches the full concept objects.
+ *
+ * @param characters - Array of character value strings
+ * @returns Array of Concept objects matching the character values
+ *
+ * @example
+ * const concepts = await GetTypeConceptByBulk(["the_person", "the_place", "the_thing"]);
+ */
 export declare function GetTypeConceptByBulk(characters: string[]): Promise<Concept[]>;

package/dist/types/Api/Session/CreateSession.d.ts

@@ -1,2 +1,16 @@
 import { SessionData } from "../../app";
+/**
+ * Creates a new session for tracking user activity.
+ * Records session metadata including user agent, IP, and timestamp.
+ *
+ * @param sessionData - SessionData object containing session information
+ * @returns Session object with generated ID, or null on error
+ *
+ * @example
+ * const session = await CreateSession({
+ *   userAgent: navigator.userAgent,
+ *   ipAddress: "192.168.1.1",
+ *   userId: 123
+ * });
+ */
 export declare function CreateSession(sessionData: SessionData): Promise<any>;

package/dist/types/Api/Session/CreateSessionVisit.d.ts

@@ -1 +1,12 @@
+/**
+ * Records a URL visit within an existing session.
+ * Tracks page navigation and user journey through the application.
+ *
+ * @param sessionId - ID of the session to associate the visit with
+ * @param url - URL being visited
+ * @returns Session visit object or null on error
+ *
+ * @example
+ * await CreateSessionVisit(456, "/dashboard/profile");
+ */
 export declare function CreateSessionVisit(sessionId: number, url: string): Promise<any>;

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

@@ -1,3 +1,24 @@
 import { FreeschemaResponse } from "../DataStructures/Responses/StandardResponses";
 import { SigninModel } from "../DataStructures/SigninModel";
+/**
+ * Alternative sign-in function using SigninModel structure.
+ *
+ * Similar to LoginToBackend but returns FreeschemaResponse format and
+ * does NOT automatically store the token. You must manually handle the token.
+ *
+ * @param signinInfo - SigninModel object containing email and password
+ * @returns FreeschemaResponse with {status, statusCode, message, data} structure
+ *         data contains user information and token (not auto-stored)
+ *
+ * @example
+ * const result = await Signin({
+ *   email: "user@example.com",
+ *   password: "password123"
+ * });
+ * if (result.status) {
+ *   const token = result.data.token; // Manual token handling required
+ * }
+ *
+ * @see {@link LoginToBackend} for auto-token-storage version
+ */
 export default function Signin(signinInfo: SigninModel): Promise<FreeschemaResponse | undefined>;

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

@@ -1,19 +1,61 @@
 import { FreeschemaResponse } from "../DataStructures/Responses/StandardResponses";
 import { SignupModel } from "../DataStructures/SignupModel";
+/**
+ * Registers a new user account on the backend server.
+ *
+ * Creates a new user with provided signup information including email, password,
+ * username, and profile details.
+ *
+ * @param signupModel - SignupModel object containing:
+ *   - email: User's email address
+ *   - password: User's password
+ *   - username: Unique username
+ *   - fname: First name
+ *   - lname: Last name
+ *   - title: Title/gender
+ *   - type: User type
+ * @returns FreeschemaResponse with signup result (status, message, data)
+ *
+ * @example
+ * const result = await Signup({
+ *   email: "newuser@example.com",
+ *   password: "securePass123",
+ *   username: "newuser",
+ *   fname: "John",
+ *   lname: "Doe"
+ * });
+ * if (result.status) {
+ *   console.log("Account created successfully");
+ * }
+ */
 export default function Signup(signupModel: SignupModel): Promise<FreeschemaResponse | undefined>;
 /**
+ * Registers a new entity (organization/company account) on the backend.
+ *
+ * Creates entity-type accounts (different from regular user accounts).
+ * Includes timestamp for registration tracking.
+ *
+ * @param signupData - Signup data object containing:
+ *   - type: Entity type
+ *   - username: Unique username
+ *   - title: Title/designation
+ *   - email: Entity email
+ *   - password: Account password
+ *   - timestamp: Registration timestamp (ISO string)
+ *   - fname: First name / Entity name
+ *   - lname: Last name / Additional info
+ * @returns Response JSON with entity creation result
+ * @throws Error if signup fails (404, 500, or other HTTP errors)
  *
- * @param signupData
- *   const signupData: any = {
- *   type: typeValue,
- *   username: usernameValue,
- *   title: genderValue,
- *   email: emailValue,
- *   password: passwordValue,
+ * @example
+ * const result = await SignupEntity({
+ *   type: "organization",
+ *   username: "acme_corp",
+ *   email: "admin@acme.com",
+ *   password: "securePass",
  *   timestamp: new Date().toISOString(),
- *   fname: firstNameValue,
- *   lname: lastNameValue,
- * };
- * @returns
+ *   fname: "ACME Corporation",
+ *   lname: "Inc."
+ * });
  */
 export declare function SignupEntity(signupData: any): Promise<any>;

package/dist/types/Api/Translate/TranslateLocalToReal.d.ts

@@ -1,2 +1,12 @@
 import { Concept } from "../../app";
+/**
+ * Translates a local concept ID to its real backend concept.
+ * Fetches the actual concept from backend and caches it in ConceptsData.
+ *
+ * @param conceptId - Local concept ID to translate
+ * @returns Real Concept object from backend, or default concept on error
+ *
+ * @example
+ * const realConcept = await TranslateLocalToReal(123);
+ */
 export declare function TranslateLocalToReal(conceptId: number): Promise<Concept>;

package/dist/types/Api/View/ViewInternalDataApi.d.ts

@@ -1 +1,15 @@
+/**
+ * Retrieves internal data (connections and concepts) for multiple compositions.
+ * Returns a dictionary mapping composition IDs to their internal connection arrays.
+ *
+ * **Complex Logic**: For each composition ID, fetches connections and related concepts,
+ * builds a dictionary structure, and bulk-loads concepts for efficiency.
+ *
+ * @param ids - Array of composition IDs to fetch internal data for
+ * @returns Dictionary mapping composition ID to Connection arrays, or empty array on error
+ *
+ * @example
+ * const internalData = await ViewInternalDataApi([123, 456, 789]);
+ * // Returns: { 123: [...connections], 456: [...connections], 789: [...connections] }
+ */
 export declare function ViewInternalDataApi(ids: number[]): Promise<any>;

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

@@ -78,6 +78,7 @@ export declare class BaseUrl {
     static sendBulkMail(): string;
     static getWidgetData(): string;
     static getLatestWidgetData(): string;
+    static getRecentWidgetData(): string;
     static getConnectionsByTypes(): string;
     static CreatePrototypeUrl(): string;
     static GetCachedImage(ImageName: string): string;

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

@@ -0,0 +1,30 @@
+import { Concept } from "../Concept";
+import { Connection } from "../Connection";
+export declare class Transaction {
+    protected transactionId: string;
+    actions: InnerActions;
+    protected success: boolean;
+    constructor();
+    initialize(): Promise<void>;
+    /**
+   * Method to move concepts and connection to transaction collection
+   * @param concept Concept
+   */
+    protected markAction(): Promise<void>;
+    /**
+   * Method to rollback all the tranctions occured
+   */
+    rollbackTransaction(): Promise<void>;
+    commitTransaction(): Promise<void>;
+    /**
+   * Concepts
+   */
+    MakeTheInstanceConcept(type: string, referent: string, composition: boolean | undefined, userId: number, accessId: number, sessionInformationId?: number, referentId?: number): Promise<Concept>;
+    CreateConnection(ofTheConcept: Concept, toTheConcept: Concept, typeConnection: string): Promise<Connection>;
+    MakeTheTypeConcept(typeString: string, sessionId: number, sessionUserId: number, userId: number): Promise<Concept>;
+    CreateTheConnectionGeneral(ofTheConceptId: number, ofTheConceptUserId: number, toTheConceptId: number, toTheConceptUserId: number, typeId: number, sessionInformationId: number, sessionInformationUserId: number, orderId?: number, accessId?: number, passedUserId?: number): Promise<Connection>;
+}
+export interface InnerActions {
+    concepts: Concept[];
+    connections: Connection[];
+}

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

@@ -0,0 +1,19 @@
+import { PermissionSet } from './PermissionSet';
+export declare class AccessControlCacheService {
+    private readonly userAccessCache;
+    private readonly publicAccessCache;
+    private readonly baseUrl;
+    constructor();
+    loadCacheFromApi(entityId?: number): Promise<void>;
+    loadCacheFromJson(jsonData: any): void;
+    hasAccess(entityId: number, conceptId: number, required: PermissionSet): Promise<boolean>;
+    getAccessibleConcepts(entityId: number, conceptIds: number[], required: PermissionSet): Promise<number[]>;
+    getAccessByUser(entityId: number): Promise<Map<number, PermissionSet>>;
+    getAccessByConcept(conceptId: number): Promise<Map<number, PermissionSet>>;
+    deleteRecordByUserId(entityId: number): void;
+    deletePublicAccessRecordById(conceptId: number): void;
+    clearCache(): void;
+    getConceptsByPublicAccess(): Promise<Record<number, string[]>>;
+    hasPublicAccess(conceptId: number, required: PermissionSet): Promise<boolean>;
+    getConceptsWithPublicAccess(conceptIds: number[], required: PermissionSet): Promise<number[]>;
+}