@techextensor/tab-core-utility 2.2.190 → 2.2.192

package/esm2022/lib/tab-core-utility/app/utils/tab-app.util.mjs

@@ -1,4 +1,90 @@
+import { Common } from '../constants/common';
 import { deleteKeyFromResponse } from './req-res.util';
+/** Get the DataSourceQuery ID from the selected AppObject's DataSourceQuery array
+ * @param dsqList - The list of DataSourceQueries
+ * @param table - The table name
+ * @param like - The like string
+ * @returns string - The ID of the DataSourceQuery
+ */
+export function getDsqIdfromSelectedAppObjectDSQArray(dsqList, table, like) {
+    if (dsqList) {
+        const matchName = like + '_' + table;
+        const result = dsqList.find((d) => d.QueryName === matchName);
+        return result?.ID;
+    }
+}
+/** Get the AppObject based on the provided ID
+ * @param id - The ID of the AppObject
+ * @returns AppObject | null - The found AppObject or null
+ */
+export function getAppObject(id) {
+    const tabData = Common.tabJson;
+    return (tabData?.AppObjects.find((t) => t.ID === id?.toLowerCase()) || null);
+}
+// function waitForData(timeout = 5000): Promise<void> {
+//   return new Promise((resolve, reject) => {
+//     const interval = 100; // Check every 100ms
+//     let waited = 0;
+//     const checkData = () => {
+//       if (Common.tabJson) {
+//         resolve();
+//       } else if (waited >= timeout) {
+//         reject(new Error('Timeout waiting for Common.tabJson'));
+//       } else {
+//         waited += interval;
+//         setTimeout(checkData, interval);
+//       }
+//     };
+//     checkData();
+//   });
+// }
+/**
+ * Get the AppObject from the DataSourceQuery ID
+ * @param dsqId - The DataSourceQuery ID
+ * @returns AppObject | null - The found AppObject or null
+ */
+export function getAppObjectFromDataSourceQueryID(dsqId) {
+    const tabData = Common.tabJson;
+    if (!dsqId || !tabData) {
+        return null;
+    }
+    for (const appObject of tabData.AppObjects) {
+        const dsq = appObject.DataSourceQueries.find((l) => l.ID === dsqId?.toLowerCase());
+        if (dsq) {
+            return appObject;
+        }
+    }
+    return null;
+}
+/**
+ * Get the DataSourceQuery ID from the QueryName and table
+ * @param table - The table name
+ * @param dsq - The DataSourceQuery name
+ * @returns any - The found DataSourceQuery
+ */
+export function getDsqIDFromQueryName(table, dsq) {
+    const appObjectList = getAppObjectFromSystemDBTableName(table);
+    return appObjectList?.DataSourceQueries.find((d) => d.QueryName === dsq);
+}
+/**
+ * Get the Data from the DataSourceQuery ID
+ *
+ * @param dsqId - The DataSourceQuery ID
+ * @returns any - The found Data
+ */
+export function getDataFromDataSourceQueryID(dsqId) {
+    const tabData = Common.tabJson;
+    if (!tabData) {
+        return null;
+    }
+    for (const appObject of tabData.AppObjects) {
+        const DSQ = appObject.DataSourceQueries.find((l) => l.ID === dsqId?.toLowerCase());
+        if (DSQ) {
+            return DSQ;
+        }
+    }
+    return null;
+}
 /**
  * Synchronize AppObject fields with the response
  *
@@ -16,4 +102,81 @@ export function syncAppObjectFields(response, appObject) {
     }
     return response;
 }
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * Get the AppObject based on the SystemDBTableName
+ *
+ * @param tableName - The SystemDBTableName
+ * @returns AppObject | null - The found AppObject or null
+ */
+export function getAppObjectFromSystemDBTableName(tableName) {
+    const tabData = Common.tabJson;
+    return (tabData?.AppObjects.find((t) => t.SystemDBTableName === tableName) || null);
+}
+/**
+ * Get the fields based on the appobjectid
+ *
+ * @param appObjectId - The appobjectid
+ * @returns AppObject | null - The found AppObject or null
+ */
+export function getAppfieldsFromAppObjectId(appObjectId) {
+    const tabData = Common.tabJson;
+    const findAppObject = tabData?.AppObjects.find((t) => t.ID === appObjectId) || null;
+    if (findAppObject) {
+        return findAppObject.Fields;
+    }
+    else {
+        return null;
+    }
+}
+export function getLookupAppfieldsFromAppObjectId(appObjectId) {
+    const tabData = Common.tabJson;
+    const findAppObject = tabData?.AppObjects.find((t) => t.ID === appObjectId) || null;
+    if (findAppObject) {
+        const lookupFields = findAppObject.Fields.filter((t) => t.LookUpDetails);
+        if (lookupFields) {
+            return lookupFields;
+        }
+        else {
+            return null;
+        }
+    }
+}
+export function getViewAppObjectDetailsFromDSQID(dsqID) {
+    const appObject = getAppObjectFromDataSourceQueryID(dsqID);
+    let viewAppObjectDetailsOfGrid = appObject;
+    // check appobject is table or view
+    if (appObject && appObject.ObjectType == 2) {
+        viewAppObjectDetailsOfGrid = getAppObject(appObject?.CRUDAppObjectId);
+    }
+    return viewAppObjectDetailsOfGrid;
+}
+/**
+ * Retrieves all appObjects and their DSQs in a single list
+ * suitable for tree view representation.
+ * @author : Parth B Thakkar
+ * @Usage : HTTP Request
+ * @returns Array<{ id: string; name: string; hasChildren: boolean; parentID: string | null }>
+ */
+export function getAllAppObjectsForTreeViewJson() {
+    const tabData = Common.tabJson;
+    const fieldData = [];
+    for (const appObject of tabData?.AppObjects || []) {
+        fieldData.push({
+            id: appObject.ID,
+            name: appObject.DisplayName,
+            hasChildren: true,
+            parentID: null,
+        });
+        // looping children
+        for (const dsq of appObject.DataSourceQueries) {
+            fieldData.push({
+                id: dsq.ID,
+                name: dsq.DisplayName,
+                hasChildren: false,
+                parentID: appObject.ID,
+            });
+        }
+    }
+    return fieldData.sort((a, b) => a.name.toLowerCase() > b.name.toLowerCase() ? 1 : -1);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tab-app.util.js","sourceRoot":"","sources":["../../../../../../../../libs/data-access/src/lib/tab-core-utility/app/utils/tab-app.util.ts"],"names":[],"mappings":"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","sourcesContent":["import { Common } from '../constants/common';\r\nimport { AppObject } from '../models/app-object.class';\r\nimport { deleteKeyFromResponse } from './req-res.util';\r\n\r\n/** Get the DataSourceQuery ID from the selected AppObject's DataSourceQuery array\r\n * @param dsqList - The list of DataSourceQueries\r\n * @param table - The table name\r\n * @param like - The like string\r\n * @returns string - The ID of the DataSourceQuery\r\n */\r\n\r\nexport function getDsqIdfromSelectedAppObjectDSQArray(\r\n  dsqList: any,\r\n  table: string,\r\n  like: string\r\n) {\r\n  if (dsqList) {\r\n    const matchName = like + '_' + table;\r\n    const result = dsqList.find((d: any) => d.QueryName === matchName);\r\n    return result?.ID;\r\n  }\r\n}\r\n\r\n/** Get the AppObject based on the provided ID\r\n * @param id - The ID of the AppObject\r\n * @returns AppObject | null - The found AppObject or null\r\n */\r\n\r\nexport function getAppObject(id: string) {\r\n  const tabData: any | null = Common.tabJson;\r\n  return (\r\n    tabData?.AppObjects.find((t: any) => t.ID === id?.toLowerCase()) || null\r\n  );\r\n}\r\n\r\n// function waitForData(timeout = 5000): Promise<void> {\r\n//   return new Promise((resolve, reject) => {\r\n//     const interval = 100; // Check every 100ms\r\n//     let waited = 0;\r\n\r\n//     const checkData = () => {\r\n//       if (Common.tabJson) {\r\n//         resolve();\r\n//       } else if (waited >= timeout) {\r\n//         reject(new Error('Timeout waiting for Common.tabJson'));\r\n//       } else {\r\n//         waited += interval;\r\n//         setTimeout(checkData, interval);\r\n//       }\r\n//     };\r\n\r\n//     checkData();\r\n//   });\r\n// }\r\n\r\n/**\r\n * Get the AppObject from the DataSourceQuery ID\r\n * @param dsqId - The DataSourceQuery ID\r\n * @returns AppObject | null - The found AppObject or null\r\n */\r\n\r\nexport function getAppObjectFromDataSourceQueryID(dsqId: string) {\r\n  const tabData: any = Common.tabJson;\r\n  if (!dsqId || !tabData) {\r\n    return null;\r\n  }\r\n\r\n  for (const appObject of tabData.AppObjects) {\r\n    const dsq = appObject.DataSourceQueries.find(\r\n      (l: any) => l.ID === dsqId?.toLowerCase()\r\n    );\r\n    if (dsq) {\r\n      return appObject;\r\n    }\r\n  }\r\n\r\n  return null;\r\n}\r\n\r\n/**\r\n * Get the DataSourceQuery ID from the QueryName and table\r\n * @param table - The table name\r\n * @param dsq - The DataSourceQuery name\r\n * @returns any - The found DataSourceQuery\r\n */\r\nexport function getDsqIDFromQueryName(table: string, dsq: string) {\r\n  const appObjectList = getAppObjectFromSystemDBTableName(table);\r\n  return appObjectList?.DataSourceQueries.find((d: any) => d.QueryName === dsq);\r\n}\r\n\r\n/**\r\n * Get the Data from the DataSourceQuery ID\r\n *\r\n * @param dsqId - The DataSourceQuery ID\r\n * @returns any - The found Data\r\n */\r\n\r\nexport function getDataFromDataSourceQueryID(dsqId: string) {\r\n  const tabData: any = Common.tabJson;\r\n  if (!tabData) {\r\n    return null;\r\n  }\r\n\r\n  for (const appObject of tabData.AppObjects) {\r\n    const DSQ = appObject.DataSourceQueries.find(\r\n      (l: any) => l.ID === dsqId?.toLowerCase()\r\n    );\r\n    if (DSQ) {\r\n      return DSQ;\r\n    }\r\n  }\r\n\r\n  return null;\r\n}\r\n\r\n/**\r\n * Synchronize AppObject fields with the response\r\n *\r\n * @param response - The response object\r\n * @param appObject - The AppObject\r\n * @returns any - The synchronized response object\r\n */\r\nexport function syncAppObjectFields(response: any, appObject: AppObject) {\r\n  for (const key in response) {\r\n    const foundObj = appObject.Fields.find((f: any) => f.FieldName === key);\r\n    const chilData = appObject.ChildRelationShips?.map(\r\n      (x) => x.childDetails.LookupObject\r\n    );\r\n    if (!foundObj && !(chilData && chilData.some((x) => x.includes(key)))) {\r\n      deleteKeyFromResponse(response, key);\r\n    }\r\n  }\r\n  return response;\r\n}\r\n\r\n/**\r\n * Get the AppObject based on the SystemDBTableName\r\n *\r\n * @param tableName - The SystemDBTableName\r\n * @returns AppObject | null - The found AppObject or null\r\n */\r\nexport function getAppObjectFromSystemDBTableName(tableName: string) {\r\n  const tabData: any = Common.tabJson;\r\n  return (\r\n    tabData?.AppObjects.find(\r\n      (t: { SystemDBTableName: string }) => t.SystemDBTableName === tableName\r\n    ) || null\r\n  );\r\n}\r\n\r\n/**\r\n * Get the fields based on the appobjectid\r\n *\r\n * @param appObjectId - The appobjectid\r\n * @returns AppObject | null - The found AppObject or null\r\n */\r\nexport function getAppfieldsFromAppObjectId(appObjectId: string) {\r\n  const tabData: any = Common.tabJson;\r\n  const findAppObject =\r\n    tabData?.AppObjects.find((t: any) => t.ID === appObjectId) || null;\r\n  if (findAppObject) {\r\n    return findAppObject.Fields;\r\n  } else {\r\n    return null;\r\n  }\r\n}\r\n\r\nexport function getLookupAppfieldsFromAppObjectId(appObjectId: string) {\r\n  const tabData: any = Common.tabJson;\r\n  const findAppObject =\r\n    tabData?.AppObjects.find((t: any) => t.ID === appObjectId) || null;\r\n  if (findAppObject) {\r\n    const lookupFields = findAppObject.Fields.filter(\r\n      (t: any) => t.LookUpDetails\r\n    );\r\n    if (lookupFields) {\r\n      return lookupFields;\r\n    } else {\r\n      return null;\r\n    }\r\n  }\r\n}\r\nexport function getViewAppObjectDetailsFromDSQID(dsqID: string) {\r\n  const appObject = getAppObjectFromDataSourceQueryID(dsqID);\r\n  let viewAppObjectDetailsOfGrid = appObject;\r\n  // check appobject is table or view\r\n  if (appObject && appObject.ObjectType == 2) {\r\n    viewAppObjectDetailsOfGrid = getAppObject(appObject?.CRUDAppObjectId);\r\n  }\r\n  return viewAppObjectDetailsOfGrid;\r\n}\r\n\r\n/**\r\n * Retrieves all appObjects and their DSQs in a single list\r\n * suitable for tree view representation.\r\n * @author : Parth B Thakkar\r\n * @Usage : HTTP Request\r\n * @returns Array<{ id: string; name: string; hasChildren: boolean; parentID: string | null }>\r\n */\r\nexport function getAllAppObjectsForTreeViewJson() {\r\n  const tabData = Common.tabJson;\r\n\r\n  const fieldData: Array<{\r\n    id: string; // UUID as a string\r\n    name: string; // Name of the node\r\n    hasChildren: boolean; // Whether the node has children\r\n    parentID: string | null; // Parent ID if applicable, otherwise null\r\n  }> = [];\r\n  for (const appObject of tabData?.AppObjects || []) {\r\n    fieldData.push({\r\n      id: appObject.ID,\r\n      name: appObject.DisplayName,\r\n      hasChildren: true,\r\n      parentID: null,\r\n    });\r\n    // looping children\r\n    for (const dsq of appObject.DataSourceQueries) {\r\n      fieldData.push({\r\n        id: dsq.ID,\r\n        name: dsq.DisplayName,\r\n        hasChildren: false,\r\n        parentID: appObject.ID,\r\n      });\r\n    }\r\n  }\r\n  return fieldData.sort((a, b) =>\r\n    a.name.toLowerCase() > b.name.toLowerCase() ? 1 : -1\r\n  );\r\n}\r\n"]}

package/esm2022/lib/tab-core-utility/core/http-client/api.service.mjs

@@ -1,10 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { Injectable, inject } from '@angular/core';
 import { HttpClient, HttpParams } from '@angular/common/http';
-import { map } from 'rxjs/operators';
 import { API_URL } from './api-url.token';
-import { Common } from '../../app/constants/common';
-import { ResponseAdapter } from '../../app/helpers/response.adapter';
 import * as i0 from "@angular/core";
 export class ApiService {
     constructor() {
@@ -124,80 +121,6 @@ export class ApiService {
     deleteByUrl(url, options) {
         return this.http.delete(url, { ...options });
     }
-    // ==================== NEW MICROSERVICE METHODS ====================
-    /**
-     * Makes an HTTP GET request to a specific microservice
-     * @param serviceName - Name of the microservice (e.g., 'crudService', 'metadataService')
-     * @param endPointName - Endpoint path relative to the service
-     * @param params - Query parameters for the request
-     * @param reqHeader - Custom headers for the request
-     * @returns An Observable emitting the response data (auto-normalized to CommonApiResponse format)
-     */
-    getFromService(serviceName, endPointName, params = new HttpParams(), reqHeader) {
-        const serviceUrl = Common.apiServiceUrls[serviceName];
-        return this.http.get(`${serviceUrl}${endPointName}`, {
-            headers: reqHeader,
-            params,
-        }).pipe(map(response => ResponseAdapter.normalize(response)));
-    }
-    /**
-     * Makes an HTTP POST request to a specific microservice
-     * @param serviceName - Name of the microservice (e.g., 'crudService', 'formioService')
-     * @param endPointName - Endpoint path relative to the service
-     * @param data - Data to send with the request
-     * @param reqHeader - Custom headers for the request
-     * @returns An Observable emitting the response data (auto-normalized to CommonApiResponse format)
-     */
-    postToService(serviceName, endPointName, data, reqHeader) {
-        const serviceUrl = Common.apiServiceUrls[serviceName];
-        return this.http.post(`${serviceUrl}${endPointName}`, JSON.stringify(data), {
-            headers: reqHeader,
-        }).pipe(map(response => ResponseAdapter.normalize(response)));
-    }
-    /**
-     * Makes an HTTP PUT request to a specific microservice
-     * @param serviceName - Name of the microservice
-     * @param endPointName - Endpoint path relative to the service
-     * @param data - Data to send with the request
-     * @param reqHeader - Custom headers for the request
-     * @returns An Observable emitting the response data (auto-normalized to CommonApiResponse format)
-     */
-    putToService(serviceName, endPointName, data, reqHeader) {
-        const serviceUrl = Common.apiServiceUrls[serviceName];
-        return this.http.put(`${serviceUrl}${endPointName}`, JSON.stringify(data), {
-            headers: reqHeader,
-        }).pipe(map(response => ResponseAdapter.normalize(response)));
-    }
-    /**
-     * Makes an HTTP DELETE request to a specific microservice
-     * @param serviceName - Name of the microservice
-     * @param endPointName - Endpoint path relative to the service
-     * @param data - Data to send with the request (optional, for DELETE with body)
-     * @param reqHeader - Custom headers for the request
-     * @returns An Observable emitting the response data (auto-normalized to CommonApiResponse format)
-     */
-    deleteFromService(serviceName, endPointName, data, reqHeader) {
-        const serviceUrl = Common.apiServiceUrls[serviceName];
-        return this.http.delete(`${serviceUrl}${endPointName}`, {
-            headers: reqHeader,
-            body: data ? JSON.stringify(data) : undefined
-        }).pipe(map(response => ResponseAdapter.normalize(response)));
-    }
-    /**
-     * Makes an HTTP POST request to a specific microservice and returns a Blob response
-     * @param serviceName - Name of the microservice (e.g., 'reportService')
-     * @param endPointName - Endpoint path relative to the service
-     * @param data - Data to send with the request
-     * @param reqHeader - Custom headers for the request
-     * @returns An Observable emitting the response as a Blob
-     */
-    postBlobToService(serviceName, endPointName, data, reqHeader) {
-        const serviceUrl = Common.apiServiceUrls[serviceName];
-        return this.http.post(`${serviceUrl}${endPointName}`, JSON.stringify(data), {
-            headers: reqHeader,
-            responseType: 'blob'
-        });
-    }
     static { this.ɵfac = function ApiService_Factory(t) { return new (t || ApiService)(); }; }
     static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ApiService, factory: ApiService.ɵfac, providedIn: 'root' }); }
 }
@@ -205,4 +128,4 @@ export class ApiService {
         type: Injectable,
         args: [{ providedIn: 'root' }]
     }], null, null); })();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api.service.js","sourceRoot":"","sources":["../../../../../../../../libs/data-access/src/lib/tab-core-utility/core/http-client/api.service.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\r\nimport { Injectable, inject } from '@angular/core';\r\nimport { HttpClient, HttpParams, HttpHeaders } from '@angular/common/http';\r\nimport { Observable } from 'rxjs';\r\nimport { map } from 'rxjs/operators';\r\nimport { API_URL } from './api-url.token';\r\nimport { Common } from '../../app/constants/common';\r\nimport { APIServiceName, CommonApiResponse, StandardApiResponse } from '../../app/interfaces/common.interface';\r\nimport { ResponseAdapter } from '../../app/helpers/response.adapter';\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class ApiService {\r\n  private readonly http = inject(HttpClient);\r\n  private readonly api_url = inject(API_URL);\r\n\r\n  /**\r\n   * Makes an HTTP GET request to retrieve data from the specified URL.\r\n   * @param endPointName The URL for the HTTP GET request.\r\n   * @param params The query parameters for the request (default is an empty HttpParams object).\r\n   * @param reqHeader The custom headers for the request (optional).\r\n   * @returns An Observable emitting the response data of type T.\r\n   */\r\n  get<T>(\r\n    endPointName: string,\r\n    params: HttpParams = new HttpParams(),\r\n    reqHeader?: HttpHeaders\r\n  ): Observable<any> {\r\n    return this.http.get<T>(`${this.api_url}${endPointName}`, {\r\n      headers: reqHeader,\r\n      params,\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP POST request to send data to the specified URL.\r\n   * @param endPointName The URL for the HTTP POST request.\r\n   * @param data The data to send with the request (optional).\r\n   * @param reqHeader The custom headers for the request (optional).\r\n   * @returns An Observable emitting the response data of type T.\r\n   */\r\n  post<T, D>(\r\n    endPointName: string,\r\n    data?: D,\r\n    reqHeader?: HttpHeaders\r\n  ): Observable<D | any> {\r\n    return this.http.post<T>(\r\n      `${this.api_url}${endPointName}`,\r\n      JSON.stringify(data),\r\n      {\r\n        headers: reqHeader,\r\n      }\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP PUT request to update data at the specified URL.\r\n   * @param endPointName The URL for the HTTP PUT request.\r\n   * @param data The data to send with the request.\r\n   * @param reqHeader The custom headers for the request (optional).\r\n   * @returns An Observable emitting the response data of type T.\r\n   */\r\n  put<T, D>(\r\n    endPointName: string,\r\n    data: D,\r\n    reqHeader?: HttpHeaders\r\n  ): Observable<any> {\r\n    return this.http.put<T>(\r\n      `${this.api_url}${endPointName}`,\r\n      JSON.stringify(data),\r\n      {\r\n        headers: reqHeader,\r\n      }\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP DELETE request to delete data from the specified URL.\r\n   * @param endPointName The URL for the HTTP DELETE request.\r\n   * @param reqHeader The custom headers for the request (optional).\r\n   * @returns An Observable emitting the response data of type T.\r\n   */\r\n  delete<T>(endPointName: string, reqHeader?: HttpHeaders): Observable<any> {\r\n    return this.http.delete<T>(`${this.api_url}${endPointName}`, {\r\n      headers: reqHeader,\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP GET request to retrieve blob data with custom headers.\r\n   * @param endPointName The URL for the HTTP request.\r\n   * @param params The query parameters for the request.\r\n   * @param reqHeader The custom headers for the request.\r\n   * @returns An Observable emitting the response as a Blob.\r\n   */\r\n  getBlob<T>(\r\n    endPointName: string,\r\n    params: HttpParams = new HttpParams(),\r\n    reqHeader?: HttpHeaders\r\n  ): Observable<any> {\r\n    return this.http.get<T>(`${this.api_url}${endPointName}`, {\r\n      headers: reqHeader,\r\n      params,\r\n      responseType: 'blob' as 'json',\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP POST request to send data and retrieve blob data with custom headers.\r\n   * @param endPointName The URL for the HTTP request.\r\n   * @param data The data to send with the request.\r\n   * @param reqHeader The custom headers for the request.\r\n   * @returns An Observable emitting the response as a Blob.\r\n   */\r\n  postBlob<T, D>(\r\n    endPointName: string,\r\n    data?: D,\r\n    reqHeader?: HttpHeaders\r\n  ): Observable<any> {\r\n    return this.http.post<T>(`${this.api_url}${endPointName}`, data, {\r\n      headers: reqHeader,\r\n      responseType: 'blob' as 'json',\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP GET request to retrieve data from the specified URL.\r\n   * @param url The URL for the HTTP GET request.\r\n   * @param options The custom options for the request (optional).\r\n   * @returns An Observable emitting the response data of type T.\r\n   */\r\n  getByUrl<T>(url: string, options?: any): Observable<any> {\r\n    return this.http.get<T>(url, { ...options });\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP POST request to the specified URL.\r\n   * @param url The URL for the HTTP POST request.\r\n   * @param data The data to send with the request (optional).\r\n   * @param options The custom options for the request (optional).\r\n   * @returns An Observable emitting the response data of type T.\r\n   */\r\n  postByUrl<T, D>(url: string, data?: D, options?: any): Observable<any> {\r\n    return this.http.post<T>(url, JSON.stringify(data), { ...options });\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP PUT request to the specified URL.\r\n   * @param url The URL for the HTTP PUT request.\r\n   * @param data The data to send with the request (optional).\r\n   * @param options The custom options for the request (optional).\r\n   * @returns An Observable emitting the response data of type T.\r\n   */\r\n  putByUrl<T, D>(url: string, data?: D, options?: any): Observable<any> {\r\n    return this.http.put<T>(url, JSON.stringify(data), { ...options });\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP DELETE request to the specified URL.\r\n   * @param url The URL for the HTTP DELETE request.\r\n   * @param options The custom options for the request (optional).\r\n   * @returns An Observable emitting the response data of type T.\r\n   */\r\n  deleteByUrl<T>(url: string, options?: any): Observable<any> {\r\n    return this.http.delete<T>(url, { ...options });\r\n  }\r\n\r\n  // ==================== NEW MICROSERVICE METHODS ====================\r\n\r\n  /**\r\n   * Makes an HTTP GET request to a specific microservice\r\n   * @param serviceName - Name of the microservice (e.g., 'crudService', 'metadataService')\r\n   * @param endPointName - Endpoint path relative to the service\r\n   * @param params - Query parameters for the request\r\n   * @param reqHeader - Custom headers for the request\r\n   * @returns An Observable emitting the response data (auto-normalized to CommonApiResponse format)\r\n   */\r\n  getFromService(\r\n    serviceName: APIServiceName,\r\n    endPointName: string,\r\n    params: HttpParams = new HttpParams(),\r\n    reqHeader?: HttpHeaders\r\n  ): Observable<CommonApiResponse> {\r\n    const serviceUrl = Common.apiServiceUrls[serviceName];\r\n    return this.http.get<StandardApiResponse>(`${serviceUrl}${endPointName}`, {\r\n      headers: reqHeader,\r\n      params,\r\n    }).pipe(\r\n      map(response => ResponseAdapter.normalize(response))\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP POST request to a specific microservice\r\n   * @param serviceName - Name of the microservice (e.g., 'crudService', 'formioService')\r\n   * @param endPointName - Endpoint path relative to the service\r\n   * @param data - Data to send with the request\r\n   * @param reqHeader - Custom headers for the request\r\n   * @returns An Observable emitting the response data (auto-normalized to CommonApiResponse format)\r\n   */\r\n  postToService<T, D>(\r\n    serviceName: APIServiceName,\r\n    endPointName: string,\r\n    data?: D,\r\n    reqHeader?: HttpHeaders\r\n  ): Observable<CommonApiResponse> {\r\n    const serviceUrl = Common.apiServiceUrls[serviceName];\r\n    return this.http.post<StandardApiResponse>(\r\n      `${serviceUrl}${endPointName}`,\r\n      JSON.stringify(data),\r\n      {\r\n        headers: reqHeader,\r\n      }\r\n    ).pipe(\r\n      map(response => ResponseAdapter.normalize(response))\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP PUT request to a specific microservice\r\n   * @param serviceName - Name of the microservice\r\n   * @param endPointName - Endpoint path relative to the service\r\n   * @param data - Data to send with the request\r\n   * @param reqHeader - Custom headers for the request\r\n   * @returns An Observable emitting the response data (auto-normalized to CommonApiResponse format)\r\n   */\r\n  putToService<T, D>(\r\n    serviceName: APIServiceName,\r\n    endPointName: string,\r\n    data: D,\r\n    reqHeader?: HttpHeaders\r\n  ): Observable<CommonApiResponse> {\r\n    const serviceUrl = Common.apiServiceUrls[serviceName];\r\n    return this.http.put<StandardApiResponse>(\r\n      `${serviceUrl}${endPointName}`,\r\n      JSON.stringify(data),\r\n      {\r\n        headers: reqHeader,\r\n      }\r\n    ).pipe(\r\n      map(response => ResponseAdapter.normalize(response))\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP DELETE request to a specific microservice\r\n   * @param serviceName - Name of the microservice\r\n   * @param endPointName - Endpoint path relative to the service\r\n   * @param data - Data to send with the request (optional, for DELETE with body)\r\n   * @param reqHeader - Custom headers for the request\r\n   * @returns An Observable emitting the response data (auto-normalized to CommonApiResponse format)\r\n   */\r\n  deleteFromService<D>(\r\n    serviceName: APIServiceName,\r\n    endPointName: string,\r\n    data?: D,\r\n    reqHeader?: HttpHeaders\r\n  ): Observable<CommonApiResponse> {\r\n    const serviceUrl = Common.apiServiceUrls[serviceName];\r\n    return this.http.delete<StandardApiResponse>(`${serviceUrl}${endPointName}`, {\r\n      headers: reqHeader,\r\n      body: data ? JSON.stringify(data) : undefined\r\n    }).pipe(\r\n      map(response => ResponseAdapter.normalize(response))\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP POST request to a specific microservice and returns a Blob response\r\n   * @param serviceName - Name of the microservice (e.g., 'reportService')\r\n   * @param endPointName - Endpoint path relative to the service\r\n   * @param data - Data to send with the request\r\n   * @param reqHeader - Custom headers for the request\r\n   * @returns An Observable emitting the response as a Blob\r\n   */\r\n  postBlobToService<D>(\r\n    serviceName: APIServiceName,\r\n    endPointName: string,\r\n    data?: D,\r\n    reqHeader?: HttpHeaders\r\n  ): Observable<Blob> {\r\n    const serviceUrl = Common.apiServiceUrls[serviceName];\r\n    return this.http.post(`${serviceUrl}${endPointName}`, JSON.stringify(data), {\r\n      headers: reqHeader,\r\n      responseType: 'blob'\r\n    });\r\n  }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api.service.js","sourceRoot":"","sources":["../../../../../../../../libs/data-access/src/lib/tab-core-utility/core/http-client/api.service.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\r\nimport { Injectable, inject } from '@angular/core';\r\nimport { HttpClient, HttpParams, HttpHeaders } from '@angular/common/http';\r\nimport { Observable } from 'rxjs';\r\nimport { API_URL } from './api-url.token';\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class ApiService {\r\n  private readonly http = inject(HttpClient);\r\n  private readonly api_url = inject(API_URL);\r\n\r\n  /**\r\n   * Makes an HTTP GET request to retrieve data from the specified URL.\r\n   * @param endPointName The URL for the HTTP GET request.\r\n   * @param params The query parameters for the request (default is an empty HttpParams object).\r\n   * @param reqHeader The custom headers for the request (optional).\r\n   * @returns An Observable emitting the response data of type T.\r\n   */\r\n  get<T>(\r\n    endPointName: string,\r\n    params: HttpParams = new HttpParams(),\r\n    reqHeader?: HttpHeaders\r\n  ): Observable<any> {\r\n    return this.http.get<T>(`${this.api_url}${endPointName}`, {\r\n      headers: reqHeader,\r\n      params,\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP POST request to send data to the specified URL.\r\n   * @param endPointName The URL for the HTTP POST request.\r\n   * @param data The data to send with the request (optional).\r\n   * @param reqHeader The custom headers for the request (optional).\r\n   * @returns An Observable emitting the response data of type T.\r\n   */\r\n  post<T, D>(\r\n    endPointName: string,\r\n    data?: D,\r\n    reqHeader?: HttpHeaders\r\n  ): Observable<D | any> {\r\n    return this.http.post<T>(\r\n      `${this.api_url}${endPointName}`,\r\n      JSON.stringify(data),\r\n      {\r\n        headers: reqHeader,\r\n      }\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP PUT request to update data at the specified URL.\r\n   * @param endPointName The URL for the HTTP PUT request.\r\n   * @param data The data to send with the request.\r\n   * @param reqHeader The custom headers for the request (optional).\r\n   * @returns An Observable emitting the response data of type T.\r\n   */\r\n  put<T, D>(\r\n    endPointName: string,\r\n    data: D,\r\n    reqHeader?: HttpHeaders\r\n  ): Observable<any> {\r\n    return this.http.put<T>(\r\n      `${this.api_url}${endPointName}`,\r\n      JSON.stringify(data),\r\n      {\r\n        headers: reqHeader,\r\n      }\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP DELETE request to delete data from the specified URL.\r\n   * @param endPointName The URL for the HTTP DELETE request.\r\n   * @param reqHeader The custom headers for the request (optional).\r\n   * @returns An Observable emitting the response data of type T.\r\n   */\r\n  delete<T>(endPointName: string, reqHeader?: HttpHeaders): Observable<any> {\r\n    return this.http.delete<T>(`${this.api_url}${endPointName}`, {\r\n      headers: reqHeader,\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP GET request to retrieve blob data with custom headers.\r\n   * @param endPointName The URL for the HTTP request.\r\n   * @param params The query parameters for the request.\r\n   * @param reqHeader The custom headers for the request.\r\n   * @returns An Observable emitting the response as a Blob.\r\n   */\r\n  getBlob<T>(\r\n    endPointName: string,\r\n    params: HttpParams = new HttpParams(),\r\n    reqHeader?: HttpHeaders\r\n  ): Observable<any> {\r\n    return this.http.get<T>(`${this.api_url}${endPointName}`, {\r\n      headers: reqHeader,\r\n      params,\r\n      responseType: 'blob' as 'json',\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP POST request to send data and retrieve blob data with custom headers.\r\n   * @param endPointName The URL for the HTTP request.\r\n   * @param data The data to send with the request.\r\n   * @param reqHeader The custom headers for the request.\r\n   * @returns An Observable emitting the response as a Blob.\r\n   */\r\n  postBlob<T, D>(\r\n    endPointName: string,\r\n    data?: D,\r\n    reqHeader?: HttpHeaders\r\n  ): Observable<any> {\r\n    return this.http.post<T>(`${this.api_url}${endPointName}`, data, {\r\n      headers: reqHeader,\r\n      responseType: 'blob' as 'json',\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP GET request to retrieve data from the specified URL.\r\n   * @param url The URL for the HTTP GET request.\r\n   * @param options The custom options for the request (optional).\r\n   * @returns An Observable emitting the response data of type T.\r\n   */\r\n  getByUrl<T>(url: string, options?: any): Observable<any> {\r\n    return this.http.get<T>(url, { ...options });\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP POST request to the specified URL.\r\n   * @param url The URL for the HTTP POST request.\r\n   * @param data The data to send with the request (optional).\r\n   * @param options The custom options for the request (optional).\r\n   * @returns An Observable emitting the response data of type T.\r\n   */\r\n  postByUrl<T, D>(url: string, data?: D, options?: any): Observable<any> {\r\n    return this.http.post<T>(url, JSON.stringify(data), { ...options });\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP PUT request to the specified URL.\r\n   * @param url The URL for the HTTP PUT request.\r\n   * @param data The data to send with the request (optional).\r\n   * @param options The custom options for the request (optional).\r\n   * @returns An Observable emitting the response data of type T.\r\n   */\r\n  putByUrl<T, D>(url: string, data?: D, options?: any): Observable<any> {\r\n    return this.http.put<T>(url, JSON.stringify(data), { ...options });\r\n  }\r\n\r\n  /**\r\n   * Makes an HTTP DELETE request to the specified URL.\r\n   * @param url The URL for the HTTP DELETE request.\r\n   * @param options The custom options for the request (optional).\r\n   * @returns An Observable emitting the response data of type T.\r\n   */\r\n  deleteByUrl<T>(url: string, options?: any): Observable<any> {\r\n    return this.http.delete<T>(url, { ...options });\r\n  }\r\n}\r\n"]}

package/index.d.ts

@@ -36,7 +36,6 @@ export * from './lib/tab-core-utility/app/interfaces/user.interface';
 export * from './lib/tab-core-utility/app/interfaces/orgInfo.interface';
 export * from './lib/tab-core-utility/app/interfaces/schema.interface';
 export * from './lib/tab-core-utility/app/interfaces/grid.interface';
-export * from './lib/tab-core-utility/app/interfaces/signalr.interface';
 export * from './lib/tab-core-utility/app/models/api-query.class';
 export * from './lib/tab-core-utility/app/models/app-object.class';
 export * from './lib/tab-core-utility/app/models/common.class';
@@ -57,9 +56,6 @@ export * from './lib/tab-core-utility/core/service/translation.service';
 export * from './lib/tab-core-utility/core/service/notification.service';
 export * from './lib/tab-core-utility/core/service/confirmation.service';
 export * from './lib/tab-core-utility/core/service/encryption.service';
-export * from './lib/tab-core-utility/core/service/signalr/signalr.service';
-export * from './lib/tab-core-utility/core/service/signalr/signalr-infrastructure.service';
-export * from './lib/tab-core-utility/core/service/signalr/operation-tracker.service';
 export * from './lib/tab-core-utility/core/pipe/translate.pipe';
 export * from './lib/tab-core-utility/core/provider/translation.provider';
 export * from './lib/tab-core-utility/core/provider/notification.provider';

package/lib/tab-core-utility/app/constants/api-constants.d.ts

@@ -1,15 +1,18 @@
-import type { APIServiceName } from '../interfaces/common.interface';
 export declare const API: {
     applicationIdentifier: string;
     applicationIdentifierForPMS: string;
     novuBackendUrl: string;
     novuSocketUrl: string;
+    insert: string;
     bulkInsert: string;
+    update: string;
+    delete: string;
     select: string;
-    screen: string;
-    listsGet: string;
+    getDSQ: string;
+    getScreen: string;
+    getListFromDsq: string;
     buildApp: string;
-    metadataSchema: string;
+    getSchema: string;
     login: string;
     pluginUpload: string;
     getFile: string;
@@ -21,12 +24,12 @@ export declare const API: {
     multipleFileUpload: string;
     deleteFile: string;
     getMediaFile: string;
-    auditGetHistory: string;
+    getHistory: string;
     changePassword: string;
     restpassword: string;
     getImage: string;
     pmjayImport: string;
-    screenData: string;
+    getScreenData: string;
     processRequest: string;
     getNextStatus: string;
     updateStatus: string;
@@ -40,7 +43,7 @@ export declare const API: {
     registerAppObjects: string;
     languageResource: string;
     refreshToken: string;
-    globalSearch: string;
+    search: string;
     cloneDsq: string;
     InsertScreenPerformanceAnalytics: string;
     GenerateHttpRequest: string;
@@ -48,10 +51,10 @@ export declare const API: {
     GetSummaryOfPerformanceAnalytics: string;
     GetDataJsonByType: string;
     SyncAppFields: string;
-    reportExport: string;
+    exportReport: string;
     RefreshGlobalSearchData: string;
     RefreshRecordInfoData: string;
-    reportDownload: string;
+    downloadReportFile: string;
     sendReport: string;
     GetReleaseJSONDifference: string;
     GetDataDifference: string;
@@ -60,14 +63,4 @@ export declare const API: {
     GetAllDocumnets: string;
     GetDocumentById: string;
     ExecuteWorkflow: string;
-    QueriesExecute: string;
-    QueriesSelect: string;
-    recordsInsert: string;
-    recordsUpdate: string;
-    recordsDelete: string;
-    fileManagerFileOperations: string;
-    fileManagerGetImage: string;
-    fileManagerUpload: string;
-    fileManagerDownload: string;
 };
-export declare const APIServices: Record<APIServiceName, APIServiceName>;

package/lib/tab-core-utility/app/constants/common.d.ts

@@ -1,4 +1,3 @@
-import { APIServiceUrls } from '../interfaces/common.interface';
 export declare class Common {
     static environmentName: string;
     static applicationCode: string;
@@ -8,13 +7,5 @@ export declare class Common {
     static tabAppObjectAccess: any;
     static staticToken: any;
     static i18n: any;
-    /** Microservice URLs configuration - NEW for microservices architecture */
-    static apiServiceUrls: APIServiceUrls;
-    /** SignalR hub URL for real-time notifications */
-    static signalRHubUrl: string;
-    /**
-     * Initialize the static variables
-     * Called once at application startup from the main app
-     */
     static init(environment: any): void;
 }

package/lib/tab-core-utility/app/constants/storage-constants.d.ts

@@ -22,5 +22,6 @@ export declare const StorageConstants: {
     refreshTokenExpiry: string;
     appNavigationMapping: string;
     tokenInfo: string;
-    EnvironmentId: string;
+    Environment: string;
+    Screen: string;
 };

package/lib/tab-core-utility/app/crud/tab-blueprint.service.d.ts

@@ -9,14 +9,14 @@ export declare class TabBlueprintService {
      * @param params - Optional parameters for the API call.
      * @returns An observable of the API response.
      */
-    getNextStatus(payload: NextStatusPayload, params?: any): Observable<CommonApiResponse>;
+    getNextStatus(payload: NextStatusPayload, params?: any, customHeaders?: any): Observable<CommonApiResponse>;
     /**
      * Updates the status of a record.
      * @param payload - Object containing the next possible status ID.
      * @param params - Optional parameters for the API call.
      * @returns An observable of the API response.
      */
-    updateStatus(payload: UpdateStatusPayload, params?: any): Observable<CommonApiResponse>;
+    updateStatus(payload: UpdateStatusPayload, params?: any, customHeaders?: any): Observable<CommonApiResponse>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TabBlueprintService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<TabBlueprintService>;
 }

package/lib/tab-core-utility/app/crud/tab-crud.service.d.ts

@@ -6,10 +6,6 @@ export declare class TabCrudService {
     private readonly _requestResponseHelper;
     private readonly _dsqHelper;
     private readonly _apiService;
-    private readonly _tabGetService;
-    private readonly _tabInsertService;
-    private readonly _tabUpdateService;
-    private readonly _tabDeleteService;
     /**
      * Returns the AppObjectModel from the given payload.
      * @param payload The payload with either dataSourceQueryIdOrName or appObjectIdOrName.
@@ -43,16 +39,14 @@ export declare class TabCrudService {
     get(payload: GetPayload, headers?: any): Observable<CommonApiResponse>;
     /**
      * Inserts data into the specified table.
-     * NEW: Delegates to TabInsertService which uses /records/insert endpoint with SYNC/ASYNC support
      * @param payload The payload containing the data to insert and the AppObjectModel ID.
      * @param headers Optional headers for the request.
-     * @returns An observable of the response from the API (returns insertedId only).
+     * @returns An observable of the response from the API.
      */
     insert(payload: InsertPayload, headers?: any): Observable<CommonApiResponse>;
     bulkInsert(payload: InsertPayload, headers?: any): Observable<CommonApiResponse>;
     /**
      * Updates data in the specified table.
-     * NEW: Delegates to TabUpdateService which uses /records/update endpoint with SYNC/ASYNC support
      * @param payload The payload containing the data to update, the criteria for the update, and the AppObjectModel ID.
      * @param headers Optional headers for the request.
      * @returns An observable of the response from the API.
@@ -60,7 +54,6 @@ export declare class TabCrudService {
     update(payload: UpdatePayload, headers?: any): Observable<CommonApiResponse>;
     /**
      * Deletes data from the specified table.
-     * NEW: Delegates to TabDeleteService which uses /records/delete endpoint with SYNC/ASYNC support
      * @param payload The payload containing the criteria for the delete and the AppObjectModel ID.
      * @param headers Optional headers for the request.
      * @returns An observable of the response from the API.

package/lib/tab-core-utility/app/crud/tab-delete.service.d.ts

@@ -1,13 +1,10 @@
-import { Observable } from 'rxjs';
-import { CommonApiResponse } from '../interfaces/common.interface';
+import { APIDeleteQuery } from "../models/api-query.class";
 import * as i0 from "@angular/core";
 export declare class TabDeleteService {
+    private readonly dsqHelper;
     private readonly screenHelper;
     private readonly whereClauseHelper;
     private readonly requestResponseHelper;
-    private readonly apiService;
-    private readonly signalRService;
-    private readonly metadataHelper;
     /**
      * Deletes a record based on the given screen ID, data, and object ID.
      * @param screenId The ID of the screen.
@@ -15,7 +12,7 @@ export declare class TabDeleteService {
      * @param objectIDToSave The object ID of the record to save.
      * @returns An Observable emitting the response of the delete operation.
      */
-    deleteRecord(screenId: string, data: any, objectIDToSave: any): Observable<CommonApiResponse> | null;
+    deleteRecord(screenId: string, data: any, objectIDToSave: any): import("rxjs").Observable<any> | null;
     /**
      * Deletes a record by the specified table name and primary key value.
      * @param tableName The name of the table.
@@ -23,20 +20,13 @@ export declare class TabDeleteService {
      * @param primaryKeyValue The value of the primary key.
      * @returns An Observable emitting the response of the delete operation.
      */
-    deleteRecordByTable(tableName: string, primaryKey: string, primaryKeyValue: string): Observable<CommonApiResponse>;
+    deleteRecordByTable(tableName: string, primaryKey: string, primaryKeyValue: string): import("rxjs").Observable<any> | null;
     /**
-     * Executes the delete operation using new /records/delete endpoint with SYNC/ASYNC support
-     * @param data The delete query payload (NEW format: { entityName, whereClause })
-     * @param headers Optional headers
-     * @returns An Observable emitting the response of the delete operation
-     */
-    delete(data: any, headers?: any): Observable<CommonApiResponse>;
-    /**
-     * Handle async delete - wait for SignalR notification
-     * @param response Initial response with correlationId
-     * @returns Observable with result from SignalR notification
+     * Executes the delete operation.
+     * @param data The delete query payload.
+     * @returns An Observable emitting the response of the delete operation.
      */
-    private handleAsyncDelete;
+    delete(data: APIDeleteQuery, headers?: any): import("rxjs").Observable<any> | null;
     /**
      * Displays a delete confirmation popup.
      * @returns True if the user confirms the delete operation, otherwise false.
@@ -48,7 +38,7 @@ export declare class TabDeleteService {
      * @param values The values of the records to delete.
      * @returns An Observable emitting the response of the delete operation.
      */
-    deleteMultipleRecordByTable(tableName: string, values: any): Observable<CommonApiResponse>;
+    deleteMultipleRecordByTable(tableName: string, values: any): import("rxjs").Observable<any> | null;
     /**
      * Deletes multiple records from the specified table based on the provided data array.
      * The data array should contain key-value pairs without primary key information.
@@ -56,7 +46,7 @@ export declare class TabDeleteService {
      * @param values The array of data objects to delete.
      * @returns An Observable emitting the response of the delete operation.
      */
-    deleteMultipleRecordByTableWithoutPrimaryKey(tableName: string, values: any, headers?: any): Observable<CommonApiResponse>;
+    deleteMultipleRecordByTableWithoutPrimaryKey(tableName: string, values: any, headers?: any): import("rxjs").Observable<any> | null;
     /**
      * Generates a values array from the data.
      * @param dataArray The array of data.