@apia/ai 4.0.9 → 4.0.11

package/dist/index.d.ts

@@ -3,12 +3,37 @@ import { ReactNode, FC, ReactElement } from 'react';
 import * as _apia_util from '@apia/util';
 import { EventEmitter, AudioRecorder } from '@apia/util';
 import { CollectorField } from '@apia/validations';
-import { ResponseStream as ResponseStream$1 } from '@apia/ai';
+import { FilterDTO } from '@apia/components';
+import { TActionDispatcher } from '@apia/dashboard-controller';
+import { ThemeUIStyleObject } from '@apia/theme';
 
 declare const AutoscrollContainer: ({ children }: {
     children: ReactNode;
 }) => react.JSX.Element;
 
+declare const AIFileContentAllowedExtensions: {
+    readonly svg: "svg";
+    readonly png: "png";
+    readonly jpg: "jpg";
+    readonly jpeg: "jpeg";
+    readonly txt: "txt";
+    readonly doc: "doc";
+    readonly pdf: "pdf";
+    readonly docx: "docx";
+    readonly csv: "csv";
+    readonly xlsx: "xlsx";
+    readonly xls: "xls";
+    readonly mp3: "mp3";
+    readonly wav: "wav";
+};
+type AIFileContentAllowedExtension = keyof typeof AIFileContentAllowedExtensions;
+type TAttachmentErrorCallback = 'fileExtension' | 'blobGeneration';
+declare enum FileType {
+    DOCUMENT = "DOCUMENT",
+    IMAGE = "IMAGE",
+    AUDIO = "AUDIO",
+    SHEET = "SHEET"
+}
 declare enum AIMessageRole {
     USER = "USER",
     SYSTEM = "SYSTEM"
@@ -16,6 +41,81 @@ declare enum AIMessageRole {
 interface Reactive {
     Component: FC<any>;
 }
+interface Cloneable {
+    clone: () => Cloneable;
+}
+
+interface IAttachment {
+    name: string;
+    id: string;
+    value: string;
+}
+type TChatControllerState = {
+    isVisible: boolean;
+    isLoading: boolean;
+    canRecord: boolean;
+    canAttach: boolean;
+    canAddSystemMessage: boolean;
+    canAddUserMessage: boolean;
+    hideDeleteButton: boolean;
+    maxAttachmentsSize: number;
+    messages: ChatMessage[];
+    currentMessage: ChatMessage;
+};
+type MessageCallback = (props: {
+    message: ChatMessage;
+}) => Promise<any>;
+declare class ChatController2 {
+    private onMessageSubmit;
+    id: string;
+    currentIndex: number;
+    needsControlExtension: boolean;
+    state: TChatControllerState;
+    private internalAudioRecorder;
+    private internalCameraRecorder;
+    private maxId;
+    audioRecorder: {
+        start: () => void;
+        stop: () => Promise<void>;
+        record: number;
+        state: _apia_util.AudioRecorderState;
+    };
+    constructor(props: Partial<TChatControllerState>, onMessageSubmit: MessageCallback, id: string);
+    removeMessage(idx: number): void;
+    addMessage(message: ChatMessage): void;
+    clearHistory(): void;
+    clearMessage(): void;
+    removeAttachment(attachment: IAttachment): void;
+    nextMessage(): void;
+    prevMessage(): void;
+    History: (() => react.JSX.Element) & {
+        displayName: string;
+    };
+    Attachments: (() => react.JSX.Element) & {
+        displayName: string;
+    };
+    TextArea: (() => react.JSX.Element) & {
+        displayName: string;
+    };
+    Renderer: () => react.JSX.Element;
+}
+
+declare class ChatMessage implements Reactive, Cloneable {
+    message: ReactNode;
+    messageType: TMessageType;
+    attachments: IAttachment[];
+    reference: ReactNode;
+    id: number;
+    parseMessage(message: string): string;
+    constructor(message?: ReactNode, messageType?: TMessageType, attachments?: IAttachment[], reference?: ReactNode);
+    clone: () => ChatMessage;
+    removeAttachment(idx: number): void;
+    Component: (({ className }: {
+        className?: string | undefined;
+    }) => react.JSX.Element) & {
+        displayName: string;
+    };
+}
 
 declare class AIContent extends CollectorField implements Reactive {
     type: string;
@@ -32,23 +132,13 @@ declare class AIMessageAttachments implements Reactive {
     customDescription: boolean;
     constructor(role: AIMessageRole, content: AIContent, close?: (() => void) | undefined);
     addDescription: () => Promise<void>;
+    getId(): string;
     Component: (props: {
         closeButton?: boolean;
         canAddDescription?: boolean;
     }) => react.JSX.Element;
 }
 
-declare class ChatMessage {
-    message: ReactNode;
-    messageType: TMessageType;
-    attachments: AIMessageAttachments[];
-    id: number;
-    parseMessage(message: string): string;
-    constructor(message?: ReactNode, messageType?: TMessageType, attachments?: AIMessageAttachments[]);
-    copy: () => ChatMessage;
-    Component: () => react.JSX.Element;
-}
-
 type TMessageType = 'user' | 'system' | 'warning' | 'error' | 'information' | 'response' | 'multipleChoice' | 'customMessage';
 type ChatControllerState = {
     current: ChatMessage;
@@ -95,7 +185,7 @@ declare class ChatController {
         dropAll: () => undefined;
         drop: (el: AIMessageAttachments) => void;
         getComponents: () => react.JSX.Element[];
-        get: () => AIMessageAttachments[];
+        get: () => IAttachment[];
         size: () => number;
     };
 }
@@ -111,6 +201,87 @@ declare class MultipleChoiceMessage<OptionProps> extends ChatMessage {
     }) => ReactElement);
 }
 
+type TSearchResultState = {
+    title: string;
+    body: string;
+    link: string;
+};
+declare class SemanticSearchReference {
+    state: TSearchResultState;
+    constructor(props: TSearchResultState);
+    Component: () => react.JSX.Element;
+}
+
+/**
+ * @class SearchController:
+ *             - mobx Controller for the semantic search logic
+ *             - search for a term and get the results. This controller must be used
+ *               to maintain the state of the search string and of the results given a search string
+ */
+declare class SearchController {
+    static instance: SearchController;
+    state: {
+        queryString: string;
+        results: SemanticSearchReference[];
+        isLoading: boolean;
+        disabled: boolean;
+    };
+    protected constructor();
+    search(selectedId: string): Promise<void>;
+    protected setReferences(results: SemanticSearchReference[]): void;
+}
+
+type TReference = {
+    title: string;
+    body: string;
+    link: string;
+    isExternal: boolean;
+};
+interface ProcessingUnit {
+    visualizationType: TSearchMode;
+    content: string;
+    references: TReference[];
+    isExternal: boolean;
+}
+interface ListingProcessingUnit extends ProcessingUnit {
+    visualizationType: 'list';
+    title: string;
+    link: string;
+}
+interface ChatProcessingUnit extends ProcessingUnit {
+    visualizationType: 'chat';
+}
+declare const ViewRendererContext: react.Context<ISemanticSearchViewController>;
+type TSearchMode = 'list' | 'chat' | 'none';
+interface ISemanticSearchViewController {
+    state: {
+        filters: Record<string, FilterDTO>;
+        filtersOpen: boolean;
+        isLoading: boolean;
+        mode: TSearchMode;
+        searchString: string;
+    };
+    ResultsRenderer: FC;
+    clearHistory(): Promise<void>;
+    search(str?: string): void;
+    toggleFiltersOpen(): void;
+}
+type TResponseData = {
+    result: string;
+    success: string;
+    failed?: boolean;
+};
+interface ISearchResultsController<P extends ProcessingUnit> {
+    state: {
+        results: P[];
+    };
+    beforeSearch(props?: object): void;
+    afterSearch(props?: object): void;
+    clear(): void;
+    processResults(qryString: string, results: ProcessingUnit[], responseData?: TResponseData): void;
+    Component: FC;
+}
+
 declare class ResponseStream extends EventEmitter<{
     part: string;
 }> {
@@ -122,7 +293,6 @@ declare class ResponseStream extends EventEmitter<{
     private partSize;
     private timing;
     private waiting;
-    close(): void;
     private calculatePartSize;
     emit<K extends 'part'>(_: K, data: {
         part: string;
@@ -134,6 +304,16 @@ type RoutinesGenerationState = {
     isLoading: boolean;
     progress: number;
 };
+type TPollProgress = {
+    message: string;
+    progress: number;
+    debug: string;
+    streamPart?: string;
+};
+type TPollRoutineResult = {
+    status: string;
+    payload: unknown | TPollProgress;
+};
 type TGenerateFromImage$1 = {
     base64: string;
     description: string;
@@ -141,7 +321,7 @@ type TGenerateFromImage$1 = {
 type TRoutineCompletion = Partial<{
     images: TGenerateFromImage$1[];
     parameters: Record<string, string>;
-    stream: ResponseStream$1;
+    stream: ResponseStream;
 }> & {
     routineName: string;
 };
@@ -151,9 +331,16 @@ declare class RoutinesGeneration {
     state: RoutinesGenerationState;
     constructor();
     private checkCanGenerate;
-    private pollRoutine;
+    pollRoutine<T>(routineId: string, stream?: ResponseStream): Promise<T | null>;
+    private internalPollRoutine;
+    protected callAudioTranscription(audio: Blob): ReturnType<RoutinesGeneration['callRoutineStart']>;
+    protected callRoutinePoll(routineId: string): Promise<TPollRoutineResult>;
+    protected callRoutineStart(routineName: string, parameters: Record<string, string>, images: TGenerateFromImage$1[]): Promise<{
+        orchestrator: {
+            routineId: string;
+        };
+    } | null>;
     private executeRoutine;
-    private poll;
     private resetLoading;
     completion<T>(params: TRoutineCompletion): Promise<T | null>;
     stop(): void;
@@ -162,6 +349,23 @@ declare class RoutinesGeneration {
     } | null>;
 }
 
+declare class DashboardsRoutinesGeneration extends RoutinesGeneration {
+    protected dispatcher: TActionDispatcher;
+    constructor(dispatcher: TActionDispatcher);
+    private blobToBase64;
+    protected callAudioTranscription(audio: Blob): Promise<{
+        orchestrator: {
+            routineId: string;
+        };
+    } | null>;
+    protected callRoutinePoll(routineId: string): Promise<TPollRoutineResult>;
+    protected callRoutineStart(routineName: string, parameters: Record<string, string>, images: TGenerateFromImage$1[]): Promise<{
+        orchestrator: {
+            routineId: string;
+        };
+    } | null>;
+}
+
 type RetrievedImage = {
     base64: string;
     path: string;
@@ -182,5 +386,49 @@ declare function getImagesWithDescription({ multiple, }: {
     multiple?: boolean;
 }): Promise<TGenerateFromImage[]>;
 
-export { AIMessageAttachments, AutoscrollContainer, ChatController, ChatMessage, MultipleChoiceMessage, ResponseStream, RoutinesGeneration, type TGenerateFromImage$1 as TGenerateFromImage, type TMessageType, type TMultipleChoiceMessageOption, type TRoutineCompletion, getImageFromDisk, getImagesFromDisk, getImagesWithDescription };
+type TFileContentProps = {
+    value: string;
+    name: string;
+    f?: File;
+    error?: Partial<Record<TAttachmentErrorCallback, () => void>>;
+    needsControlExtension?: boolean;
+    onClose?: () => unknown;
+};
+declare class AIFileContent extends AIContent implements Reactive, IAttachment {
+    type: FileType;
+    value: string;
+    name: string;
+    extension: AIFileContentAllowedExtension;
+    private __file;
+    private __error?;
+    private onClose?;
+    private overrideSize;
+    id: string;
+    constructor(props: TFileContentProps);
+    setOnClose(callback: () => unknown): this;
+    setOverrideSize(overrideSize: {
+        width: number;
+        height: number;
+    }): this;
+    get file(): File;
+    inferContent: () => string;
+    inferExtension: (extension: AIFileContentAllowedExtension) => FileType | undefined;
+    static isValidExtension: (extension: string) => extension is "svg" | "jpg" | "jpeg" | "png" | "pdf" | "txt" | "doc" | "docx" | "csv" | "xlsx" | "xls" | "mp3" | "wav";
+    static blobToBase64: (blob: Blob) => Promise<string>;
+    static fromFile: (props: Omit<TFileContentProps, 'fileName' | 'fileUrl' | 'f'> & {
+        f: File;
+    }) => Promise<AIFileContent>;
+    static getExtensionFromFileName(fileName: string): "svg" | "jpg" | "jpeg" | "png" | "pdf" | "txt" | "doc" | "docx" | "csv" | "xlsx" | "xls" | "mp3" | "wav";
+    private static __getExtensionErrorMessage;
+    private __throwError;
+    getId(): string;
+    Component: () => react.JSX.Element;
+}
+
+declare const WindowDragger: react.ForwardRefExoticComponent<{
+    children: ReactNode;
+    style?: ThemeUIStyleObject | undefined;
+} & react.RefAttributes<HTMLElement>>;
+
+export { AIFileContent, AIMessageAttachments, AutoscrollContainer, ChatController, ChatController2, ChatMessage, type ChatProcessingUnit, DashboardsRoutinesGeneration, type ISearchResultsController, type ISemanticSearchViewController, type ListingProcessingUnit, MultipleChoiceMessage, type ProcessingUnit, ResponseStream, RoutinesGeneration, SearchController, SemanticSearchReference as SemanticSearchResult, type TGenerateFromImage$1 as TGenerateFromImage, type TMessageType, type TMultipleChoiceMessageOption, type TPollRoutineResult, type TReference, type TResponseData, type TRoutineCompletion, type TSearchMode, type ISemanticSearchViewController as ViewController, ViewRendererContext, WindowDragger, getImageFromDisk, getImagesFromDisk, getImagesWithDescription };
 //# sourceMappingURL=index.d.ts.map