@openk9ui/openk9-chatbot 3.0.1

package/dist/lib/components/useFocusTrap.js

@@ -0,0 +1,85 @@
+"use strict";
+exports.__esModule = true;
+exports.useFocusTrap = exports.sortByTabIndex = exports.getTabIndexOfNode = exports.convertToIntOrFallback = void 0;
+var react_1 = require("react");
+function convertToIntOrFallback(stringToConvert) {
+    var parsed = parseInt(stringToConvert !== null && stringToConvert !== void 0 ? stringToConvert : "");
+    return isNaN(parsed) ? 0 : parsed;
+}
+exports.convertToIntOrFallback = convertToIntOrFallback;
+function getTabIndexOfNode(targetNode) {
+    return convertToIntOrFallback(targetNode.getAttribute("tabindex"));
+}
+exports.getTabIndexOfNode = getTabIndexOfNode;
+function sanitizeTabIndexInput(tabIndex, highestPositiveTabIndex) {
+    if (tabIndex < 0) {
+        throw new Error("Unable to sort given input. A negative value is not part of the tab order: ".concat(tabIndex));
+    }
+    return tabIndex === 0 ? highestPositiveTabIndex + 1 : tabIndex;
+}
+function sortByTabIndex(firstNode, secondNode) {
+    var tabIndexes = [firstNode, secondNode].map(function (node) {
+        return getTabIndexOfNode(node);
+    });
+    return tabIndexes
+        .map(function (tabIndexValue) {
+        return sanitizeTabIndexInput(tabIndexValue, Math.max.apply(Math, tabIndexes));
+    })
+        .reduce(function (previousValue, currentValue) { return previousValue - currentValue; });
+}
+exports.sortByTabIndex = sortByTabIndex;
+var focusableElementsSelector = "a[href], area[href], input:not([disabled]):not([type=hidden]), select:not([disabled]), textarea:not([disabled]), button:not([disabled]), iframe, object, embed, *[tabindex], *[contenteditable]";
+var TAB_KEY = 9;
+function useFocusTrap(isActive) {
+    var trapRef = (0, react_1.useRef)(null);
+    var selectNextFocusableElem = (0, react_1.useCallback)(function (sortedFocusableElems, currentIndex, shiftKeyPressed, skipCount) {
+        var _a;
+        if (shiftKeyPressed === void 0) { shiftKeyPressed = false; }
+        if (skipCount === void 0) { skipCount = 0; }
+        if (skipCount > sortedFocusableElems.length) {
+            return;
+        }
+        var backwards = !!shiftKeyPressed;
+        var maxIndex = sortedFocusableElems.length - 1;
+        if (currentIndex === undefined) {
+            currentIndex =
+                (_a = sortedFocusableElems.indexOf(document.activeElement)) !== null && _a !== void 0 ? _a : 0;
+        }
+        var nextIndex = backwards ? currentIndex - 1 : currentIndex + 1;
+        if (nextIndex > maxIndex) {
+            nextIndex = 0;
+        }
+        if (nextIndex < 0) {
+            nextIndex = maxIndex;
+        }
+        var newFocusElem = sortedFocusableElems[nextIndex];
+        newFocusElem.focus();
+        if (document.activeElement !== newFocusElem) {
+            selectNextFocusableElem(sortedFocusableElems, nextIndex, shiftKeyPressed, skipCount + 1);
+        }
+    }, []);
+    var trapper = (0, react_1.useCallback)(function (evt) {
+        var trapRefElem = trapRef.current;
+        if (trapRefElem !== null) {
+            if (evt.which === TAB_KEY || evt.key === "Tab") {
+                evt.preventDefault();
+                var shiftKeyPressed = !!evt.shiftKey;
+                var focusableElems = Array.from(trapRefElem.querySelectorAll(focusableElementsSelector)).filter(function (focusableElement) { return getTabIndexOfNode(focusableElement) >= 0; });
+                focusableElems = focusableElems.sort(sortByTabIndex);
+                selectNextFocusableElem(focusableElems, undefined, shiftKeyPressed);
+            }
+        }
+    }, [selectNextFocusableElem]);
+    (0, react_1.useEffect)(function () {
+        if (isActive) {
+            window.addEventListener("keydown", trapper);
+        }
+        return function () {
+            if (isActive) {
+                window.removeEventListener("keydown", trapper);
+            }
+        };
+    }, [isActive, trapper]);
+    return [trapRef];
+}
+exports.useFocusTrap = useFocusTrap;

package/dist/lib/components/useGenerateResponse.js

@@ -0,0 +1,310 @@
+"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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 (g && (g = 0, op[0] && (_ = 0)), _) 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 __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+exports.__esModule = true;
+var react_1 = __importStar(require("react"));
+var uuid_1 = require("uuid");
+var useLanguage_1 = require("./useLanguage");
+var client_1 = require("./client");
+var useGenerateResponse = function (_a) {
+    var initialMessages = _a.initialMessages, tenant = _a.tenant, callbackAuthorization = _a.callbackAuthorization;
+    var language = (0, useLanguage_1.useLanguage)().language;
+    var _b = (0, react_1.useState)(initialMessages), messages = _b[0], setMessages = _b[1];
+    var _c = (0, react_1.useState)(new Map()), abortControllers = _c[0], setAbortControllers = _c[1];
+    var _d = (0, react_1.useState)(false), isChatting = _d[0], setIsChatting = _d[1];
+    var _e = (0, react_1.useState)(null), isLoading = _e[0], setIsLoading = _e[1];
+    var client = react_1["default"].useMemo(function () { return (0, client_1.OpenK9Client)({ callbackAuthorization: callbackAuthorization }); }, [callbackAuthorization]);
+    var generateResponse = (0, react_1.useCallback)(function (query) { return __awaiter(void 0, void 0, void 0, function () {
+        var id, timestamp, nonLoggedUserId, chatHistory, controller, url, searchQuery, response_1, reader, decoder, done, buffer, _a, value, readerDone, boundaryIndex, _loop_1, error_1;
+        var _b, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    id = (0, uuid_1.v4)();
+                    setIsLoading({ id: id, isLoading: true });
+                    timestamp = "" + Date.now();
+                    nonLoggedUserId = "anonymous_".concat((0, uuid_1.v4)(), "_").concat(timestamp);
+                    chatHistory = messages.map(function (msg) { return ({
+                        question: msg.question,
+                        answer: msg.answer,
+                        title: "",
+                        sources: msg.sources || [],
+                        chat_id: nonLoggedUserId,
+                        timestamp: msg.timestamp || "",
+                        chat_sequence_number: msg.chat_sequence_number
+                    }); });
+                    setMessages(function (prevMessages) {
+                        var _a;
+                        var chat_sequence_number = (((_a = prevMessages[prevMessages.length - 1]) === null || _a === void 0 ? void 0 : _a.chat_sequence_number) || 0) +
+                            1;
+                        var newMessage = {
+                            id: id,
+                            question: query,
+                            answer: "",
+                            sendTime: new Date().toISOString(),
+                            status: "CHUNK",
+                            sources: [],
+                            chat_sequence_number: chat_sequence_number,
+                            timestamp: timestamp
+                        };
+                        return __spreadArray(__spreadArray([], prevMessages, true), [newMessage], false);
+                    });
+                    setIsChatting(true);
+                    controller = new AbortController();
+                    setAbortControllers(function (prev) { return new Map(prev).set(id, controller); });
+                    url = "".concat(tenant, "/api/rag/chat-tool");
+                    searchQuery = 
+                    // keycloak.authenticated ? {
+                    // 	searchText: query,
+                    // 	chatId,
+                    // 	chatSequenceNumber: messages[messages.length - 1]?.chat_sequence_number + 1 || 1,
+                    // 	timestamp,
+                    // // language,
+                    // } :
+                    {
+                        searchText: query,
+                        chatSequenceNumber: ((_b = messages[messages.length - 1]) === null || _b === void 0 ? void 0 : _b.chat_sequence_number) + 1 || 1,
+                        timestamp: timestamp,
+                        chatHistory: chatHistory
+                    };
+                    _d.label = 1;
+                case 1:
+                    _d.trys.push([1, 8, , 9]);
+                    return [4 /*yield*/, client.GenerateResponse({
+                            controller: controller,
+                            searchQuery: searchQuery,
+                            url: url
+                        })];
+                case 2:
+                    response_1 = _d.sent();
+                    if (!response_1.ok) return [3 /*break*/, 6];
+                    reader = (_c = response_1.body) === null || _c === void 0 ? void 0 : _c.getReader();
+                    decoder = new TextDecoder("utf-8");
+                    done = false;
+                    buffer = "";
+                    _d.label = 3;
+                case 3:
+                    if (!(!done && reader)) return [3 /*break*/, 5];
+                    return [4 /*yield*/, reader.read()];
+                case 4:
+                    _a = _d.sent(), value = _a.value, readerDone = _a.done;
+                    done = readerDone;
+                    buffer += decoder.decode(value, { stream: true });
+                    boundaryIndex = void 0;
+                    _loop_1 = function () {
+                        var chunkStr = buffer.slice(0, boundaryIndex);
+                        buffer = buffer.slice(boundaryIndex + 1);
+                        if (chunkStr.trim().startsWith("data: ")) {
+                            var dataStr = chunkStr.trim().slice(6);
+                            try {
+                                var data_1 = JSON.parse(dataStr);
+                                switch (data_1.type) {
+                                    case "CHUNK":
+                                        setMessages(function (prev) {
+                                            return prev.map(function (msg) {
+                                                return msg.id === id
+                                                    ? __assign(__assign({}, msg), { answer: msg.answer + data_1.chunk }) : msg;
+                                            });
+                                        });
+                                        break;
+                                    case "DOCUMENT":
+                                        setMessages(function (prev) {
+                                            return prev.map(function (msg) {
+                                                var _a;
+                                                return msg.id === id
+                                                    ? __assign(__assign({}, msg), { sources: __spreadArray(__spreadArray([], ((_a = msg === null || msg === void 0 ? void 0 : msg.sources) !== null && _a !== void 0 ? _a : []), true), [data_1.chunk], false) }) : msg;
+                                            });
+                                        });
+                                        break;
+                                    case "START":
+                                        setIsLoading(null);
+                                        break;
+                                    case "ERROR":
+                                        setMessages(function (prev) {
+                                            return prev.map(function (msg) {
+                                                return msg.id === id
+                                                    ? __assign(__assign({}, msg), { answer: data_1.chunk, status: "ERROR" }) : msg;
+                                            });
+                                        });
+                                        setIsChatting(false);
+                                        break;
+                                    case "END":
+                                        setMessages(function (prev) {
+                                            return prev.map(function (msg) {
+                                                return msg.id === id
+                                                    ? __assign(__assign({}, msg), { status: "END" }) : msg;
+                                            });
+                                        });
+                                        setIsChatting(false);
+                                        break;
+                                    default:
+                                        console.warn("Tipo di chunk non riconosciuto:", data_1.type);
+                                        break;
+                                }
+                            }
+                            catch (e) {
+                                console.error("Errore nel parsing del JSON", e);
+                            }
+                        }
+                    };
+                    while ((boundaryIndex = buffer.indexOf("\n")) !== -1) {
+                        _loop_1();
+                    }
+                    return [3 /*break*/, 3];
+                case 5: return [3 /*break*/, 7];
+                case 6:
+                    console.error("Errore nel generare la risposta");
+                    setMessages(function (prev) {
+                        return prev.map(function (msg) {
+                            return msg.id === id
+                                ? __assign(__assign({}, msg), { status: "ERROR", answer: (response_1 === null || response_1 === void 0 ? void 0 : response_1.statusText) || "Error" }) : msg;
+                        });
+                    });
+                    setIsChatting(false);
+                    _d.label = 7;
+                case 7:
+                    setIsChatting(false);
+                    setIsLoading(null);
+                    return [3 /*break*/, 9];
+                case 8:
+                    error_1 = _d.sent();
+                    console.error("Errore durante la richiesta", error_1);
+                    setIsChatting(false);
+                    return [3 /*break*/, 9];
+                case 9:
+                    setAbortControllers(function (prev) {
+                        var updated = new Map(prev);
+                        updated["delete"](id);
+                        return updated;
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    }); }, [messages, client, tenant, language]);
+    var cancelResponse = function (id) {
+        var controller = abortControllers.get(id);
+        if (controller) {
+            controller.abort();
+            setIsLoading(null);
+            setMessages(function (prev) {
+                return prev.map(function (msg) {
+                    return msg.id === id
+                        ? __assign(__assign({}, msg), { status: "END", answer: "La risposta è stata annullata" }) : msg;
+                });
+            });
+            setAbortControllers(function (prev) {
+                var updated = new Map(prev);
+                updated["delete"](id);
+                return updated;
+            });
+            setIsChatting(abortControllers.size > 0);
+        }
+        else {
+            console.warn("No AbortController found for id: ".concat(id));
+        }
+    };
+    var cancelAllResponses = function () {
+        abortControllers.forEach(function (controller) {
+            controller.abort();
+        });
+        setMessages(function (prev) {
+            return prev.map(function (msg) {
+                return msg.status === "CHUNK"
+                    ? __assign(__assign({}, msg), { status: "END", answer: msg.answer + "... La risposta è stata annullata" }) : msg;
+            });
+        });
+        setAbortControllers(new Map());
+        setIsChatting(false);
+        setIsLoading(null);
+    };
+    var resetMessage = function () {
+        setMessages([]);
+    };
+    return {
+        messages: messages,
+        generateResponse: generateResponse,
+        cancelResponse: cancelResponse,
+        cancelAllResponses: cancelAllResponses,
+        isChatting: isChatting,
+        isLoading: isLoading,
+        resetMessage: resetMessage
+    };
+};
+exports["default"] = useGenerateResponse;

package/dist/lib/components/useLanguage.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.useLanguage = void 0;
+var react_1 = require("react");
+var LanguageContext_1 = __importDefault(require("./LanguageContext"));
+var useLanguage = function () {
+    var context = (0, react_1.useContext)(LanguageContext_1["default"]);
+    if (!context) {
+        throw new Error("useLanguage must used to LanguageProvider");
+    }
+    return context;
+};
+exports.useLanguage = useLanguage;

package/dist/lib/main.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.Chatbot = void 0;
+var Chatbot_1 = __importDefault(require("./components/Chatbot"));
+exports.Chatbot = Chatbot_1["default"];

package/dist/main.js

@@ -0,0 +1,4 @@
+import { default as default2 } from "./components/Chatbot.js";
+export {
+  default2 as Chatbot
+};

package/dist/src/theme.js

@@ -0,0 +1,52 @@
+"use strict";
+exports.__esModule = true;
+exports.defaultThemeK9 = void 0;
+var styles_1 = require("@mui/material/styles");
+exports.defaultThemeK9 = (0, styles_1.createTheme)({
+    breakpoints: {
+        values: {
+            xs: 0,
+            sm: 576,
+            md: 768,
+            lg: 992,
+            xl: 1200
+        }
+    },
+    palette: {
+        primary: {
+            main: "#C0272B",
+            contrastText: "#FFF",
+            dark: "#b10707",
+            light: "#e77979"
+        },
+        text: {
+            primary: "#000000",
+            secondary: "#666666"
+        }
+    },
+    typography: {
+        allVariants: {
+            fontFamily: "Titillium Web"
+        },
+        fontFamily: "Titillium Web",
+        body1: {
+            fontWeight: 400,
+            fontSize: "12px",
+            lineHeight: "19px"
+        },
+        body2: {
+            fontFamily: "Roboto",
+            font: "Roboto",
+            fontWeight: 500,
+            fontSize: "10px",
+            lineHeight: "12px"
+        },
+        h5: {
+            fontWeight: 400,
+            fontSize: "12px",
+            lineHeight: "22px"
+        }
+    },
+    spacing: 2,
+    shape: { borderRadius: 2 }
+});

package/dist/types/lib/components/Chatbot.d.ts

@@ -0,0 +1,26 @@
+import { Theme } from "@mui/material";
+import React from "react";
+import "@fontsource/roboto";
+import "@fontsource/titillium-web";
+export type IconProps = {
+    buttonIcon?: React.ReactNode;
+    userIcon?: React.ReactNode;
+    chatbotIcon?: React.ReactNode;
+    refreshChatIcon?: React.ReactNode;
+    closeIcon?: React.ReactNode;
+    searchIcon?: React.ReactNode;
+    logoIcon?: React.ReactNode;
+    closeModal?: React.ReactNode;
+};
+type ChatbotProps = {
+    icon: IconProps;
+    title?: React.ReactNode;
+    initialMessage?: string;
+    nameChatbot?: string;
+    themeCustom?: Theme;
+    language?: string;
+    tenant?: string;
+    callbackAuthorization?: () => string | undefined | null;
+};
+declare const Chatbot: React.FC<ChatbotProps>;
+export default Chatbot;

package/dist/types/lib/components/LanguageContext.d.ts

@@ -0,0 +1,12 @@
+import React, { ReactNode } from "react";
+type LanguageContextType = {
+    language: string;
+    setLanguage: (language: string) => void;
+};
+declare const LanguageContext: React.Context<LanguageContextType>;
+type LanguageProviderProps = {
+    children: ReactNode;
+    initialLanguage?: string;
+};
+export declare const LanguageProvider: React.FC<LanguageProviderProps>;
+export default LanguageContext;

package/dist/types/lib/components/Search.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import { IconProps } from "./Chatbot";
+export default function Search({ handleSearch, isChatting, icon, chatbotSearchRef, }: {
+    handleSearch: (message: string) => void;
+    cancelAllResponses(): void;
+    isChatting: boolean;
+    icon: IconProps;
+    chatbotSearchRef: React.MutableRefObject<HTMLHeadingElement | null>;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/lib/components/SingleMessage.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="react" />
+type Theme = "light" | "dark";
+type Source = {
+    score?: string;
+    title?: string;
+    url?: string;
+};
+export declare function SingleMessage({ contentMessage, timeMessage, isChatbot, isLoading, icon, nameChatbot, status, sources, themeInfo, }: {
+    contentMessage: string;
+    timeMessage: string;
+    isChatbot: boolean;
+    isLoading?: boolean;
+    icon?: React.ReactNode;
+    nameChatbot?: string;
+    status?: "END" | "CHUNK" | "ERROR";
+    sources?: Source[];
+    themeInfo?: Theme;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/lib/components/Translate.d.ts

@@ -0,0 +1,5 @@
+export declare function Translate({ label }: {
+    label: TranslationKey;
+}): string;
+type TranslationKey = "closeChatbot" | "openChatbot" | "clearChat" | "startQuestion" | "youSendMessage" | "sendMessage" | "customPlaceholder" | "searchLabel";
+export {};

package/dist/types/lib/components/client.d.ts

@@ -0,0 +1,91 @@
+import React from "react";
+export declare const OpenK9ClientContext: React.Context<{
+    getInitialMessages(chatId: string): Promise<{
+        chat_id: string;
+        messages: [
+            {
+                question: string;
+                answer: string;
+                chat_sequence_number: string;
+            }
+        ];
+    }>;
+    getHistoryChat(searchQuery: jsonObjPost): Promise<{
+        result: ChatHistory[];
+    }>;
+    GenerateResponse({ url, searchQuery, controller, }: {
+        url: string;
+        searchQuery: {
+            searchText: string;
+            chatId?: string;
+            chatSequenceNumber: number;
+            timestamp: string;
+            chatHistory?: Array<{
+                question: string;
+                answer: string;
+                title: string;
+                sources: Array<any>;
+                chat_id: string;
+                timestamp: string;
+                chat_sequence_number: number;
+            }>;
+        };
+        controller: AbortController;
+    }): Promise<Response>;
+}>;
+export default function Client(): any;
+export declare function OpenK9Client({ callbackAuthorization, }: {
+    callbackAuthorization?: () => string | undefined | null;
+}): {
+    getInitialMessages(chatId: string): Promise<{
+        chat_id: string;
+        messages: [
+            {
+                question: string;
+                answer: string;
+                chat_sequence_number: string;
+            }
+        ];
+    }>;
+    getHistoryChat(searchQuery: jsonObjPost): Promise<{
+        result: ChatHistory[];
+    }>;
+    GenerateResponse({ url, searchQuery, controller, }: {
+        url: string;
+        searchQuery: {
+            searchText: string;
+            chatId?: string;
+            chatSequenceNumber: number;
+            timestamp: string;
+            chatHistory?: Array<{
+                question: string;
+                answer: string;
+                title: string;
+                sources: Array<any>;
+                chat_id: string;
+                timestamp: string;
+                chat_sequence_number: number;
+            }>;
+        };
+        controller: AbortController;
+    }): Promise<Response>;
+};
+export interface getUserInfo {
+    refreshOnSuggestionCategory: boolean;
+    refreshOnTab: boolean;
+    refreshOnDate: boolean;
+    refreshOnQuery: boolean;
+    retrieveType: "MATCH" | "KNN" | "HYBRID";
+}
+export interface ChatHistory {
+    chat_id: string | null;
+    title: string;
+    question: string;
+    timestamp: string;
+}
+export type jsonObjPost = {
+    userId: string;
+    chatSequenceNumber?: number;
+    paginationFrom: number;
+    paginationSize: number;
+};

package/dist/types/lib/components/styled.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+export declare const ParagraphTime: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme;
+    as?: import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>;
+} & {
+    $color?: string;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, {}>;
+export declare const ParagraphMessage: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme;
+    as?: import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>;
+} & {
+    $color?: string;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, {}>;

package/dist/types/lib/components/useFocusTrap.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+export declare function convertToIntOrFallback(stringToConvert: string | null): number;
+export declare function getTabIndexOfNode(targetNode: HTMLElement): number;
+export declare function sortByTabIndex(firstNode: HTMLElement, secondNode: HTMLElement): number;
+export declare function useFocusTrap(isActive: boolean): [React.RefObject<HTMLDivElement>];