mftsccs-browser 2.1.239-dev → 2.1.240-dev

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>;

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

@@ -0,0 +1,15 @@
+/**
+ * This is the basic function of the concept connection system. This function let's you create a concept within the constraints of the
+ * concept connection system. This function is the building block of the concept connection system.
+ * @param type this is the type of the concept. You can also think of this as the key of concept. first_name, last_name etc.
+ * @param referent the actual value of the concept. The actual name of value of the concept.
+ * @param composition this is a boolean that defines if the concept is a composition or not. If this is a composition then other things are also
+ * connected internally with this concept. If composition is true then always a new concept is created otherwise it checks if the concept already exists
+ * and creates only in the case that the concept does not already exists with its type and value as its unique identifier.
+ * @param userId the userId of the creator.
+ * @param passedAccessId this is the accessId of the creator. By default should be 4.
+ * @param passedSessionId this is the session that is created by the system.
+ * @param referentId In case we need this concept to refer to any other concept.
+ * @returns a concept which is either newly created or an older concept that already exists.
+ */
+export default function MakeTheInstanceConcept(type: string, referent: string, composition: boolean | undefined, userId: number, passedAccessId?: number, passedSessionId?: number, referentId?: number): Promise<any>;

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

@@ -0,0 +1 @@
+export declare function MakeTheTimestamp(type: string, referent: string, userId: number, accessId?: number, sessionInformationId?: number): Promise<any>;

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

@@ -0,0 +1 @@
+export declare function MakeTheTypeConcept(typeString: string, sessionId: number, sessionUserId: number, userId: number): Promise<any>;

package/dist/types/Services/Mqtt/publishMessage.d.ts

@@ -0,0 +1 @@
+export declare function publishMessage(topic: string, message: any): void;

package/dist/types/Services/Search/DataIdFormat.d.ts

@@ -0,0 +1,32 @@
+import { Connection } from "../../app";
+/**
+ * ## Format DATA-ID ##
+ * this function takes in connections and creates a single level objects so that all the data are added to its object/ array.
+ * This is then passed on further for stiching.
+ * @param connections
+ * @param compositionData
+ * @param reverse
+ * @returns
+ */
+export declare function FormatFunctionDataForData(connections: Connection[], compositionData: any[], reverse?: number[]): Promise<any[]>;
+/**
+ * ############ Format is data-id and is used for list. ############
+ * This is helpful in building a format that has multiple mainCompositions i.e. in the context of the list
+ * The list format is helpful because you do not have to go over each individual query.
+ * @param connections the type connections that need (external connections) to be passed
+ * @param compositionData  this is a dictionary type of format that has all the build compositions {id: { actual data}}
+ * @param mainComposition this is list of  ids of the main composition that builds the tree
+ * @param reverse this is the list of connections ids that needs to go to the reverse direction (to---->from)
+ * @returns
+ */
+export declare function FormatFromConnectionsAlteredArrayExternal(connections: Connection[], compositionData: any[], newCompositionData: any, mainComposition: number[], reverse: number[] | undefined, CountDictionary: any[]): Promise<any[]>;
+/**
+ * ## Format DATA-ID ##
+ * this function takes in connections and creates a single level objects so that all the data are added to its object/ array.
+ * This is then passed on further for stiching.
+ * @param connections
+ * @param compositionData
+ * @param reverse
+ * @returns
+ */
+export declare function FormatFunctionData(connections: Connection[], compositionData: any[], reverse?: number[]): Promise<any[]>;

package/dist/types/Services/Search/FormatData.d.ts

@@ -0,0 +1,36 @@
+import { Connection } from "../../app";
+/**
+ * ######### Format is normal ######### used for listing. This only provides type connections.
+ * This is helpful in building a format that has multiple mainCompositions i.e. in the context of the list
+ * The list format is helpful because you do not have to go over each individual query.
+ * @param connections the type connections that need (external connections) to be passed
+ * @param compositionData  this is a dictionary type of format that has all the build compositions {id: { actual data}}
+ * @param mainComposition this is list of  ids of the main composition that builds the tree
+ * @param reverse this is the list of connections ids that needs to go to the reverse direction (to---->from)
+ * @returns
+ */
+export declare function FormatConceptsAndConnectionsNormalList(connections: Connection[], compositionData: any[], mainComposition: number[], newCompositionData: any, reverse?: number[]): Promise<any[]>;
+/**
+ *
+ * ## Format Normal ##
+ * This function takes in the connections and then converts the connections to the single level objects for further processing
+ * This function is the builder of the arrays/ objects from the connections.
+ */
+export declare function formatFunction(connections: Connection[], compositionData: any, reverse: number[]): Promise<any>;
+/**
+*
+* ## Format Normal ##
+* This function takes in the connections and then converts the connections to the single level objects for further processing
+* This function is the builder of the arrays/ objects from the connections.
+*/
+export declare function formatFunctionForData(connections: Connection[], compositionData: any, reverse: number[]): Promise<any>;
+/**
+ * ## Format DATA-ID ##
+ * this function takes in connections and creates a single level objects so that all the data are added to its object/ array.
+ * This is then passed on further for stiching.
+ * @param connections
+ * @param compositionData
+ * @param reverse
+ * @returns
+ */
+export declare function FormatFunctionData(connections: Connection[], compositionData: any[], reverse?: number[]): Promise<any[]>;

package/dist/types/Services/Search/JustIdFormat.d.ts

@@ -0,0 +1,23 @@
+import { Connection } from "../../app";
+/**
+* ## Format Just-Id ##
+* this function takes in connections and creates a single level objects so that all the data are added to its object/ array.
+* This is then passed on further for stiching.
+* @param connections
+* @param compositionData
+* @param reverse
+* @returns
+*/
+export declare function FormatFunctionDataForDataJustId(connections: Connection[], compositionData: any[], reverse?: number[]): Promise<any[]>;
+/**
+ * ############ Format is Just Id and is used for list. ############
+ * This is helpful in building a format that has multiple mainCompositions i.e. in the context of the list
+ * The list format is helpful because you do not have to go over each individual query.
+ * @param connections the type connections that need (external connections) to be passed
+ * @param compositionData  this is a dictionary type of format that has all the build compositions {id: { actual data}}
+ * @param mainComposition this is list of  ids of the main composition that builds the tree
+ * @param reverse this is the list of connections ids that needs to go to the reverse direction (to---->from)
+ * @returns
+ */
+export declare function FormatFromConnectionsAlteredArrayExternalJustId(connections: Connection[], compositionData: any[], mainComposition: number[], reverse: number[] | undefined, CountDictionary: any[]): Promise<any[]>;
+export declare function AddCount(ofTheConceptId: number, CountDictionary: any, newData: any): void;

package/dist/types/Services/Search/NewFormat.d.ts

@@ -0,0 +1,4 @@
+import { Connection } from "../../app";
+export declare function FormatFunctionDataV2(connections: Connection[], compositionData?: Record<number, any>, reverse?: number[]): Promise<Record<number, any>>;
+export declare function FormatFunctionDataForDataV2(connections: Connection[], compositionData?: Record<number, any>, reverse?: number[]): Promise<Record<number, any>>;
+export declare function FormatFromConnectionsAlteredArrayExternalV2(connections: Connection[], compositionData: Record<number, any>, mainComposition: number[], reverse: number[] | undefined, CountDictionary: Record<number, any>): Promise<any[]>;

package/dist/types/Services/Search/SearchLinkInternal.d.ts

@@ -0,0 +1,3 @@
+import { SearchStructure } from "../../app";
+export declare function SearchLinkInternal(searchQuery: SearchStructure, token?: string): Promise<any[]>;
+export declare function SearchLinkInternalAll(searchQuery: SearchStructure, token?: string): Promise<any>;

package/dist/types/Services/Search/SearchLinkMultiple.d.ts

@@ -0,0 +1,55 @@
+import { SearchQuery } from "../../DataStructures/SearchQuery";
+import { Connection } from "../../app";
+export declare function SearchLinkMultipleAll(searchQuery: SearchQuery[], token?: string, caller?: any, format?: number): Promise<any>;
+/**
+ * ######### This layer builds the data. Format is dataid ##########
+ * @param linkers list of ids that help us
+ * @param conceptIds this is all the concept ids that need  to be composited
+ * @param connections these are the internal connections of the compositions that help in creating individual compositions
+ * @param reverse this is the list of connection ids that need to show reverse connections(to->from)
+ * @param mainCompositionId this is the main centre point of this data.
+ * @returns
+ */
+export declare function DataIdBuildLayer(linkers: number[], conceptIds: number[], connections: number[], reverse: number[], mainCompositionId: number, searchQuery: SearchQuery, format?: number): Promise<any>;
+/**
+ * ## Format is DATAID ##
+ * This  is altered format and is different from others because it passes all the connections prebuilt/prefetched
+ * This will not let the connections to be again fetched from the memory.
+ * @param connections the type connections that need (external connections) to be passed
+ * @param compositionData this is a dictionary type of format that has all the build compositions {id: { actual data}}
+ * @param mainComposition this is the id of the main composition that builds the tree
+ * @param reverse this is the list of connections ids that needs to go to the reverse direction (to---->from)
+ * @returns
+ */
+export declare function FormatFromConnectionsAltered(connections: Connection[], compositionData: any[], mainComposition: number, reverse?: number[]): Promise<any>;
+/**
+ * ######### Format is normal ######### used for listing.
+ * This is helpful in building a format that has multiple mainCompositions i.e. in the context of the list
+ * The list format is helpful because you do not have to go over each individual query.
+ * @param connections the type connections that need (external connections) to be passed
+ * @param compositionData  this is a dictionary type of format that has all the build compositions {id: { actual data}}
+ * @param mainComposition this is list of  ids of the main composition that builds the tree
+ * @param reverse this is the list of connections ids that needs to go to the reverse direction (to---->from)
+ * @returns
+ */
+export declare function FormatConceptsAndConnections(connections: Connection[], compositionData: any[], mainComposition: number[], reverse?: number[]): Promise<any[]>;
+/**
+ * ############ Format is data-id and is used for list. ############
+ * This is helpful in building a format that has multiple mainCompositions i.e. in the context of the list
+ * The list format is helpful because you do not have to go over each individual query.
+ * @param connections the type connections that need (external connections) to be passed
+ * @param compositionData  this is a dictionary type of format that has all the build compositions {id: { actual data}}
+ * @param mainComposition this is list of  ids of the main composition that builds the tree
+ * @param reverse this is the list of connections ids that needs to go to the reverse direction (to---->from)
+ * @returns
+ */
+export declare function FormatFromConnectionsAlteredArray(connections: Connection[], compositionData: any[], conceptIds: number[], mainComposition: number[], reverse?: number[]): Promise<any[]>;
+/**
+ * ########## Format works with JUSTDATA / NORMAL ########### used for single origin concept
+ * @param linkers this is the list of linkers that
+ * @param compositionData
+ * @param mainComposition
+ * @param reverse list of connection ids that need to show reverse conneciton.
+ * @returns
+ */
+export declare function FormatFromConnections(linkers: number[], compositionData: any[], mainComposition: number, reverse?: number[]): Promise<any>;

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

@@ -0,0 +1,82 @@
+import { SearchStructure, SearchQuery } from '../../app';
+import { CountInfo } from '../../DataStructures/Count/CountInfo';
+/**
+ * This function will help you search a concept by their type and also to query inside of it.
+ * Put the number of compositions you want to get in the searchStructure which can be set by inpage and page
+ * Then the type should be set in searchQuery for the compositionName.
+ * Inside the searchQuery array this you can set the full linker / listLinker in the searchQuery.
+ * This will give the id of the structures.
+ */
+export declare function SearchWithTypeAndLinkerDataId(searchStructure: SearchStructure, searchQuery: SearchQuery[], token?: string): Promise<any>;
+/**
+ * This function will help you search a concept by their type and also to query inside of it.
+ * Put the number of compositions you want to get in the searchStructure which can be set by inpage and page
+ * Then the type should be set in searchQuery for the compositionName.
+ * Inside the searchQuery array this you can set the full linker / listLinker in the searchQuery.
+ * This will not give the id of the structures.
+ */
+export declare function SearchWithTypeAndLinker(searchStructure: SearchStructure, searchQuery: SearchQuery[], token?: string): Promise<any>;
+/**
+ * ## Format dataid ##
+ * @param linkers
+ * @param conceptIds
+ * @param connections
+ * @param mainCompositionIds
+ * @param reverse
+ * @returns
+ */
+export declare function formatDataArrayDataId(linkers: number[], conceptIds: number[], connections: number[], mainCompositionIds: number[], reverse: number[]): Promise<any>;
+/**
+ * ## Format Normal ##
+ * @param linkers
+ * @param conceptIds
+ * @param connections
+ * @param mainCompositionIds
+ * @param reverse
+ * @returns
+ */
+export declare function formatDataArrayNormal(linkers: number[], conceptIds: number[], connections: number[], mainCompositionIds: number[], reverse: number[]): Promise<any>;
+/**
+ * ## Format Normal ##
+ * @param linkers
+ * @param conceptIds
+ * @param connections
+ * @param mainCompositionIds
+ * @param reverse
+ * @returns
+ */
+export declare function formatLinkersNormal(linkers: number[], conceptIds: number[], connections: number[], mainCompositionIds: number[], reverse: number[]): Promise<any>;
+/**
+ * ## Format Normal ##
+ * This function fetches all the connections and then converts all the connections to the single level connections
+ * Then those single level objects are then stiched together to create a complex json/ array.
+ * @param linkers
+ * @param conceptIds
+ * @param mainCompositionIds
+ * @param reverse
+ * @returns
+ */
+export declare function formatConnections(linkers: number[], conceptIds: number[], mainCompositionIds: number[], reverse: number[], countInfos: CountInfo[]): Promise<any>;
+/**
+ * ## Format JustId ##
+ * This function fetches all the connections and then converts all the connections to the single level connections
+ * Then those single level objects are then stiched together to create a complex json/ array.
+ * @param linkers
+ * @param conceptIds
+ * @param mainCompositionIds
+ * @param reverse
+ * @returns
+ */
+export declare function formatConnectionsJustId(linkers: number[], conceptIds: number[], mainCompositionIds: number[], reverse: number[], countInfos: CountInfo[], order?: string): Promise<any>;
+/**
+ * ## Format DATA-ID ##
+ * This function fetches all the connections and then converts all the connections to the single level connections
+ * Then those single level objects are then stiched together to create a complex json/ array.
+ * @param linkers
+ * @param conceptIds
+ * @param mainCompositionIds
+ * @param reverse
+ * @returns
+ */
+export declare function formatConnectionsDataId(linkers: number[], conceptIds: number[], mainCompositionIds: number[], reverse: number[], countInfos: CountInfo[], order?: string): Promise<any>;
+export declare function formatConnectionsV2(linkers: number[], conceptIds: number[], mainCompositionIds: number[], reverse: number[], countInfos: CountInfo[], order?: string): Promise<any>;

package/dist/types/Services/Search/orderingConnections.d.ts

@@ -0,0 +1,2 @@
+import { Connection } from "../../app";
+export declare function orderTheConnections(connections: Connection[], order?: string): Connection[];

package/dist/types/Services/Security/GetRequestHeader.d.ts

@@ -0,0 +1,6 @@
+type RequestHeader = Record<string, string>;
+export declare function GetRequestHeader(contentType?: string, Accept?: string): Promise<RequestHeader>;
+export declare function GetRequestHeaderWithAuthorization(contentType?: string, token?: string, Accept?: string): Promise<RequestHeader>;
+export declare function GetOnlyTokenHeader(): Promise<Headers>;
+export declare function getValidAccessToken(token?: string): Promise<string>;
+export {};

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

@@ -0,0 +1 @@
+export declare function SplitStrings(typeString: string): string[];

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

@@ -0,0 +1,117 @@
+import { Concept, InnerActions } from "../../app";
+import { FetchConnectionQuery } from "../../DataStructures/FetchConnection";
+export declare class LocalTransaction {
+    protected transactionId: string;
+    actions: InnerActions;
+    protected success: boolean;
+    protected pendingConnectionDeletions: number[];
+    constructor();
+    /**
+     * Method to initialize the transactions for specified transaction
+     */
+    initialize(): Promise<void>;
+    /**
+     * Method to commi the created Transactions
+     */
+    commitTransaction(): Promise<void>;
+    commitTransactionWithoutAuth(): Promise<void>;
+    /**
+     * Method to rollback all the tranctions occured
+     */
+    rollbackTransaction(): Promise<void>;
+    /**
+     * Method to move concepts and connection to transaction collection
+     * @param concept Concept
+     */
+    protected markAction(): Promise<void>;
+    /**
+     * Deletions
+     */
+    /**
+     * Queries the backend for connections matching the given criteria and queues all
+     * returned connection IDs for bulk deletion when commitTransaction() is called.
+     *
+     * **Nothing is deleted until commitTransaction() is called.**
+     * Calling rollbackTransaction() discards the queue without touching the backend.
+     *
+     * Supported query permutations:
+     * 1. `ofTheConceptId` + `toTheConceptId` + `type` — connections between two specific concepts
+     * 2. `ofTheConceptId` + `type`                    — all connections FROM a concept of that type
+     * 3. `toTheConceptId` + `type`                    — all connections TO a concept of that type
+     * 4. `typeId` + `isComposition: true`             — all internal connections of a composition
+     *
+     * For multiple queries in one go use {@link DeleteConnectionsBetweenBulk} — it sends
+     * all queries in a single HTTP request.
+     *
+     * @param query - Partial FetchConnectionQuery with only the fields relevant to your permutation.
+     * @returns The connection IDs queued for deletion by this call.
+     *
+     * @example
+     * // Delete all connections of type "the_project_s_page" from concept 103927382
+     * const ids = await transaction.DeleteConnectionsBetween({
+     *     ofTheConceptId: 103927382,
+     *     type: "the_project_s_page"
+     * });
+     * await transaction.commitTransaction(); // deletion fires here
+     *
+     * @example
+     * // Delete connections between two specific concepts
+     * await transaction.DeleteConnectionsBetween({
+     *     ofTheConceptId: 103927382,
+     *     toTheConceptId: 103927389,
+     *     type: "the_project_s_page"
+     * });
+     *
+     * @example
+     * // Delete all internal connections of a composition
+     * await transaction.DeleteConnectionsBetween({
+     *     typeId: 101490186,
+     *     isComposition: true
+     * });
+     *
+     * @see {@link DeleteConnectionsBetweenBulk} for sending multiple queries in one HTTP request
+     * @see {@link commitTransaction} where the queued deletions are executed via bulk delete
+     */
+    DeleteConnectionsBetween(query: Partial<FetchConnectionQuery>): Promise<number[]>;
+    /**
+     * Same as {@link DeleteConnectionsBetween} but resolves multiple queries in a single
+     * HTTP request to POST /api/get-connection-between.
+     *
+     * Prefer this over looping DeleteConnectionsBetween — all queries go to the backend
+     * in one round trip, and all returned IDs are merged into the same pending-deletion queue.
+     * The actual deletion still fires as a single bulk call inside commitTransaction().
+     *
+     * @param queries - Array of partial FetchConnectionQuery objects, one per query permutation.
+     * @returns All connection IDs queued for deletion across every query in this call.
+     *
+     * @example
+     * // Three different queries → one HTTP request to get IDs → one bulk delete on commit
+     * await transaction.DeleteConnectionsBetweenBulk([
+     *     { ofTheConceptId: 103927382, type: "the_project_s_page" },
+     *     { ofTheConceptId: 103927382, type: "the_project_s_tag" },
+     *     { typeId: 101490186, isComposition: true },
+     * ]);
+     * await transaction.commitTransaction();
+     *
+     * @see {@link DeleteConnectionsBetween} for the single-query convenience wrapper
+     * @see {@link commitTransaction} where the queued deletions are executed via bulk delete
+     */
+    DeleteConnectionsBetweenBulk(queries: Partial<FetchConnectionQuery>[]): Promise<number[]>;
+    /**
+     * Concepts
+     */
+    MakeTheInstanceConceptLocal(type: string, referent: string, composition: boolean | undefined, userId: number, accessId: number, sessionInformationId?: number, referentId?: number): Promise<any>;
+    MakeTheTypeConceptLocal(typeString: string, sessionId: number, sessionUserId: number, userId: number): Promise<Concept>;
+    CreateTheConceptLocal(referent: string, typecharacter: string, userId: number, categoryId: number, typeId: number, accessId: number, isComposition?: boolean, referentId?: number | null, actions?: InnerActions): Promise<any>;
+    /**
+     * Connections
+     */
+    CreateConnectionBetweenTwoConceptsLocal(ofTheConcept: Concept, toTheConcept: Concept, linker: string, both?: boolean): Promise<any>;
+    CreateTheConnectionLocal(ofTheConceptId: number, toTheConceptId: number, typeId: number, orderId?: number, typeString?: string, userId?: number): Promise<any>;
+    CreateConnection(ofTheConcept: Concept, toTheConcept: Concept, connectionTypeString: string): Promise<any>;
+    CreateConnectionBetweenEntityLocal(concept1Data: Concept, concept2Data: Concept, linker: string): Promise<any>;
+    /**
+     * Compositions
+     */
+    CreateTheCompositionLocal(json: any, ofTheConceptId?: number | null, ofTheConceptUserId?: number | null, mainKey?: number | null, userId?: number | null, accessId?: number | null, sessionInformationId?: number | null, automaticSync?: boolean): Promise<any>;
+}

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

@@ -0,0 +1,2 @@
+import { PatcherStructure } from "../DataStructures/PatcherStructure";
+export default function UpdateComposition(patcherStructure: PatcherStructure): Promise<any>;