totalum-api-sdk 2.0.42 → 3.0.0

package/dist/common/fetch-client.d.ts

@@ -0,0 +1,24 @@
+import { TotalumApiResponse, TotalumHeaders, ErrorResult } from './interfaces';
+export declare class TotalumError extends Error {
+    errorCode: string;
+    errorMessage: string;
+    hasManyErrors?: boolean;
+    multipleErrors?: {
+        errorCode: string;
+        errorMessage: string;
+    }[];
+    constructor(errorResult: ErrorResult);
+    toJSON(): ErrorResult;
+}
+export declare class FetchClient {
+    private baseUrl;
+    private headers;
+    constructor(baseUrl: string, headers: TotalumHeaders);
+    private handleResponse;
+    request<T>(endpoint: string, options?: RequestInit): Promise<TotalumApiResponse<T>>;
+    get<T>(endpoint: string, params?: Record<string, any>): Promise<TotalumApiResponse<T>>;
+    post<T>(endpoint: string, body?: any): Promise<TotalumApiResponse<T>>;
+    patch<T>(endpoint: string, body?: any): Promise<TotalumApiResponse<T>>;
+    delete<T>(endpoint: string): Promise<TotalumApiResponse<T>>;
+    put<T>(endpoint: string, body?: any): Promise<TotalumApiResponse<T>>;
+}

package/dist/common/fetch-client.js

@@ -0,0 +1,127 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchClient = exports.TotalumError = void 0;
+class TotalumError extends Error {
+    constructor(errorResult) {
+        super(errorResult.errorMessage);
+        this.errorCode = errorResult.errorCode;
+        this.errorMessage = errorResult.errorMessage;
+        this.hasManyErrors = errorResult.hasManyErrors || false;
+        this.multipleErrors = errorResult.multipleErrors || [];
+        this.name = 'TotalumError';
+        Object.setPrototypeOf(this, TotalumError.prototype);
+    }
+    toJSON() {
+        return {
+            errorCode: this.errorCode,
+            errorMessage: this.errorMessage,
+            hasManyErrors: this.hasManyErrors,
+            multipleErrors: this.multipleErrors
+        };
+    }
+}
+exports.TotalumError = TotalumError;
+class FetchClient {
+    constructor(baseUrl, headers) {
+        this.baseUrl = baseUrl;
+        this.headers = headers;
+    }
+    handleResponse(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let jsonData;
+            try {
+                jsonData = yield response.json();
+            }
+            catch (e) {
+                // If response is not JSON, return error structure
+                return {
+                    errors: {
+                        errorCode: 'RESPONSE_PARSE_ERROR',
+                        errorMessage: `Failed to parse response: ${response.statusText}`
+                    }
+                };
+            }
+            // Always return the API response structure {data, errors}
+            // Even on HTTP errors, the API returns this structure
+            return jsonData;
+        });
+    }
+    request(endpoint, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = this.baseUrl + endpoint;
+            try {
+                const response = yield fetch(url, Object.assign(Object.assign({}, options), { headers: Object.assign(Object.assign({}, this.headers), options === null || options === void 0 ? void 0 : options.headers) }));
+                return this.handleResponse(response);
+            }
+            catch (error) {
+                // Network error or fetch failed
+                return {
+                    errors: {
+                        errorCode: 'NETWORK_ERROR',
+                        errorMessage: error instanceof Error ? error.message : 'Network request failed'
+                    }
+                };
+            }
+        });
+    }
+    get(endpoint, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let url = endpoint;
+            if (params) {
+                const queryString = new URLSearchParams(Object.entries(params).reduce((acc, [key, value]) => {
+                    if (value !== undefined && value !== null) {
+                        acc[key] = String(value);
+                    }
+                    return acc;
+                }, {})).toString();
+                if (queryString) {
+                    url += '?' + queryString;
+                }
+            }
+            return this.request(url, { method: 'GET' });
+        });
+    }
+    post(endpoint, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isFormData = body instanceof FormData;
+            return this.request(endpoint, {
+                method: 'POST',
+                headers: isFormData ? {} : { 'Content-Type': 'application/json' },
+                body: isFormData ? body : JSON.stringify(body),
+            });
+        });
+    }
+    patch(endpoint, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request(endpoint, {
+                method: 'PATCH',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(body),
+            });
+        });
+    }
+    delete(endpoint) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request(endpoint, { method: 'DELETE' });
+        });
+    }
+    put(endpoint, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request(endpoint, {
+                method: 'PUT',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(body),
+            });
+        });
+    }
+}
+exports.FetchClient = FetchClient;

package/dist/common/interfaces.d.ts

@@ -1,3 +1,16 @@
+export interface ErrorResult {
+    errorCode: string;
+    errorMessage: string;
+    hasManyErrors?: boolean;
+    multipleErrors?: {
+        errorCode: string;
+        errorMessage: string;
+    }[];
+}
+export interface TotalumApiResponse<T> {
+    data?: T;
+    errors?: ErrorResult | null;
+}
 export interface StructureLevels {
     id: string;
     typeId: string;
@@ -60,13 +73,15 @@ export interface PropertyQueryOptionsI {
     lt?: number | Date;
     ne?: number | Date | boolean | string;
 }
-export type fieldValuesEnabled = null | string | number | boolean | Date | {
+export type fieldValuesEnabled = string | number | boolean | Date | fieldFileI | fieldFileI[];
+export type FileTypesI = 'image' | 'video' | 'audio' | 'word' | 'pdf' | 'excel' | 'other';
+export type fieldFileI = {
     name: string;
-} | {
-    lastUsersActions?: {
-        [key: string]: any;
-    };
+    url: string;
+    type?: FileTypesI;
+    order?: number;
 };
+export type fieldTypesEnabled = 'string' | 'number' | 'boolean' | 'date' | 'options' | 'file' | 'long-string' | /*'array' |*/ 'objectReference';
 export interface DataValues {
     _id: string;
     createdAt: Date;
@@ -88,6 +103,12 @@ export interface AuthOptions {
     };
     baseUrl?: string;
 }
+export interface TotalumHeaders {
+    authorization?: string;
+    'api-key'?: string;
+    fromEvent?: string;
+    [key: string]: string | undefined;
+}
 export interface NotificationI {
     name: string;
     title: string;

package/dist/common/response-types.d.ts

@@ -0,0 +1,210 @@
+import { DataValues } from './interfaces';
+export { DataValues };
+/**
+ * Response metadata (optional, used in some endpoints)
+ */
+export interface ResponseMetadata {
+    count?: number;
+    ocrFullResult?: any;
+    ocrFullResultText?: string;
+    usageUnits?: number;
+    exactUsageUnits?: number;
+    [key: string]: any;
+}
+export interface DeleteObjectResponse {
+    /** Indicates whether this write result was acknowledged. If not, then all other members of this result will be undefined. */
+    acknowledged: boolean;
+    /** The number of documents that were deleted */
+    deletedCount: number;
+}
+export interface GetObjectsResponse<T = DataValues> {
+    data: T[];
+    metadata?: {
+        count?: number;
+    };
+}
+export interface FileUploadResponse {
+    fileName: string;
+}
+export interface FileDownloadUrlResponse {
+    url: string;
+}
+export interface FileDeleteResponse {
+    success: boolean;
+    message?: string;
+}
+export interface OcrImageResponse {
+    text: string;
+    confidence?: number;
+    fullDetails?: any;
+}
+export interface OcrPdfResponse {
+    text: string;
+    pages?: Array<{
+        text: string;
+        pageNumber: number;
+    }>;
+    fullDetails?: any;
+}
+export interface InvoiceLineItem {
+    fullDescription: string;
+    productReference?: string;
+    quantity: number;
+    unitPrice?: number;
+    taxes: number;
+    total: number;
+}
+export interface ScanInvoiceData {
+    totalAmountIncludingTaxes: number;
+    totalAmountExcludingTaxes: number;
+    dateOfInvoice: string;
+    irpf: number;
+    iva: number;
+    complete_invoice_number: string;
+    currency: "EUR" | "USD" | "GBP" | "OTHER";
+    fullNameOfCompanyIssuingInvoice: string;
+    addressOfCompanyIssuingInvoice: string;
+    nif_cif: string;
+    postalCode: string;
+    city: string;
+    province: string;
+    country: string;
+    invoiceListItems?: InvoiceLineItem[];
+    extraFields?: {
+        [key: string]: any;
+    };
+}
+export interface ScanInvoiceResponse {
+    data: ScanInvoiceData;
+    metadata: {
+        ocrFullResult?: any;
+        usageUnits: number;
+        exactUsageUnits: number;
+    };
+}
+export interface ScanDocumentResponse {
+    data: any;
+    metadata: {
+        ocrFullResult?: any;
+        ocrFullResultText?: string;
+        usageUnits: number;
+        exactUsageUnits: number;
+    };
+}
+export interface PdfGenerationResponse {
+    fileName: string;
+}
+export interface EmailSendResponse {
+    success: true;
+    message: string;
+    messageId: string;
+    data?: any;
+}
+export interface OpenAIUsage {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+}
+export interface OpenAICompletionChoice {
+    text: string;
+    index: number;
+    logprobs: any;
+    finish_reason: string;
+}
+export interface OpenAICompletionResponse {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: OpenAICompletionChoice[];
+    usage: OpenAIUsage;
+}
+export interface OpenAIChatMessage {
+    role: string;
+    content: string;
+}
+export interface OpenAIChatCompletionChoice {
+    index: number;
+    message: OpenAIChatMessage;
+    finish_reason: string;
+}
+export interface OpenAIChatCompletionResponse {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: OpenAIChatCompletionChoice[];
+    usage: OpenAIUsage;
+}
+export interface ImageGenerationResponse {
+    fileName: string;
+}
+export interface LookupFilterResult {
+    result: DataValues[] | number;
+    count?: number;
+}
+export interface NestedFilterResponse {
+    data: DataValues[];
+    metadata?: {
+        count?: number;
+    };
+}
+export type CustomAggregationResponse = any;
+export interface NotificationVisibility {
+    sendTo: "all" | "admins" | "specificUsers";
+    specificUsersEmails?: string[];
+}
+export interface NotificationAction {
+    actionType: "link" | "none";
+    actionName?: string;
+    link?: string;
+}
+export interface NotificationEmail {
+    sendEmail: boolean;
+    totalumSupportBtn?: boolean;
+}
+export interface NotificationResponse {
+    _id: string;
+    name: string;
+    type?: string;
+    title: string;
+    description: string;
+    visibility: NotificationVisibility;
+    action?: NotificationAction;
+    email?: NotificationEmail;
+    createdAt: Date | string;
+}
+export type StatisticResponse = number;
+export interface UpdateRecordChange {
+    timestamp: Date | string;
+    userId: string;
+    changes: any;
+}
+export interface UpdatesRecordResponse {
+    _id: string;
+    objectId: string;
+    typeId: string;
+    updates: UpdateRecordChange[];
+}
+export interface CreateRecordResponse {
+    acknowledged: boolean;
+    insertedId: string;
+}
+export interface UpdatedRecordResponse {
+    /** Indicates whether this write result was acknowledged. If not, then all other members of this result will be undefined */
+    acknowledged: boolean;
+    /** The number of documents that matched the filter */
+    matchedCount?: number;
+    /** The number of documents that were modified */
+    modifiedCount?: number;
+    /** The number of documents that were upserted */
+    upsertedCount?: number;
+    /** The identifier of the inserted document if an upsert took place */
+    upsertedId?: string;
+}
+export interface ManyToManyReferenceResponse {
+    acknowledged: boolean;
+    matchedCount?: number;
+    modifiedCount?: number;
+}
+export type UpdatesRecordResponseOrEmpty = UpdatesRecordResponse | [];

package/dist/common/response-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -7,11 +7,14 @@ import { NotificationService } from './services/NotificationService';
 import { StatisticService } from './services/StatisticService';
 import { EmailService } from './services/EmailService';
 export * from './common/interfaces';
+export * from './common/response-types';
 export { EmailPayloadI } from './services/EmailService';
+export { TotalumError } from './common/fetch-client';
 export declare class TotalumApiSdk {
     private authOptions;
     private _baseUrl;
     private _headers;
+    private client;
     openai: OpenaiService;
     files: FilesService;
     filter: FilterService;

package/dist/index.js

@@ -14,7 +14,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TotalumApiSdk = void 0;
+exports.TotalumApiSdk = exports.TotalumError = void 0;
+const fetch_client_1 = require("./common/fetch-client");
 const OpenaiService_1 = require("./services/OpenaiService");
 const FilterService_1 = require("./services/FilterService");
 const FilesService_1 = require("./services/FilesService");
@@ -22,21 +23,23 @@ const CrudService_1 = require("./services/CrudService");
 const NotificationService_1 = require("./services/NotificationService");
 const StatisticService_1 = require("./services/StatisticService");
 const EmailService_1 = require("./services/EmailService");
+// Export all interfaces and types
 __exportStar(require("./common/interfaces"), exports);
+__exportStar(require("./common/response-types"), exports);
+var fetch_client_2 = require("./common/fetch-client");
+Object.defineProperty(exports, "TotalumError", { enumerable: true, get: function () { return fetch_client_2.TotalumError; } });
 class TotalumApiSdk {
     constructor(authOptions) {
         var _a, _b;
         this._baseUrl = 'https://api.totalum.app/';
         this.authOptions = authOptions;
+        // Initialize headers
+        this._headers = {};
         if ((_a = this.authOptions.token) === null || _a === void 0 ? void 0 : _a.accessToken) {
-            this._headers = {
-                authorization: this.authOptions.token.accessToken
-            };
+            this._headers.authorization = this.authOptions.token.accessToken;
         }
         else if ((_b = this.authOptions.apiKey) === null || _b === void 0 ? void 0 : _b['api-key']) {
-            this._headers = {
-                'api-key': this.authOptions.apiKey['api-key'],
-            };
+            this._headers['api-key'] = this.authOptions.apiKey['api-key'];
         }
         else {
             throw new Error('Error: invalid auth options');
@@ -44,25 +47,28 @@ class TotalumApiSdk {
         if (this.authOptions.baseUrl) {
             this._baseUrl = this.authOptions.baseUrl;
         }
-        // @ts-ignore
+        // @ts-ignore - fromEvent is an internal property
         if (this.authOptions.fromEvent) {
-            this._headers['fromEvent'] = 'true';
+            this._headers.fromEvent = 'true';
         }
         this.setRequestData();
     }
     changeBaseUrl(newBaseUrl) {
         this._baseUrl = newBaseUrl;
-        //update services with new implementation
+        // Update services with new base URL
         this.setRequestData();
     }
     setRequestData() {
-        this.crud = new CrudService_1.CrudService(this._baseUrl, this._headers);
-        this.openai = new OpenaiService_1.OpenaiService(this._baseUrl, this._headers);
-        this.files = new FilesService_1.FilesService(this._baseUrl, this._headers);
-        this.filter = new FilterService_1.FilterService(this._baseUrl, this._headers);
-        this.notification = new NotificationService_1.NotificationService(this._baseUrl, this._headers);
-        this.statistic = new StatisticService_1.StatisticService(this._baseUrl, this._headers);
-        this.email = new EmailService_1.EmailService(this._baseUrl, this._headers);
+        // Create fetch client with base URL and headers
+        this.client = new fetch_client_1.FetchClient(this._baseUrl, this._headers);
+        // Initialize all services with the fetch client
+        this.crud = new CrudService_1.CrudService(this.client);
+        this.openai = new OpenaiService_1.OpenaiService(this.client);
+        this.files = new FilesService_1.FilesService(this.client);
+        this.filter = new FilterService_1.FilterService(this.client);
+        this.notification = new NotificationService_1.NotificationService(this.client);
+        this.statistic = new StatisticService_1.StatisticService(this.client);
+        this.email = new EmailService_1.EmailService(this.client);
     }
 }
 exports.TotalumApiSdk = TotalumApiSdk;

package/dist/services/CrudService.d.ts

@@ -1,48 +1,84 @@
-import { FilterSearchQueryI, NestedQuery } from "../common/interfaces";
+import { FilterSearchQueryI, NestedQuery, TotalumApiResponse } from "../common/interfaces";
+import { CreateRecordResponse, DataValues, DeleteObjectResponse, UpdatedRecordResponse, UpdatesRecordResponse } from "../common/response-types";
+import { FetchClient } from "../common/fetch-client";
 export declare class CrudService {
-    private headers;
-    private baseUrl;
-    constructor(baseUrl: string, headers: any);
+    private client;
+    constructor(client: FetchClient);
     /**
-     * Fetches an item by its ID.
-     * @param {string} itemType - The type of the item. (table name)
-     * @param {string} id - The ID of the item.
-     * @returns {Promise<any>} - A promise that resolves to the item data.
+     * Fetches a record by its ID.
+     * @param {string} tableName - The type of the record. (table name)
+     * @param {string} id - The ID of the record.
+     * @returns {Promise<TotalumApiResponse<T>>} - A promise that resolves to the record data.
      */
-    getItemById<T = any>(itemType: string, id: string): Promise<import("axios").AxiosResponse<any, any>>;
+    getRecordById<T = DataValues>(tableName: string, id: string): Promise<TotalumApiResponse<T>>;
     /**
      * Fetches the historic updates of a record by its ID.
      * @param {string} recordId - The ID of the record to fetch the historic updates.
-     * @returns {Promise<any>} - A promise that resolves to the historic updates data.
-     */
-    getHistoricRecordUpdatesById(recordId: string): Promise<import("axios").AxiosResponse<any, any>>;
-    getItems<T = any>(itemType: string, query?: FilterSearchQueryI): Promise<import("axios").AxiosResponse<any, any>>;
-    getNestedData<T = any>(nestedQuery: NestedQuery, options?: any): Promise<import("axios").AxiosResponse<any, any>>;
-    deleteItemById(itemType: string, id: string): Promise<import("axios").AxiosResponse<any, any>>;
-    editItemById<T = any>(itemType: string, id: string, properties: T): Promise<import("axios").AxiosResponse<any, any>>;
-    createItem<T = any>(itemType: string, item: T): Promise<import("axios").AxiosResponse<any, any>>;
-    /**
-     *
-     * @param typeId the type id of the item (table name)
-     * @param id the id of the item that we want to add a many to many reference
-     * @param propertyId the property that we want to add a many to many reference
-     * @param referenceId the id of the item that we want to add as a many to many reference
-     */
-    addManyToManyReferenceItem(type: string, id: string, propertyName: string, referenceId: string): Promise<any>;
-    /**
-     *
-     * @param typeId the type id of the item (table name)
-     * @param id the id of the item that we want to drop a many to many reference
-     * @param propertyId the property that we want to drop a many to many reference
-     * @param referenceId the id of the item that we want to drop as a many to many reference
-     */
-    dropManyToManyReferenceItem(type: string, id: string, propertyName: string, referenceId: string): Promise<any>;
-    /**
-     *
-     * @param typeId the type id of the item (table name)
-     * @param id the id of the item that we want to get many to many references
-     * @param propertyName the property that we want to get many to many references
-     * @param query the query to filter and sort the results
-     */
-    getManyToManyReferencesItems<T = any>(type: string, id: string, propertyName: string, query?: FilterSearchQueryI): Promise<any>;
+     * @returns {Promise<TotalumApiResponse<UpdatesRecordResponse>>} - A promise that resolves to the historic updates data.
+     */
+    getHistoricRecordUpdatesById(recordId: string): Promise<TotalumApiResponse<UpdatesRecordResponse>>;
+    /**
+     * Fetches records with optional filtering, sorting, and pagination.
+     * The response data is an array of records. If returnCount is true, a metadata object with count is also returned.
+     * @param {string} tableName - The type of the record. (table name)
+     * @param {FilterSearchQueryI} query - Optional query parameters for filtering.
+     * @returns {Promise<TotalumApiResponse<T[]>>} - A promise that resolves to an array of records.
+     */
+    getRecords<T = DataValues>(tableName: string, query?: FilterSearchQueryI): Promise<TotalumApiResponse<T[]>>;
+    /**
+     * Fetches nested data across related tables.
+     * @param {NestedQuery} nestedQuery - The nested query structure.
+     * @param {any} options - Optional configuration.
+     * @returns {Promise<TotalumApiResponse<T[]>>} - A promise that resolves to nested data array.
+     */
+    getNestedData<T = DataValues>(nestedQuery: NestedQuery, options?: any): Promise<TotalumApiResponse<T[]>>;
+    /**
+     * Deletes a record by its ID.
+     * @param {string} tableName - The type of the record. (table name)
+     * @param {string} id - The ID of the record.
+     * @returns {Promise<TotalumApiResponse<DeleteObjectResponse>>} - A promise that resolves when deletion is complete.
+     */
+    deleteRecordById(tableName: string, id: string): Promise<TotalumApiResponse<DeleteObjectResponse>>;
+    /**
+     * Edits a record by its ID.
+     * @param {string} tableName - The type of the record. (table name)
+     * @param {string} id - The ID of the record.
+     * @param {T} properties - The properties to update.
+     * @returns {Promise<TotalumApiResponse<UpdatedRecordResponse>>} - A promise that resolves to the updated record.
+     */
+    editRecordById<T = DataValues>(tableName: string, id: string, properties: Partial<T>): Promise<TotalumApiResponse<UpdatedRecordResponse>>;
+    /**
+     * Creates a new record.
+     * @param {string} tableName - The type of the record. (table name)
+     * @param {T} record - The record data to create.
+     * @returns {Promise<TotalumApiResponse<T>>} - A promise that resolves to the created record.
+     */
+    createRecord<T = DataValues>(tableName: string, record: Partial<T>): Promise<TotalumApiResponse<CreateRecordResponse>>;
+    /**
+     * Adds a many-to-many reference between records.
+     * @param {string} type - The type id of the record (table name)
+     * @param {string} id - The id of the record that we want to add a many to many reference
+     * @param {string} propertyName - The property that we want to add a many to many reference
+     * @param {string} referenceId - The id of the record that we want to add as a many to many reference
+     * @returns {Promise<TotalumApiResponse<CreateRecordResponse>>}
+     */
+    addManyToManyReferenceRecord(type: string, id: string, propertyName: string, referenceId: string): Promise<TotalumApiResponse<CreateRecordResponse>>;
+    /**
+     * Drops a many-to-many reference between records.
+     * @param {string} type - The type id of the record (table name)
+     * @param {string} id - The id of the record that we want to drop a many to many reference
+     * @param {string} propertyName - The property that we want to drop a many to many reference
+     * @param {string} referenceId - The id of the record that we want to drop as a many to many reference
+     * @returns {Promise<TotalumApiResponse<DeleteObjectResponse>>}
+     */
+    dropManyToManyReferenceRecord(type: string, id: string, propertyName: string, referenceId: string): Promise<TotalumApiResponse<DeleteObjectResponse>>;
+    /**
+     * Gets many-to-many reference records with optional filtering.
+     * @param {string} type - The type id of the record (table name)
+     * @param {string} id - The id of the record that we want to get many to many references
+     * @param {string} propertyName - The property that we want to get many to many references
+     * @param {FilterSearchQueryI} query - The query to filter and sort the results
+     * @returns {Promise<TotalumApiResponse<T[]>>}
+     */
+    getManyToManyReferencesRecords<T = DataValues>(type: string, id: string, propertyName: string, query?: FilterSearchQueryI): Promise<TotalumApiResponse<T[]>>;
 }