@iblai/web-containers 0.0.6 → 0.2.0

package/dist/web-containers/src/components/ui/label.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+import * as LabelPrimitive from "@radix-ui/react-label";
+import { type VariantProps } from "class-variance-authority";
+declare const Label: React.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React.RefAttributes<HTMLLabelElement>, "ref"> & VariantProps<(props?: import("class-variance-authority/dist/types").ClassProp | undefined) => string> & React.RefAttributes<HTMLLabelElement>>;
+export { Label };

package/dist/web-containers/src/components/ui/pagination.d.ts

@@ -0,0 +1,28 @@
+import * as React from "react";
+import { ButtonProps } from "@web-containers/components/ui/button";
+declare const Pagination: {
+    ({ className, ...props }: React.ComponentProps<"nav">): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const PaginationContent: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React.RefAttributes<HTMLUListElement>>;
+declare const PaginationItem: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React.RefAttributes<HTMLLIElement>>;
+type PaginationLinkProps = {
+    isActive?: boolean;
+} & Pick<ButtonProps, "size"> & React.ComponentProps<"a">;
+declare const PaginationLink: {
+    ({ className, isActive, size, ...props }: PaginationLinkProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const PaginationPrevious: {
+    ({ className, ...props }: React.ComponentProps<typeof PaginationLink>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const PaginationNext: {
+    ({ className, ...props }: React.ComponentProps<typeof PaginationLink>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const PaginationEllipsis: {
+    ({ className, ...props }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { Pagination, PaginationContent, PaginationLink, PaginationItem, PaginationPrevious, PaginationNext, PaginationEllipsis, };

package/dist/web-containers/src/components/ui/popover.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+import * as PopoverPrimitive from "@radix-ui/react-popover";
+declare const Popover: React.FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTrigger: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const PopoverContent: React.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Popover, PopoverTrigger, PopoverContent };

package/dist/web-containers/src/components/ui/select.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+import * as SelectPrimitive from "@radix-ui/react-select";
+declare const Select: React.FC<SelectPrimitive.SelectProps>;
+declare const SelectGroup: React.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const SelectValue: React.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
+declare const SelectTrigger: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const SelectScrollUpButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollUpButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectScrollDownButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollDownButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectContent: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectLabel: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectItem: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectSeparator: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Select, SelectGroup, SelectValue, SelectTrigger, SelectContent, SelectLabel, SelectItem, SelectSeparator, SelectScrollUpButton, SelectScrollDownButton, };

package/dist/web-containers/src/components/ui/separator.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import * as SeparatorPrimitive from "@radix-ui/react-separator";
+declare const Separator: React.ForwardRefExoticComponent<Omit<SeparatorPrimitive.SeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Separator };

package/dist/web-containers/src/components/ui/skeleton.d.ts

@@ -0,0 +1,2 @@
+declare function Skeleton({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+export { Skeleton };

package/dist/web-containers/src/components/ui/sonner.d.ts

@@ -0,0 +1,4 @@
+import { Toaster as Sonner } from "sonner";
+type ToasterProps = React.ComponentProps<typeof Sonner>;
+declare const Toaster: ({ ...props }: ToasterProps) => import("react/jsx-runtime").JSX.Element;
+export { Toaster };

package/dist/web-containers/src/components/ui/switch.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import * as SwitchPrimitives from "@radix-ui/react-switch";
+declare const Switch: React.ForwardRefExoticComponent<Omit<SwitchPrimitives.SwitchProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { Switch };

package/dist/web-containers/src/components/ui/table.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+declare const Table: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableElement> & React.RefAttributes<HTMLTableElement>>;
+declare const TableHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableBody: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableRow: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableRowElement> & React.RefAttributes<HTMLTableRowElement>>;
+declare const TableHead: React.ForwardRefExoticComponent<React.ThHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
+declare const TableCell: React.ForwardRefExoticComponent<React.TdHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
+declare const TableCaption: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableCaptionElement> & React.RefAttributes<HTMLTableCaptionElement>>;
+export { Table, TableHeader, TableBody, TableFooter, TableHead, TableRow, TableCell, TableCaption, };

package/dist/web-containers/src/components/ui/tabs.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import * as TabsPrimitive from "@radix-ui/react-tabs";
+declare const Tabs: React.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React.RefAttributes<HTMLDivElement>>;
+declare const TabsList: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const TabsTrigger: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const TabsContent: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Tabs, TabsList, TabsTrigger, TabsContent };

package/dist/web-containers/src/components/ui/textarea.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare const Textarea: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement>, "ref"> & React.RefAttributes<HTMLTextAreaElement>>;
+export { Textarea };

package/dist/web-containers/src/components/ui/toast.d.ts

@@ -0,0 +1,15 @@
+import * as React from "react";
+import * as ToastPrimitives from "@radix-ui/react-toast";
+import { type VariantProps } from "class-variance-authority";
+declare const ToastProvider: React.FC<ToastPrimitives.ToastProviderProps>;
+declare const ToastViewport: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastViewportProps & React.RefAttributes<HTMLOListElement>, "ref"> & React.RefAttributes<HTMLOListElement>>;
+declare const Toast: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastProps & React.RefAttributes<HTMLLIElement>, "ref"> & VariantProps<(props?: ({
+    variant?: "default" | "destructive" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string> & React.RefAttributes<HTMLLIElement>>;
+declare const ToastAction: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastActionProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const ToastClose: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastCloseProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const ToastTitle: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastTitleProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ToastDescription: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastDescriptionProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+type ToastProps = React.ComponentPropsWithoutRef<typeof Toast>;
+type ToastActionElement = React.ReactElement<typeof ToastAction>;
+export { type ToastProps, type ToastActionElement, ToastProvider, ToastViewport, Toast, ToastTitle, ToastDescription, ToastClose, ToastAction, };

package/dist/web-containers/src/components/ui/toaster.d.ts

@@ -0,0 +1,15 @@
+import * as React from "react";
+import * as ToastPrimitives from "@radix-ui/react-toast";
+import { type VariantProps } from "class-variance-authority";
+declare const ToastProvider: React.FC<ToastPrimitives.ToastProviderProps>;
+declare const ToastViewport: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastViewportProps & React.RefAttributes<HTMLOListElement>, "ref"> & React.RefAttributes<HTMLOListElement>>;
+declare const Toast: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastProps & React.RefAttributes<HTMLLIElement>, "ref"> & VariantProps<(props?: ({
+    variant?: "default" | "destructive" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string> & React.RefAttributes<HTMLLIElement>>;
+declare const ToastAction: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastActionProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const ToastClose: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastCloseProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const ToastTitle: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastTitleProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ToastDescription: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastDescriptionProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+type ToastProps = React.ComponentPropsWithoutRef<typeof Toast>;
+type ToastActionElement = React.ReactElement<typeof ToastAction>;
+export { type ToastProps, type ToastActionElement, ToastProvider, ToastViewport, Toast, ToastTitle, ToastDescription, ToastClose, ToastAction, };

package/dist/web-containers/src/components/ui/tooltip.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+declare function TooltipProvider({ delayDuration, ...props }: React.ComponentProps<typeof TooltipPrimitive.Provider>): import("react/jsx-runtime").JSX.Element;
+declare function Tooltip({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function TooltipTrigger({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function TooltipContent({ className, sideOffset, children, ...props }: React.ComponentProps<typeof TooltipPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };

package/dist/web-containers/src/components/ui/use-toast.d.ts

@@ -0,0 +1,15 @@
+import * as React from "react";
+import * as ToastPrimitives from "@radix-ui/react-toast";
+import { type VariantProps } from "class-variance-authority";
+declare const ToastProvider: React.FC<ToastPrimitives.ToastProviderProps>;
+declare const ToastViewport: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastViewportProps & React.RefAttributes<HTMLOListElement>, "ref"> & React.RefAttributes<HTMLOListElement>>;
+declare const Toast: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastProps & React.RefAttributes<HTMLLIElement>, "ref"> & VariantProps<(props?: ({
+    variant?: "default" | "destructive" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string> & React.RefAttributes<HTMLLIElement>>;
+declare const ToastAction: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastActionProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const ToastClose: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastCloseProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const ToastTitle: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastTitleProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ToastDescription: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastDescriptionProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+type ToastProps = React.ComponentPropsWithoutRef<typeof Toast>;
+type ToastActionElement = React.ReactElement<typeof ToastAction>;
+export { type ToastProps, type ToastActionElement, ToastProvider, ToastViewport, Toast, ToastTitle, ToastDescription, ToastClose, ToastAction, };

package/dist/web-containers/src/components/user-profile-dropdown/index.d.ts

@@ -0,0 +1,52 @@
+import React from "react";
+import { Tenant } from "../tenant-switch/types";
+export interface UserMetadata {
+    name?: string;
+    username?: string;
+    email?: string;
+    profile_image?: {
+        has_image?: boolean;
+        image_url_small?: string;
+    };
+}
+export interface UserProfileDropdownProps {
+    username?: string;
+    userIsAdmin?: boolean;
+    userIsStudent?: boolean;
+    tenantKey?: string;
+    mentorId?: string;
+    currentTenant?: Tenant;
+    userTenants?: Tenant[];
+    showProfileTab?: boolean;
+    showAccountTab?: boolean;
+    showTenantSwitcher?: boolean;
+    showHelpLink?: boolean;
+    showLogoutButton?: boolean;
+    showLearnerModeSwitch?: boolean;
+    helpCenterUrl?: string;
+    enableGravatarOnProfilePic?: boolean;
+    onProfileClick?: (tab: string) => void;
+    onLogout?: () => void;
+    onTenantChange?: (tenantKey: string) => void;
+    onHelpClick?: (url: string) => void;
+    billingEnabled?: boolean;
+    billingURL?: string;
+    topUpEnabled?: boolean;
+    topUpURL?: string;
+    currentPlan?: string;
+    currentSPA?: string;
+    LearnerModeSwitchComponent?: React.ComponentType<any>;
+    CustomProfileModal?: React.ComponentType<any>;
+    className?: string;
+    dropdownClassName?: string;
+    avatarSize?: number;
+    metadata?: {
+        help_center_url?: string;
+    };
+    metadataLoaded?: boolean;
+    showMentorAIDisplayCheckbox?: boolean;
+    showLeaderboardDisplayCheckbox?: boolean;
+    showUsernameField?: boolean;
+    showPlatformName?: boolean;
+}
+export declare function UserProfileDropdown({ username, userIsAdmin, userIsStudent, tenantKey, mentorId, currentTenant, userTenants, showProfileTab, showAccountTab, showTenantSwitcher, showHelpLink, showLogoutButton, showLearnerModeSwitch, helpCenterUrl, enableGravatarOnProfilePic, onProfileClick, onLogout, onTenantChange, onHelpClick, billingEnabled, billingURL, topUpEnabled, topUpURL, currentPlan, LearnerModeSwitchComponent, CustomProfileModal, className, dropdownClassName, avatarSize, metadata, metadataLoaded, currentSPA, showMentorAIDisplayCheckbox, showLeaderboardDisplayCheckbox, showUsernameField, showPlatformName, }: UserProfileDropdownProps): import("react/jsx-runtime").JSX.Element;

package/dist/web-containers/src/components/version.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+export declare function Version({ appName, appVersion, poweredBy, }: {
+    appName: string;
+    appVersion: string;
+    poweredBy: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/web-containers/src/hooks/index.d.ts

@@ -0,0 +1 @@
+export * from "./use-iframe-message-handler";

package/dist/web-containers/src/hooks/use-iframe-message-handler.d.ts

@@ -0,0 +1,8 @@
+type MessageHandler = (payload: any, rawEvent: MessageEvent) => void | Promise<void>;
+type UseIframeMessageHandlerOptions = {
+    handlers: Record<string, MessageHandler>;
+    allowedOrigins?: string[];
+    defaultHandler?: (data: any) => void;
+};
+export declare function useIframeMessageHandler({ handlers, allowedOrigins, defaultHandler, }: UseIframeMessageHandlerOptions): void;
+export {};

package/dist/web-containers/src/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./hooks";
+export * from "./components";

package/dist/web-containers/src/lib/error-utils.d.ts

@@ -0,0 +1,15 @@
+import type React from "react";
+export interface ErrorData {
+    code: string;
+    title: string;
+    description: string;
+    icon: React.ReactNode;
+}
+export declare const ErrorIcons: {
+    notFound: import("react/jsx-runtime").JSX.Element;
+    serverError: import("react/jsx-runtime").JSX.Element;
+    forbidden: import("react/jsx-runtime").JSX.Element;
+    unauthorized: import("react/jsx-runtime").JSX.Element;
+    timeout: import("react/jsx-runtime").JSX.Element;
+};
+export declare function getErrorData(code: string): ErrorData;

package/dist/web-containers/src/lib/utils.d.ts

@@ -0,0 +1,2 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;

package/dist/web-containers/src/utils.d.ts

@@ -0,0 +1 @@
+export declare const getUserName: () => string;

package/dist/web-utils/src/features/chat/slice.d.ts

@@ -0,0 +1,91 @@
+import type { AdvancedTab } from "../../utils";
+import type { Message } from "../../hooks/chat/use-chat-v2";
+export type ChatState = Record<AdvancedTab, Message[]>;
+export interface SessionIds extends Record<AdvancedTab, string> {
+}
+export type StreamingMessage = {
+    id: string;
+    content: string;
+};
+export declare const defaultSessionIds: SessionIds;
+export type ChatStatus = "idle" | "pending" | "streaming" | "stopped" | "error";
+type ChatSliceState = {
+    chats: ChatState;
+    isTyping: boolean;
+    streaming: boolean;
+    currentStreamingMessage: StreamingMessage;
+    activeTab: AdvancedTab;
+    sessionId: string;
+    sessionIds: SessionIds;
+    status: ChatStatus;
+    tools: string[];
+    token: string | null;
+    iframeContext: {
+        hostInfo: {
+            title: string;
+            href: string;
+        };
+        pageContent: string;
+    };
+    documentFilter: Record<string, unknown> | null;
+};
+export declare const chatActions: import("@reduxjs/toolkit").CaseReducerActions<import("@reduxjs/toolkit").SliceCaseReducers<ChatSliceState>, string>;
+export declare const chatSliceReducerShared: import("@reduxjs/toolkit").Reducer<ChatSliceState>;
+export declare const selectChats: (state: {
+    chatSliceShared: ChatSliceState;
+}) => ChatState;
+export declare const selectIsTyping: (state: {
+    chatSliceShared: ChatSliceState;
+}) => boolean;
+export declare const selectStreaming: (state: {
+    chatSliceShared: ChatSliceState;
+}) => boolean;
+export declare const selectStatus: (state: {
+    chatSliceShared: ChatSliceState;
+}) => ChatStatus;
+export declare const selectIsPending: (state: {
+    chatSliceShared: ChatSliceState;
+}) => boolean;
+export declare const selectIsStopped: (state: {
+    chatSliceShared: ChatSliceState;
+}) => boolean;
+export declare const selectIsError: (state: {
+    chatSliceShared: ChatSliceState;
+}) => boolean;
+export declare const selectCurrentStreamingMessage: (state: {
+    chatSliceShared: ChatSliceState;
+}) => StreamingMessage;
+export declare const selectActiveTab: (state: {
+    chatSliceShared: ChatSliceState;
+}) => "chat" | "summarize" | "translate" | "expand";
+export declare const selectSessionId: (state: {
+    chatSliceShared: ChatSliceState;
+}) => string;
+export declare const selectSessionIds: (state: {
+    chatSliceShared: ChatSliceState;
+}) => SessionIds;
+export declare const selectIframeContext: (state: {
+    chatSliceShared: ChatSliceState;
+}) => {
+    hostInfo: {
+        title: string;
+        href: string;
+    };
+    pageContent: string;
+};
+export declare const selectDocumentFilter: (state: {
+    chatSliceShared: ChatSliceState;
+}) => Record<string, unknown> | null;
+export declare const selectTools: (state: {
+    chatSliceShared: ChatSliceState;
+}) => string[];
+export declare const selectToken: (state: {
+    chatSliceShared: ChatSliceState;
+}) => string | null;
+export declare const selectActiveChatMessages: (state: {
+    chatSliceShared: ChatSliceState;
+}) => Message[];
+export declare const selectNumberOfActiveChatMessages: (state: {
+    chatSliceShared: ChatSliceState;
+}) => number;
+export {};

package/dist/web-utils/src/features/index.d.ts

@@ -0,0 +1 @@
+export * from "./chat/slice";

package/dist/web-utils/src/hooks/chat/use-advanced-chat.d.ts

@@ -0,0 +1,48 @@
+import React from "react";
+import type { ChatMode } from "../../types";
+import { type AdvancedTab } from "../../utils";
+import { Message } from "./use-chat-v2";
+import { ChatStatus } from "../../features/chat/slice";
+type Props = {
+    mode: ChatMode;
+    tenantKey: string;
+    mentorId: string;
+    username: string;
+    token: string;
+    wsUrl: string;
+    redirectToAuthSpa: () => void;
+    stopGenerationWsUrl: string;
+    sendMessageToParentWebsite?: (payload: unknown) => void;
+    errorHandler?: (message: string, error?: any) => void;
+    isPreviewMode?: boolean;
+    mentorShareableToken?: string | null;
+    on402Error?: (message: Record<string, unknown>) => void;
+};
+export declare function useAdvancedChat({ mode, tenantKey, mentorId, username, token, wsUrl, stopGenerationWsUrl, redirectToAuthSpa, errorHandler, sendMessageToParentWebsite, isPreviewMode, mentorShareableToken, on402Error, }: Props): {
+    messages: Message[];
+    isStreaming: boolean;
+    status: ChatStatus;
+    isPending: boolean;
+    isStopped: boolean;
+    isError: boolean;
+    currentStreamingMessage: import("../../features/chat/slice").StreamingMessage;
+    activeTab: "chat" | "summarize" | "translate" | "expand";
+    uniqueMentorId: string;
+    mentorName: string;
+    profileImage: string;
+    enabledGuidedPrompts: boolean;
+    sendMessage: (tab: AdvancedTab, text: string, options?: import("./use-chat-v2").SendMessageOptions) => Promise<void>;
+    stopGenerating: () => void;
+    setMessage: (message: Message) => void;
+    changeTab: (tab: AdvancedTab) => Promise<void>;
+    sessionId: string;
+    startNewChat: () => Promise<void>;
+    isLoadingSessionIds: boolean;
+    ws: React.MutableRefObject<WebSocket | null>;
+    isConnected: React.MutableRefObject<boolean>;
+    messageQueue: React.MutableRefObject<any[]>;
+    sessionIds: import("../../features/chat/slice").SessionIds;
+    enableSafetyDisclaimer: any;
+    resetConnection: () => void;
+};
+export {};

package/dist/web-utils/src/hooks/chat/use-chat-v2.d.ts

@@ -0,0 +1,56 @@
+import type { AdvancedTab } from "../../utils/data/advanced-tab";
+import { ChatStatus } from "@web-utils/features";
+export interface Message {
+    id: string;
+    role: "user" | "assistant" | "system";
+    content: string;
+    timestamp: string;
+    url?: string;
+    fileType?: string;
+    contentType?: string;
+    visible: boolean;
+}
+export type SendMessageOptions = {
+    visible?: boolean;
+} | undefined;
+export interface UseChatProps {
+    wsUrl: string;
+    wsToken: string;
+    flowConfig: {
+        name: string;
+        tenant: string;
+        username: string;
+        pathway: string;
+    };
+    sessionId: string;
+    stopGenerationWsUrl: string;
+    activeTab: AdvancedTab;
+    enableHaptics?: boolean;
+    hapticFeedback?: {
+        impactAsync: (style: any) => Promise<void>;
+    };
+    redirectToAuthSpa: () => void;
+    store?: {
+        sendMessage?: (text: string) => Promise<void>;
+    };
+    WebSocketImpl?: typeof WebSocket;
+    errorHandler?: (message: string, error?: any) => void;
+    onStatusChange: (status: ChatStatus) => void;
+    onStreamingChange: (streaming: boolean) => void;
+    onStreamingMessageUpdate: (message: {
+        id: string | null;
+        content: string;
+    }) => void;
+    onAddUserMessage?: (activeTab: AdvancedTab, message: Message) => void;
+    sendMessageToParentWebsite?: (payload: unknown) => void;
+    on402Error?: (message: Record<string, unknown>) => void;
+}
+export interface UseChatReturn {
+    sendMessage: (tab: AdvancedTab, text: string, options?: SendMessageOptions) => Promise<void>;
+    ws: React.MutableRefObject<WebSocket | null>;
+    isConnected: React.MutableRefObject<boolean>;
+    messageQueue: React.MutableRefObject<any[]>;
+    stopGenerating: () => void;
+    resetConnection: () => void;
+}
+export declare const useChat: ({ wsUrl, wsToken, flowConfig, sessionId, stopGenerationWsUrl, activeTab, enableHaptics, hapticFeedback, store, errorHandler, onStatusChange, onStreamingChange, onStreamingMessageUpdate, onAddUserMessage, WebSocketImpl, redirectToAuthSpa, sendMessageToParentWebsite, on402Error, }: UseChatProps) => UseChatReturn;

package/dist/web-utils/src/hooks/chat/use-mentor-tools.d.ts

@@ -0,0 +1,18 @@
+type Props = {
+    tenantKey: string;
+    mentorId: string;
+    username: string;
+    errorHandler?: (message: string, error?: any) => void;
+};
+export declare function useMentorTools({ tenantKey, mentorId, username, errorHandler, }: Props): {
+    tools: any;
+    activeTools: string[];
+    updateSessionTools: (tool: string) => Promise<void>;
+    enableWebBrowsing: boolean;
+    screenSharing: boolean;
+    deepResearch: boolean;
+    imageGeneration: boolean;
+    codeInterpreter: boolean;
+    promptsIsEnabled: boolean;
+};
+export {};

package/dist/web-utils/src/hooks/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./subscription/use-subscription-handler";
+export * from "./subscription/constants";
+export * from "./subscription/class-subscription-flow";
+export * from "./subscription-v2/use-subscription-handler";
+export * from "./subscription-v2/class-subscription-flow";
+export * from "./subscription-v2/use-external-pricing-plan";
+export * from "./subscription-v2/constants";
+export * from "./use-day-js";
+export * from "./chat/use-advanced-chat";
+export * from "./chat/use-mentor-tools";
+export * from "./profile/use-user-profile-update";
+export * from "./profile/use-profile-image-upload";
+export * from "./chat/use-chat-v2";
+export * from "./tenant-metadata/use-tenant-metadata";
+export * from "./tenant-metadata/constants";

package/dist/web-utils/src/hooks/profile/use-profile-image-upload.d.ts

@@ -0,0 +1,13 @@
+import { UploadProfileImageResponse, RemoveProfileImageResponse } from '@iblai/data-layer';
+export interface UseProfileImageUploadOptions {
+    onSuccess?: (imageUrl: string) => void;
+    onError?: (error: any) => void;
+}
+export interface UseProfileImageUploadReturn {
+    uploadImage: (file: File, username: string) => Promise<UploadProfileImageResponse>;
+    removeImage: (username: string) => Promise<RemoveProfileImageResponse>;
+    isLoading: boolean;
+    isRemoving: boolean;
+    error: any;
+}
+export declare function useProfileImageUpload(options?: UseProfileImageUploadOptions): UseProfileImageUploadReturn;

package/dist/web-utils/src/hooks/profile/use-user-profile-update.d.ts

@@ -0,0 +1,28 @@
+export interface UserProfileUpdateData {
+    name?: string;
+    title?: string;
+    about?: string;
+    social_links?: {
+        platform: string;
+        social_link: string;
+    }[];
+    public_metadata?: {
+        bio?: string;
+        name?: string;
+        about?: string;
+        language?: string;
+        social_links?: {
+            platform: string;
+            social_link: string;
+        }[];
+        [key: string]: any;
+    };
+    enable_sidebar_ai_mentor_display?: boolean;
+    enable_skills_leaderboard_display?: boolean;
+}
+export interface UseUserProfileUpdateResult {
+    updateProfile: (data: UserProfileUpdateData) => Promise<void>;
+    isLoading: boolean;
+    error: any;
+}
+export declare function useUserProfileUpdate(username: string): UseUserProfileUpdateResult;

package/dist/web-utils/src/hooks/subscription/class-subscription-flow.d.ts

@@ -0,0 +1,70 @@
+import { FreeUsageCount } from "@iblai/iblai-api";
+interface Tenant {
+    key: string;
+    is_admin: boolean;
+    org: string;
+}
+export interface SubscriptionFlowConfig {
+    platformName: string;
+    currentTenantKey: string;
+    username: string;
+    currentTenantOrg: string;
+    userTenants: Tenant[];
+    isAdmin: boolean;
+    mainTenantKey: string;
+}
+/**
+ * SubscriptionFlow class manages all subscription-related flows and user interactions
+ * Handles free trial, usage limits, and subscription management
+ */
+export declare class SubscriptionFlow {
+    protected platformName: string;
+    protected currentTenantKey: string;
+    protected username: string;
+    protected currentTenantOrg: string;
+    protected userTenants: Tenant[];
+    protected isAdmin: boolean;
+    protected mainTenantKey: string;
+    constructor(config: SubscriptionFlowConfig);
+    getPlatformName(): string;
+    getCurrentTenantKey(): string;
+    getUsername(): string;
+    getCurrentTenantOrg(): string;
+    getUserTenants(): Tenant[];
+    isUserAdmin(): boolean;
+    /**
+     * Handles the flow when user reaches their free usage limit
+     * Updates banner with appropriate message based on remaining usage count
+     */
+    handleFreeUsageCountFlow(freeUsageCount: FreeUsageCount): void;
+    /**
+     * Handles the flow when user's free trial period has ended
+     * Updates banner and clears any existing trial interval
+     */
+    handleTrialEndedFlow(freeTrialIntervalID?: number): void;
+    /**
+     * Handles the flow for ongoing subscription period
+     * Updates banner with remaining trial time and subscription options
+     */
+    handleSubscriptionOnGoingFlow(timeRemainingInString: string): void;
+    /**
+     * Handles redirection to external URLs with optional toast notification
+     */
+    handleRedirectToURLFlow(redirectUrl: string, toastMessage?: string): void;
+    /**
+     * Displays the pricing modal for subscription options
+     */
+    handlePricingPageDisplayFlow(): void;
+    /**
+     * Handles the pre-subscription state
+     * Updates banner to show loading state
+     */
+    handleBeforeSubscribeUserTriggerFlow(): void;
+    /**
+     * Handles successful subscription completion
+     * Shows success message and disables subscription banner
+     */
+    handleSuccessfullySubscribedFlow(message?: string): void;
+    getMainTenantKey(): string;
+}
+export {};

package/dist/web-utils/src/hooks/subscription/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const SUBSCRIPTION_TRIGGERS: {
+    PRICING_MODAL: string;
+    SUBSCRIBE_USER: string;
+};