mftsccs-browser 2.1.242-dev → 2.1.244-dev

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,7 @@
+type RequestHeader = Record<string, string>;
+export declare function GetRequestHeader(contentType?: string | null, Accept?: string): Promise<RequestHeader>;
+export declare function GetRequestHeaderWithAuthorization(contentType?: string | null, token?: string, Accept?: string): Promise<RequestHeader>;
+export declare function GetOnlyTokenHeader(): Promise<Headers>;
+export declare function fetchWithAuthRetry(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+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>;

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

@@ -0,0 +1,111 @@
+export declare const validImageFormats: string[];
+export declare const validDocumentFormats: string[];
+export interface R2UploadData {
+    key: string;
+    bucket: string;
+    contentType: string;
+    size: number;
+    eTag: string;
+    url: string;
+}
+export interface R2PresignedUploadUrlRequest {
+    fileName: string;
+    contentType: string;
+    folder?: string;
+    expiresInSeconds?: number;
+}
+export interface R2PresignedUploadUrlData {
+    uploadUrl: string;
+    key: string;
+    bucket: string;
+    contentType: string;
+    expiresInSeconds: number;
+    expiresAt: string;
+    publicUrl: string;
+}
+export interface R2PresignedUploadOptions {
+    fileName?: string;
+    contentType?: string;
+    folder?: string;
+    expiresInSeconds?: number;
+}
+export interface R2PresignedUploadResult {
+    message: string;
+    success: boolean;
+    url?: string;
+    data?: R2PresignedUploadUrlData;
+    eTag?: string | null;
+}
+export interface UploadResponse<T = string | R2UploadData> {
+    message: string;
+    success: boolean;
+    data?: T;
+}
+type UploadFileParam = Blob & {
+    name?: string;
+    type?: string;
+    uri?: string;
+};
+/**
+ * Generic method to upload file or image
+ * @param file File
+ * @returns Promise<{message: string, success: boolean, url?: string}>
+ */
+export declare function uploadAttachment(file: File, token?: string): Promise<{
+    message: string;
+    success: boolean;
+    url?: string;
+}>;
+/**
+ * Method to upload a file or image to R2 storage.
+ * @param body FormData. Append the file under the "file" key.
+ * @param token string?
+ * @returns UploadResponse<R2UploadData> | null
+ */
+export declare function uploadR2Storage(body: FormData, token?: string): Promise<UploadResponse<R2UploadData> | null>;
+/**
+ * Method to request an R2 pre-signed upload URL from the backend.
+ * @param body Request metadata for the file to upload.
+ * @param token string?
+ * @returns UploadResponse<R2PresignedUploadUrlData> | null
+ */
+export declare function getR2PresignedUploadUrl(body: R2PresignedUploadUrlRequest, token?: string): Promise<UploadResponse<R2PresignedUploadUrlData> | null>;
+/**
+ * Method to upload a file body to a pre-signed R2 URL.
+ * @param uploadUrl URL returned by getR2PresignedUploadUrl
+ * @param file Blob/File, raw body, or compatible file-like object
+ * @param contentType Must match the contentType used when creating the signed URL.
+ * @returns Response from R2
+ */
+export declare function uploadToR2PresignedUrl(uploadUrl: string, file: UploadFileParam | Blob | BodyInit | any, contentType: string): Promise<Response>;
+/**
+ * Full R2 pre-signed upload workflow: create URL, PUT file to R2, return public URL.
+ * @param file Blob/File, raw body, or compatible file-like object
+ * @param options Optional fileName/contentType/folder/expiresInSeconds overrides.
+ * @param token string?
+ * @returns R2PresignedUploadResult
+ */
+export declare function uploadWithR2PresignedUrl(file: UploadFileParam | Blob | BodyInit | any, options?: R2PresignedUploadOptions, token?: string): Promise<R2PresignedUploadResult>;
+/**
+ * Method to upload image to server
+ * @param body FormData
+ * @param token string?
+ * @returns JSON | string | null
+ */
+export declare function uploadImage(body: FormData, token?: string): Promise<R2PresignedUploadResult>;
+/**
+ * Method to upload image to server
+ * @param body FormData
+ * @param token string?
+ * @returns JSON | string | null
+ */
+export declare function uploadImageV2(body: FormData, token?: string): Promise<UploadResponse<string | R2UploadData> | null>;
+/**
+ * Method to upload file to server
+ * @param body FormData
+ * @param token string?
+ * @returns JSON | string | null
+ */
+export declare function uploadFile(body: FormData, token?: string): Promise<UploadResponse<R2UploadData> | null>;
+export declare function getUploadFileLimit(): Promise<{}>;
+export {};

package/dist/types/Services/User/UserFromLocalStorage.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Returns user details synchronously.
+ * Priority: in-memory profileCache (encrypted) → legacy localStorage("profile") fallback.
+ */
+export declare function getUserDetails(): Record<string, any>;
+/**
+ * Returns user details after hydrating storage and refreshing an expired token.
+ * Use this when callers need a valid token from the user details object.
+ */
+export declare function getUserDetailsWithRefresh(): Promise<Record<string, any>>;

package/dist/types/Services/User/UserTranslation.d.ts

@@ -0,0 +1,3 @@
+import { Concept } from './../../DataStructures/Concept';
+export declare function GetUserGhostId(userId: number, ghostId: number, sessionId?: number): Promise<Concept>;
+export declare function AddGhostConcept(concept: Concept, userId: number, sessionId?: number): Promise<void>;

package/dist/types/Services/View/ViewInternalData.d.ts

@@ -0,0 +1 @@
+export declare function ViewInternalData(ids: number[]): Promise<any[]>;

package/dist/types/Services/assets/GetImageService.d.ts

@@ -0,0 +1,14 @@
+/**
+ *
+ * @param url this is the url of the image that you have. This image will be cached in the cache server
+ * @param format this is the format it can be either normal , small, by default it is normal
+ * @returns
+ */
+export declare function GetFreeschemaImage(url: string, format?: string): Promise<any>;
+/**
+ *
+ * @param url this is the url of the image that you have. This image will be cached in the cache server
+ * @param format this is the format it can be either normal , small, by default it is normal
+ * @returns
+ */
+export declare function GetFreeschemaImageUrl(url: string, format?: string): string;

package/dist/types/Services/automated/automated-concept-connection.d.ts

@@ -0,0 +1,7 @@
+import { Concept, InnerActions } from "../../app";
+export declare function CreateData(json: any, ofConcept?: Concept | null, typeConcept?: string, actions?: InnerActions): Promise<any>;
+export declare function removePrefix(key: string): string;
+export declare function addPrefix(key: string): string;
+export declare function addArrayPrefix(key: string): string;
+export declare function removeArrayPrefix(key: string): string;
+export declare function createTypeString(typeConceptString: string, key: any): string;

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

@@ -0,0 +1 @@
+export declare function requestNextCacheServer(requestData: any, url: string): Promise<Response>;

package/dist/types/Validator/constant.d.ts

@@ -0,0 +1,3 @@
+export declare const DATA_TYPES_RULES: {
+    [key: string]: RegExp;
+};

package/dist/types/Validator/interface.d.ts

@@ -0,0 +1,19 @@
+export interface FormErrors {
+    [key: string]: {} | undefined;
+}
+export interface FormFieldData {
+    name: string | null;
+    value: string | null;
+    type?: string | null;
+    dataType?: string | null;
+    pattern?: string | null;
+    conceptType?: string | null;
+    maxLength?: number | null;
+    minLength?: number | null;
+    minValue?: number | null;
+    maxValue?: number | null;
+    accept?: string | null;
+    file?: File | null;
+    required?: boolean;
+    isUnique?: boolean;
+}

package/dist/types/Validator/utils.d.ts

@@ -0,0 +1,7 @@
+import { FormFieldData } from "./interface";
+/**
+ * Utility function to get input field data and attributes
+ * @param fieldName - The Name of the form field.
+ * @returns - An object containing the field's value and constraints (type, maxLength, etc.).
+ */
+export declare const createFormFieldData: (fieldName: string) => FormFieldData;

package/dist/types/Validator/validator.d.ts

@@ -0,0 +1,37 @@
+import { FormErrors, FormFieldData } from "./interface";
+export declare class Validator {
+    /**
+     * Checks if a concept with the given type and value is unique.
+     * @param type concept type where to check
+     * @param value value to check
+     * @returns boolean indicating uniqueness
+     */
+    checkUniqueness(type: string, value: string): Promise<boolean>;
+    /**
+     * Validates a single form field based on its constraints and uniqueness.
+     * @param options - An object containing field properties including name, value, type, and validation constraints.
+     * @returns An object containing validation errors if validation fails.
+     */
+    validateField(options: FormFieldData): Promise<{
+        [fieldName: string]: string;
+    }>;
+    /**
+     * Validates all form fields by iterating over the provided form data.
+     * It checks each field's value, data type, and constraints, collecting errors where necessary.
+     *
+     * @param formData - An object representing the form data, where each key is a field name
+     *                   and each value is an object containing the `value`, `dataType`, and constraints (e.g., `maxLength`, `minLength`).
+     *
+     * @returns An object containing validation errors for fields that failed validation.
+     *          If no errors exist, the object will be empty.
+     */
+    validateForm(formData: {
+        [key: string]: FormFieldData;
+    }): Promise<FormErrors>;
+    /**
+     * Take field element attributes
+     * @param options  Object conist of attributes
+     * @returns Object with status and details
+     */
+    validate(options: FormFieldData): any;
+}