lamp-core-lst 2025.11.1-3.basic

package/dist/service/Credential.service.js

@@ -0,0 +1,319 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CredentialService = void 0;
+var jose_1 = require("jose");
+var Fetch_1 = require("./Fetch");
+var Credential_1 = require("../model/Credential");
+var Demo_1 = require("./Demo");
+var jsonata_1 = __importDefault(require("jsonata"));
+var CredentialService = /** @class */ (function () {
+    function CredentialService() {
+    }
+    /**
+     *
+     * @param typeId
+     * @param secretKey
+     */
+    CredentialService.prototype.create = function (typeId, accessKey, secretKey, description) {
+        return __awaiter(this, void 0, void 0, function () {
+            var auth_1, credential, token, decoded, exists, unique;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (accessKey === null || accessKey === undefined)
+                            throw new Error("Required parameter accessKey was null or undefined when calling credentialCreate.");
+                        if (secretKey === null || secretKey === undefined)
+                            throw new Error("Required parameter secretKey was null or undefined when calling credentialCreate.");
+                        if (this.configuration.base === "https://demo.lamp.digital") {
+                            auth_1 = (this.configuration.authorization || ":").split(":");
+                            credential = Demo_1.Demo.Credential.filter(function (x) { return x["access_key"] === auth_1[0] && x["secret_key"] === auth_1[1]; });
+                            if (credential.length === 0)
+                                return [2 /*return*/, Promise.resolve({ error: "403.invalid-credentials" })];
+                            if (typeId === "me")
+                                typeId = credential.length > 0 ? credential[0]["origin"] : typeId;
+                            token = this.configuration.token;
+                            if (!token)
+                                return [2 /*return*/, Promise.resolve({ error: "401.missing-credentials" })];
+                            decoded = void 0;
+                            // try {
+                            //   // decoded = verifyToken(token, this.configuration.jwt_secret);
+                            // } catch (error) {
+                            //   return Promise.resolve({ error: "403.invalid-token" } as any);
+                            // }
+                            // const credential = Demo.Credential.filter(x => x["access_key"] === decoded.accessKey && x["secret_key"] === decoded.secretKey);
+                            // if (!credential) return Promise.resolve({ error: "403.invalid-credentials" } as any);
+                            if (typeId === "me")
+                                typeId = credential.length > 0 ? credential[0]["origin"] : typeId;
+                            exists = Demo_1.Demo.Researcher.filter(function (x) { return x["id"] === typeId; }).length > 0 ||
+                                Demo_1.Demo.Study.filter(function (x) { return x["id"] === typeId; }).length > 0 ||
+                                Demo_1.Demo.Participant.filter(function (x) { return x["id"] === typeId; }).length > 0 ||
+                                Demo_1.Demo.Activity.filter(function (x) { return x["id"] === typeId; }).length > 0 // ???
+                            ;
+                            unique = Demo_1.Demo.Credential.filter(function (x) { return x["access_key"] === accessKey; }).length === 0;
+                            if (exists && unique) {
+                                Demo_1.Demo.Credential.push({
+                                    "#type": "Credential",
+                                    "#parent": typeId,
+                                    origin: typeId,
+                                    access_key: accessKey,
+                                    secret_key: secretKey,
+                                    description: description,
+                                });
+                                return [2 /*return*/, Promise.resolve({})];
+                            }
+                            else {
+                                return [2 /*return*/, Promise.resolve({ error: "404.not-found" })];
+                            }
+                        }
+                        return [4 /*yield*/, Fetch_1.Fetch.post("/type/" + typeId + "/credential", { origin: typeId, access_key: accessKey, secret_key: secretKey, description: description }, this.configuration)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     *
+     * @param typeId
+     * @param accessKey
+     */
+    CredentialService.prototype.delete = function (typeId, accessKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var token, decoded_1, credential, idx;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (accessKey === null || accessKey === undefined)
+                            throw new Error("Required parameter accessKey was null or undefined when calling credentialDelete.");
+                        if (this.configuration.base === "https://demo.lamp.digital") {
+                            token = this.configuration.token;
+                            if (!token)
+                                return [2 /*return*/, Promise.resolve({ error: "401.missing-credentials" })];
+                            credential = Demo_1.Demo.Credential.find(function (x) { return x["access_key"] === decoded_1.accessKey && x["secret_key"] === decoded_1.secretKey; });
+                            if (typeId === "me")
+                                typeId = credential.length > 0 ? credential[0]["origin"] : typeId;
+                            idx = Demo_1.Demo.Credential.findIndex(function (x) { return x["#parent"] === typeId && x["access_key"] === accessKey; });
+                            if (idx >= 0) {
+                                Demo_1.Demo.Credential.splice(idx, 1);
+                                return [2 /*return*/, Promise.resolve({})];
+                            }
+                            else {
+                                return [2 /*return*/, Promise.resolve({ error: "404.not-found" })];
+                            }
+                        }
+                        return [4 /*yield*/, Fetch_1.Fetch.delete("/type/" + typeId + "/credential/" + accessKey, this.configuration)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     *
+     * @param typeId
+     */
+    CredentialService.prototype.list = function (typeId, transform) {
+        return __awaiter(this, void 0, void 0, function () {
+            var token, decoded_2, credential, exists, output;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.configuration.base === "https://demo.lamp.digital") {
+                            token = this.configuration.token;
+                            if (!token)
+                                return [2 /*return*/, Promise.resolve({ error: "401.missing-credentials" })];
+                            credential = Demo_1.Demo.Credential.find(function (x) { return x["access_key"] === decoded_2.accessKey && x["secret_key"] === decoded_2.secretKey; });
+                            // if (!credential) return Promise.resolve({ error: "403.invalid-credentials" } as any);
+                            if (typeId === "me")
+                                typeId = credential.length > 0 ? credential[0]["origin"] : typeId;
+                            exists = Demo_1.Demo.Researcher.filter(function (x) { return x["id"] === typeId; }).length > 0 ||
+                                Demo_1.Demo.Study.filter(function (x) { return x["id"] === typeId; }).length > 0 ||
+                                Demo_1.Demo.Participant.filter(function (x) { return x["id"] === typeId; }).length > 0 ||
+                                Demo_1.Demo.Activity.filter(function (x) { return x["id"] === typeId; }).length > 0 // ???
+                            ;
+                            if (exists) {
+                                output = Demo_1.Demo.Credential.filter(function (x) { return x["#parent"] === typeId; }).map(function (x) {
+                                    return Object.assign(new Credential_1.Credential(), __assign(__assign({}, x), { secret_key: "" }));
+                                });
+                                output = typeof transform === "string" ? jsonata_1.default(transform).evaluate(output) : output;
+                                return [2 /*return*/, Promise.resolve(output)];
+                            }
+                            else {
+                                return [2 /*return*/, Promise.resolve({ error: "404.not-found" })];
+                            }
+                        }
+                        return [4 /*yield*/, Fetch_1.Fetch.get("/type/" + typeId + "/credential", this.configuration)];
+                    case 1: return [2 /*return*/, (_a.sent()).data.map(function (x) {
+                            return Object.assign(new Credential_1.Credential(), x);
+                        })];
+                }
+            });
+        });
+    };
+    /**
+     *
+     * @param typeId
+     * @param accessKey
+     * @param secretKey
+     */
+    CredentialService.prototype.update = function (typeId, accessKey, secretKey, description) {
+        return __awaiter(this, void 0, void 0, function () {
+            var token, decoded_3, credential, idx;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (accessKey === null || accessKey === undefined)
+                            throw new Error("Required parameter accessKey was null or undefined when calling credentialUpdate.");
+                        if (secretKey === null || secretKey === undefined)
+                            throw new Error("Required parameter secretKey was null or undefined when calling credentialUpdate.");
+                        if (this.configuration.base === "https://demo.lamp.digital") {
+                            token = this.configuration.token;
+                            if (!token)
+                                return [2 /*return*/, Promise.resolve({ error: "401.missing-credentials" })];
+                            credential = Demo_1.Demo.Credential.find(function (x) { return x["access_key"] === decoded_3.accessKey && x["secret_key"] === decoded_3.secretKey; });
+                            // if (!credential) return Promise.resolve({ error: "403.invalid-credentials" } as any);
+                            if (typeId === "me")
+                                typeId = credential.length > 0 ? credential[0]["origin"] : typeId;
+                            idx = Demo_1.Demo.Credential.findIndex(function (x) { return x["#parent"] === typeId && x["access_key"] === accessKey; });
+                            if (idx >= 0) {
+                                Demo_1.Demo.Credential[idx] = {
+                                    "#type": "Credential",
+                                    "#parent": typeId,
+                                    origin: typeId,
+                                    access_key: accessKey,
+                                    secret_key: secretKey !== null && secretKey !== void 0 ? secretKey : Demo_1.Demo.Credential[idx]["secret_key"],
+                                    description: description !== null && description !== void 0 ? description : Demo_1.Demo.Credential[idx]["description"],
+                                };
+                                return [2 /*return*/, Promise.resolve({})];
+                            }
+                            else {
+                                return [2 /*return*/, Promise.resolve({ error: "404.not-found" })];
+                            }
+                        }
+                        return [4 /*yield*/, Fetch_1.Fetch.put("/type/" + typeId + "/credential/" + accessKey, secretKey, this.configuration)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     *
+     * @param accessKey
+     * @param secretKey
+     */
+    CredentialService.prototype.login = function (accessKey, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var credential, exists, secretKeyEncoded, _a, error_1;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (accessKey === null || accessKey === undefined)
+                            throw new Error("Required parameter accessKey was null or undefined when calling login.");
+                        if (secretKey === null || secretKey === undefined)
+                            throw new Error("Required parameter secretKey was null or undefined when calling login.");
+                        if (!(this.configuration.base === "https://demo.lamp.digital")) return [3 /*break*/, 4];
+                        credential = Demo_1.Demo.Credential.filter(function (x) { return x["access_key"] === accessKey && x["secret_key"] === secretKey; });
+                        if (credential.length === 0)
+                            return [2 /*return*/, Promise.resolve({ error: "403.invalid-credentials" })];
+                        exists = Demo_1.Demo.Researcher.filter(function (x) { return x["id"] === accessKey; }).length > 0 ||
+                            Demo_1.Demo.Participant.filter(function (x) { return x["id"] === accessKey; }).length > 0;
+                        if (!exists)
+                            return [2 /*return*/, Promise.resolve({ error: "403.invalid-credentials" })];
+                        if (!exists) return [3 /*break*/, 4];
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 3, , 4]);
+                        secretKeyEncoded = new TextEncoder().encode(this.configuration.jwt_secret);
+                        _a = this.configuration;
+                        return [4 /*yield*/, new jose_1.SignJWT({ accessKey: accessKey, secretKey: secretKey })
+                                .setProtectedHeader({ alg: "HS256" })
+                                .setIssuedAt()
+                                .setExpirationTime("2h")
+                                .sign(secretKeyEncoded)];
+                    case 2:
+                        _a.token = _b.sent();
+                        return [2 /*return*/, Promise.resolve({ success: "Login successful", token: this.configuration.token })];
+                    case 3:
+                        error_1 = _b.sent();
+                        console.error("Error generating token:", error_1);
+                        return [2 /*return*/, Promise.resolve({ error: "500.server-error" })];
+                    case 4: return [4 /*yield*/, Fetch_1.Fetch.post("/login", { accessKey: accessKey, secretKey: secretKey }, this.configuration)];
+                    case 5: return [2 /*return*/, _b.sent()];
+                }
+            });
+        });
+    };
+    CredentialService.prototype.renewToken = function (refreshToken, base) {
+        return __awaiter(this, void 0, void 0, function () {
+            var configuration;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        configuration = { accessToken: refreshToken, base: base };
+                        return [4 /*yield*/, Fetch_1.Fetch.post("/renewToken", { refreshToken: refreshToken }, configuration)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    CredentialService.prototype.logout = function (token) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Fetch_1.Fetch.post("/logout", { token: token }, this.configuration)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    return CredentialService;
+}());
+exports.CredentialService = CredentialService;

package/dist/service/Demo.d.ts

@@ -0,0 +1,14 @@
+export declare let Demo: {
+    ActivitySpec: any[];
+    SensorSpec: any[];
+    Researcher: any[];
+    ResearcherSettings: any[];
+    Study: any[];
+    Participant: any[];
+    Activity: any[];
+    Sensor: any[];
+    ActivityEvent: any[];
+    SensorEvent: any[];
+    Credential: any[];
+    Tags: any[];
+};

package/dist/service/Demo.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Demo = void 0;
+//
+// [NOTE]: Demo mode carries various restrictions and does not:
+//       (1) verify R/W permissions.
+//       (2) carry an audit log.
+//       (3) support root operations.
+//       (4) encrypt any data.
+//
+exports.Demo = {
+    ActivitySpec: [],
+    SensorSpec: [],
+    Researcher: [],
+    ResearcherSettings: [],
+    Study: [],
+    Participant: [],
+    Activity: [],
+    Sensor: [],
+    ActivityEvent: [],
+    SensorEvent: [],
+    Credential: [],
+    Tags: []
+};

package/dist/service/Fetch.d.ts

@@ -0,0 +1,30 @@
+/**
+ *
+ */
+export declare type Configuration = {
+    /**
+     *
+     */
+    base: string;
+    /**
+     *
+     */
+    authorization?: string;
+    /**
+     *
+     */
+    headers?: {
+        [header: string]: string;
+    };
+    token?: string;
+    accessToken?: string;
+    refreshToken?: string;
+    jwt_secret?: string;
+};
+export declare class Fetch {
+    static get<ResultType>(route: string, configuration?: Configuration): Promise<ResultType>;
+    static post<ResultType>(route: string, body: any, configuration?: Configuration): Promise<ResultType>;
+    static put<ResultType>(route: string, body: any, configuration?: Configuration): Promise<ResultType>;
+    static patch<ResultType>(route: string, body: any, configuration?: Configuration): Promise<ResultType>;
+    static delete<ResultType>(route: string, configuration?: Configuration, body?: any): Promise<ResultType>;
+}

package/dist/service/Fetch.js

@@ -0,0 +1,245 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Fetch = void 0;
+var Credential_service_1 = require("./Credential.service");
+var userTokenKey = "tokenInfo";
+//If refresh token expired, then logout from app
+var handleSessionExpiry = function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        localStorage.removeItem(userTokenKey);
+        localStorage.setItem("verified", JSON.stringify({ value: false }));
+        sessionStorage.setItem("LAMP._auth", JSON.stringify({ id: null, password: null, serverAddress: null }));
+        return [2 /*return*/];
+    });
+}); };
+//If access Token expired then call api for renewing the tokens
+var handleRenewToken = function (refreshToken, base) { return __awaiter(void 0, void 0, void 0, function () {
+    var credService, res, accessToken, error_1;
+    var _a, _b, _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _d.trys.push([0, 2, , 3]);
+                credService = new Credential_service_1.CredentialService();
+                return [4 /*yield*/, credService.renewToken(refreshToken, base)];
+            case 1:
+                res = _d.sent();
+                accessToken = (_a = res === null || res === void 0 ? void 0 : res.data) === null || _a === void 0 ? void 0 : _a.access_token;
+                if (accessToken) {
+                    sessionStorage.setItem(userTokenKey, JSON.stringify({ accessToken: (_b = res === null || res === void 0 ? void 0 : res.data) === null || _b === void 0 ? void 0 : _b.access_token, refreshToken: (_c = res === null || res === void 0 ? void 0 : res.data) === null || _c === void 0 ? void 0 : _c.refresh_token }));
+                }
+                return [2 /*return*/, accessToken];
+            case 2:
+                error_1 = _d.sent();
+                console.log(error_1);
+                return [3 /*break*/, 3];
+            case 3: return [2 /*return*/];
+        }
+    });
+}); };
+function _fetch(method, route, configuration, body) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function () {
+        var authorization, userTokenFromLocalStore, response, result, refreshToken, token, _c, tokenError_1, error_2, message;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    if (!configuration)
+                        throw new Error("Cannot make HTTP request due to invalid configuration.");
+                    userTokenFromLocalStore = JSON.parse(sessionStorage.getItem("tokenInfo"));
+                    if (userTokenFromLocalStore === null || userTokenFromLocalStore === void 0 ? void 0 : userTokenFromLocalStore.accessToken) {
+                        authorization = "Bearer " + (configuration.accessToken ? configuration.accessToken : userTokenFromLocalStore === null || userTokenFromLocalStore === void 0 ? void 0 : userTokenFromLocalStore.accessToken);
+                    }
+                    _d.label = 1;
+                case 1:
+                    _d.trys.push([1, 23, , 24]);
+                    return [4 /*yield*/, fetch("" + configuration.base + route, {
+                            method: method,
+                            headers: new Headers(typeof authorization !== "undefined" && !!authorization
+                                ? __assign(__assign({ "Content-Type": "application/json", Accept: "application/json" }, (configuration.headers || {})), { Authorization: authorization }) : __assign({ "Content-Type": "application/json", Accept: "application/json" }, (configuration.headers || {}))),
+                            credentials: "include",
+                            body: body !== undefined ? JSON.stringify(body) : undefined,
+                        })];
+                case 2:
+                    response = _d.sent();
+                    if (!response.ok) {
+                        console.warn("HTTP error " + response.status);
+                    }
+                    return [4 /*yield*/, response.json().catch(function () {
+                            throw new Error("Invalid JSON response");
+                        })
+                        // Handle invalid token
+                    ];
+                case 3:
+                    result = _d.sent();
+                    if (!((result === null || result === void 0 ? void 0 : result.error) === "401.invalid-token" || (result === null || result === void 0 ? void 0 : result.message) === "401.invalid-token")) return [3 /*break*/, 22];
+                    if (!!route.includes("renewToken")) return [3 /*break*/, 21];
+                    _d.label = 4;
+                case 4:
+                    _d.trys.push([4, 19, , 20]);
+                    refreshToken = (_a = configuration.refreshToken) !== null && _a !== void 0 ? _a : userTokenFromLocalStore === null || userTokenFromLocalStore === void 0 ? void 0 : userTokenFromLocalStore.refreshToken;
+                    if (!refreshToken) {
+                        handleSessionExpiry();
+                        return [2 /*return*/, { data: [], error: "401.invalid-token" }];
+                    }
+                    return [4 /*yield*/, handleRenewToken(refreshToken, configuration.base)];
+                case 5:
+                    token = _d.sent();
+                    if (!token) return [3 /*break*/, 17];
+                    configuration.authorization = token;
+                    _c = method;
+                    switch (_c) {
+                        case "post": return [3 /*break*/, 6];
+                        case "get": return [3 /*break*/, 8];
+                        case "put": return [3 /*break*/, 10];
+                        case "delete": return [3 /*break*/, 12];
+                        case "patch": return [3 /*break*/, 14];
+                    }
+                    return [3 /*break*/, 16];
+                case 6: return [4 /*yield*/, Fetch.post(route, body, configuration)];
+                case 7: return [2 /*return*/, _d.sent()];
+                case 8: return [4 /*yield*/, Fetch.get(route, configuration)];
+                case 9: return [2 /*return*/, _d.sent()];
+                case 10: return [4 /*yield*/, Fetch.put(route, body, configuration)];
+                case 11: return [2 /*return*/, _d.sent()];
+                case 12: return [4 /*yield*/, Fetch.delete(route, configuration)];
+                case 13: return [2 /*return*/, _d.sent()];
+                case 14: return [4 /*yield*/, Fetch.patch(route, body, configuration)];
+                case 15: return [2 /*return*/, _d.sent()];
+                case 16: return [3 /*break*/, 18];
+                case 17:
+                    handleSessionExpiry();
+                    return [2 /*return*/, { data: [], error: "401.invalid-token" }];
+                case 18: return [3 /*break*/, 20];
+                case 19:
+                    tokenError_1 = _d.sent();
+                    console.error("Token renewal failed:", tokenError_1);
+                    handleSessionExpiry();
+                    return [2 /*return*/, { data: [], error: "401.invalid-token" }];
+                case 20: return [3 /*break*/, 22];
+                case 21:
+                    handleSessionExpiry();
+                    return [2 /*return*/, { data: [], error: "401.invalid-token" }];
+                case 22: return [2 /*return*/, result];
+                case 23:
+                    error_2 = _d.sent();
+                    message = ((_b = error_2) === null || _b === void 0 ? void 0 : _b.message) || String(error_2);
+                    console.error("Fetch failed:", message);
+                    return [2 /*return*/, { data: [], error: message || "Unknown error" }];
+                case 24: return [2 /*return*/];
+            }
+        });
+    });
+}
+var Fetch = /** @class */ (function () {
+    function Fetch() {
+    }
+    Fetch.get = function (route, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, _fetch("get", route, configuration)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Fetch.post = function (route, body, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, _fetch("post", route, configuration, body)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Fetch.put = function (route, body, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, _fetch("put", route, configuration, body)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Fetch.patch = function (route, body, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, _fetch("patch", route, configuration, body)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Fetch.delete = function (route, configuration, body) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, _fetch("delete", route, configuration, body)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    return Fetch;
+}());
+exports.Fetch = Fetch;
+// export async function verifyToken(token: string, secretKey: string) {
+//   try {
+//     const secret_Key = new TextEncoder().encode(this.configuration.jwt_secret);
+//     const decoded = jwtVerify(token, secret_Key);
+//     return decoded;
+//   } catch (error) {
+//     throw new Error('Invalid token');
+//   }
+// }