@8wave/ai-elements 0.115.0-beta.47 → 0.115.0-beta.52

package/dist-vue/locales.js

@@ -154,6 +154,7 @@ var e = {
 		mimeTypeImages: "Images",
 		mimeTypeDocuments: "Documents",
 		mimeTypeText: "Text",
+		mimeTypeSpreadsheets: "Spreadsheets (.xlsx)",
 		general: "General",
 		style: "Style",
 		tools: "Tools",
@@ -473,11 +474,9 @@ var e = {
 	},
 	userFiles: {
 		chatFilesTitle: "Files in this chat",
-		excludeConfirm: "The assistant will not be able to search it any more. It stays in the chat you uploaded it to.",
 		chatFilesEmpty: "No files uploaded in this chat.",
 		open: "Open file",
-		untitled: "Untitled file",
-		exclude: "Remove file"
+		untitled: "Untitled file"
 	},
 	twoFactor: {
 		challengeBackup: "Enter one of the backup codes you saved.",
@@ -513,6 +512,7 @@ var e = {
 		steps: "Processing",
 		stepCount: "{n} step | {n} steps",
 		stepError: "Error",
+		editSpreadsheetCells: "{count} cell changed | {count} cells changed",
 		requestGeolocation: "Requesting location...",
 		requestOAuthConnectionSuccess: "Successfully connected to {name}.",
 		requestOAuthConnection: "Connecting...",
@@ -526,6 +526,9 @@ var e = {
 		searchingDocuments: "Memory search...",
 		expandChunkContext: "Reading more context...",
 		readDocumentFile: "Reading the original document...",
+		readSpreadsheet: "Reading the spreadsheet...",
+		editSpreadsheet: "Editing the spreadsheet...",
+		querySpreadsheet: "Querying the spreadsheet...",
 		geocode: "Looking up a location...",
 		getWeather: "Fetching weather data...",
 		recallUserMemory: "Recalling user memories...",
@@ -554,10 +557,7 @@ var e = {
 		reasoning: "Reasoning...",
 		streaming: "Loading..."
 	},
-	confirmTitle: {
-		deleteMyConversations: "Delete all your conversations?",
-		excludeUserFile: "Remove this file from your files?"
-	},
+	confirmTitle: { deleteMyConversations: "Delete all your conversations?" },
 	toolApproval: {
 		expired: "This request is no longer answerable: the action was not performed.",
 		prompt: "Your confirmation is needed to continue:"
@@ -753,6 +753,7 @@ var e = {
 		mimeTypeImages: "Immagini",
 		mimeTypeDocuments: "Documenti",
 		mimeTypeText: "Testo",
+		mimeTypeSpreadsheets: "Fogli di calcolo (.xlsx)",
 		general: "Generale",
 		style: "Stile",
 		tools: "Tool",
@@ -1072,11 +1073,9 @@ var e = {
 	},
 	userFiles: {
 		chatFilesTitle: "File in questa chat",
-		excludeConfirm: "L'assistente non potrà più cercarlo. Resta nella chat in cui lo avete caricato.",
 		chatFilesEmpty: "Nessun file caricato in questa chat.",
 		open: "Apri file",
-		untitled: "File senza nome",
-		exclude: "Rimuovi file"
+		untitled: "File senza nome"
 	},
 	twoFactor: {
 		challengeBackup: "Scrivi uno dei codici di recupero che hai salvato.",
@@ -1112,6 +1111,7 @@ var e = {
 		steps: "Elaborazione",
 		stepCount: "{n} passaggio | {n} passaggi",
 		stepError: "Errore",
+		editSpreadsheetCells: "{count} cella modificata | {count} celle modificate",
 		requestGeolocation: "Richiesta posizione...",
 		requestOAuthConnectionSuccess: "Connessione a {name} riuscita.",
 		requestOAuthConnection: "Connessione in corso...",
@@ -1125,6 +1125,9 @@ var e = {
 		searchingDocuments: "Ricerca nella memoria...",
 		expandChunkContext: "Lettura di altro contesto...",
 		readDocumentFile: "Lettura del documento originale...",
+		readSpreadsheet: "Lettura del foglio di calcolo...",
+		editSpreadsheet: "Modifica del foglio di calcolo...",
+		querySpreadsheet: "Interrogazione del foglio di calcolo...",
 		geocode: "Ricerca della posizione...",
 		getWeather: "Recupero dati meteo...",
 		recallUserMemory: "Richiamo dei ricordi utente...",
@@ -1153,10 +1156,7 @@ var e = {
 		reasoning: "Ragionamento...",
 		streaming: "Caricamento..."
 	},
-	confirmTitle: {
-		deleteMyConversations: "Eliminare tutte le vostre conversazioni?",
-		excludeUserFile: "Rimuovere questo file dai vostri file?"
-	},
+	confirmTitle: { deleteMyConversations: "Eliminare tutte le vostre conversazioni?" },
 	toolApproval: {
 		expired: "Questa richiesta non è più confermabile: l'azione non è stata eseguita.",
 		prompt: "Per continuare serve la tua conferma:"

package/dist-vue/packages/components/src/chat/PkChatbotFilePreview.d.ts

@@ -14,6 +14,11 @@ type __VLS_Props = {
      * message log where the details matter.
      */
     compact?: boolean;
+    /**
+     * Keeps the download button visible instead of revealing it on hover:
+     * for a file the agent wrote, which the user is there to download.
+     */
+    showDownload?: boolean;
 };
 declare const __VLS_export: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
     remove: () => any;

package/dist-vue/packages/components/src/chat/PkToolEditSpreadsheet.d.ts

@@ -0,0 +1,14 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+/**
+ * The version an `editSpreadsheet` call wrote, as a file to download.
+ * Drawn once the call has an output: while it runs, the feed's activity
+ * indicator names it, and a refused edit is explained by the answer.
+ */
+type __VLS_Props = {
+    part: unknown;
+    /** The authenticated download URL of a file stored in this chat. */
+    fileUrl: (storedFileName: string) => string;
+};
+declare const __VLS_export: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist-vue/packages/components/src/chat/utils.d.ts

@@ -16,6 +16,14 @@ export declare function mergeConsecutiveTextParts(parts: UIMessage['parts']): UI
  * keeps every call, the refused one included.
  */
 export declare function dropCorrectedWidgetErrors(parts: UIMessage['parts']): UIMessage['parts'];
+/** The parts with the file outputs moved last, in their own order. */
+export declare function moveFileOutputsLast(parts: UIMessage['parts']): UIMessage['parts'];
+/**
+ * The key of a part in the feed. Its position, except for a file output: that
+ * one is always last, so its position moves as the answer grows, and keyed by
+ * it the card would be redrawn at every new part.
+ */
+export declare function feedPartKey(part: UIMessage['parts'][number], index: number): string | number;
 export declare function isStreamingPart(part: UIMessage['parts'][number] | null | undefined): part is Extract<UIMessage['parts'][number], {
     streaming?: boolean;
 }>;

package/dist-vue/packages/composable/src/chatbot/api/createChatbotApiClient.d.ts

@@ -19,9 +19,13 @@ export interface SubmitLeadPayload {
     chatId: string;
     [key: string]: unknown;
 }
-/** A file from the user's "My files" KB, as listed for a chat. */
+/** A file from the user's "My files" KB, or a spreadsheet of the chat with its
+ * versions, as listed for a chat. */
 export interface ChatbotFile {
     documentId: string;
+    kind: 'document' | 'spreadsheet';
+    /** For a spreadsheet version, the attachment it is a version of. */
+    sourceAttachmentId: string | null;
     name: string | null;
     mimeType: string | null;
     indexStatus: string;
@@ -38,6 +42,8 @@ export interface ChatbotApiClient {
     getAgent(orgSlug: string, agentId: string): Promise<AgentPublic>;
     getAgentAccess(orgSlug: string, agentId: string): Promise<AgentAccess>;
     getMediaUrl(agentId: string, chatId: string, storedFileName: string): string;
+    /** Like {@link getMediaUrl}, served as an attachment: the browser saves it. */
+    getMediaDownloadUrl(agentId: string, chatId: string, storedFileName: string): string;
     appendAuthToken(url: string): string;
     uploadMedia(agentId: string, chatId: string, file: File): Promise<MediaSource>;
     getChatEndpoint(agentId: string, type?: 'chat' | 'reasoning'): string;

package/dist-vue/packages/composable/src/chatbot/useChatbotStore.d.ts

@@ -1558,12 +1558,16 @@ export declare function useChatbotStore(agentId: string): Store<`chatbot-${strin
     isLoadingConversations: globalThis.Ref<boolean, boolean>;
     chatFiles: globalThis.Ref<{
         documentId: string;
+        kind: "document" | "spreadsheet";
+        sourceAttachmentId: string | null;
         name: string | null;
         mimeType: string | null;
         indexStatus: string;
         createdAt: string;
     }[], ChatbotFile[] | {
         documentId: string;
+        kind: "document" | "spreadsheet";
+        sourceAttachmentId: string | null;
         name: string | null;
         mimeType: string | null;
         indexStatus: string;
@@ -3304,12 +3308,16 @@ export declare function useChatbotStore(agentId: string): Store<`chatbot-${strin
     isLoadingConversations: globalThis.Ref<boolean, boolean>;
     chatFiles: globalThis.Ref<{
         documentId: string;
+        kind: "document" | "spreadsheet";
+        sourceAttachmentId: string | null;
         name: string | null;
         mimeType: string | null;
         indexStatus: string;
         createdAt: string;
     }[], ChatbotFile[] | {
         documentId: string;
+        kind: "document" | "spreadsheet";
+        sourceAttachmentId: string | null;
         name: string | null;
         mimeType: string | null;
         indexStatus: string;
@@ -5050,12 +5058,16 @@ export declare function useChatbotStore(agentId: string): Store<`chatbot-${strin
     isLoadingConversations: globalThis.Ref<boolean, boolean>;
     chatFiles: globalThis.Ref<{
         documentId: string;
+        kind: "document" | "spreadsheet";
+        sourceAttachmentId: string | null;
         name: string | null;
         mimeType: string | null;
         indexStatus: string;
         createdAt: string;
     }[], ChatbotFile[] | {
         documentId: string;
+        kind: "document" | "spreadsheet";
+        sourceAttachmentId: string | null;
         name: string | null;
         mimeType: string | null;
         indexStatus: string;

package/dist-vue/packages/composable/src/useFileRow.d.ts

@@ -22,3 +22,24 @@ export declare function useFileRow(urls: {
     openFile: (file: FileRowLike, download?: boolean) => void;
     formatDate: (iso: string) => string;
 };
+/** What tells a spreadsheet row apart from a KB document. */
+export interface FileKindLike {
+    kind?: 'document' | 'spreadsheet';
+    sourceAttachmentId?: string | null;
+}
+/**
+ * The wording that depends on what a "My files" row is. A KB document is a
+ * copy of the upload: removing it only takes it out of the assistant's reach.
+ * A spreadsheet is the chat attachment itself and never enters the KB: its row
+ * says so, and removing it deletes it from its chat with every version the
+ * assistant wrote of it.
+ */
+export declare function useUserFileKind(): {
+    isSpreadsheet: (file: FileKindLike) => boolean;
+    kindNote: (file: FileKindLike) => string | undefined;
+    removeLabel: (file: FileKindLike) => string;
+    removeConfirm: (file: FileKindLike) => {
+        title: string;
+        questionLabel: string;
+    };
+};

package/dist-vue/packages/models/src/schema/Agent.d.ts

@@ -320,6 +320,13 @@ export declare enum AgentBuiltInTool {
     SearchInKnowledgeBase = "searchInKnowledgeBase",
     SearchInUserFiles = "searchInUserFiles",
     UserMemory = "userMemory",
+    /**
+     * `readSpreadsheet`, `editSpreadsheet` and `querySpreadsheet`, on a chat
+     * with an attached .xlsx.
+     */
+    Spreadsheet = "spreadsheet",
+    /** `querySpreadsheet` on the spreadsheets of the knowledge base. */
+    QuerySpreadsheet = "querySpreadsheet",
     RunWorker = "runWorker",
     FetchTeamsChannelHistory = "fetchTeamsChannelHistory",
     ShowArtifact = "showArtifact",
@@ -1091,6 +1098,13 @@ export declare const AgentInterfaceSchema: z.ZodObject<{
 export type AgentInterface = z.infer<typeof AgentInterfaceSchema>;
 export declare const CHAT_FILE_UPLOAD_DEFAULT_MIME_TYPES: readonly ["image/jpeg", "image/png", "image/gif", "image/webp", "application/pdf", "text/plain", "text/markdown", "text/csv"];
 export type ChatFileUploadMimeType = (typeof CHAT_FILE_UPLOAD_DEFAULT_MIME_TYPES)[number];
+/**
+ * An Excel workbook (.xlsx). Opt-in, never in the defaults: an agent accepts it
+ * when its admin turns spreadsheets on, and the model then reads and edits it
+ * through the spreadsheet tools instead of receiving the file (spec
+ * `chat-spreadsheet-editing.md`).
+ */
+export declare const SPREADSHEET_MIME_TYPE = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
 export declare const CHAT_FILE_UPLOAD_MAX_FILE_SIZE_BYTES = 104857600;
 export declare const AgentFileUploadSchema: z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;

package/dist-vue/packages/models/src/schema/Document.d.ts

@@ -1,4 +1,5 @@
 import { SupportedLanguage, ExtractionStrategy, BrowserEngine } from './constants';
+import { SpreadsheetConversionJob } from './Tabular';
 import { StoragePolicy } from './Media';
 import * as z from 'zod';
 /**
@@ -41,6 +42,12 @@ export interface SearchIndexFacts {
     searchIndexFailedAt: string | null | undefined;
     /** Whether the organization can compute embeddings right now. */
     canEmbed: boolean;
+    /**
+     * A spreadsheet read as tables and converted (`metadata.tabular`, index
+     * status `success`): the agent queries it with SQL, and it has no chunks
+     * by design.
+     */
+    tabular?: boolean;
 }
 /**
  * The searchability of a document, from its chunk flags.
@@ -70,6 +77,7 @@ export declare const ConversionOptionsSchema: z.ZodObject<{
     language: z.ZodOptional<z.ZodString>;
     forceOcr: z.ZodDefault<z.ZodBoolean>;
     pages: z.ZodOptional<z.ZodString>;
+    asTables: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type ConversionOptions = z.infer<typeof ConversionOptionsSchema>;
 /**
@@ -478,6 +486,39 @@ export interface DocumentProcessingJob {
      */
     sourceId?: string;
 }
+/** Everything the `document-processing` queue carries. */
+export type DocumentQueueMessage = DocumentProcessingJob | SpreadsheetConversionJob;
+/**
+ * Why a document is not processed because of the organization's AI settings,
+ * as `DocumentRefusal` in `database/documentAi` says.
+ */
+export declare const DOCUMENT_REFUSAL_REASONS: readonly ["gateway-disabled", "endpoint-off", "model-unavailable", "no-model", "format-unsupported", "credit-exhausted"];
+export type DocumentRefusalReason = (typeof DOCUMENT_REFUSAL_REASONS)[number];
+/**
+ * Why a file is refused for what it is, as `UnprocessableFileError` in the
+ * document processor says.
+ */
+export declare const UNPROCESSABLE_FILE_REASONS: readonly ["file-unreadable", "file-protected", "file-type-unsupported", "spreadsheet-protected", "spreadsheet-unreadable", "spreadsheet-macros", "spreadsheet-too-large", "spreadsheet-no-table"];
+export type UnprocessableFileReason = (typeof UNPROCESSABLE_FILE_REASONS)[number];
+/** Every `reason` a failed document can carry in `metadata.lastIndexError`. */
+export declare const DOCUMENT_INDEX_ERROR_REASONS: readonly (DocumentRefusalReason | UnprocessableFileReason)[];
+/**
+ * Why the last run of a document failed in a way no other attempt can change,
+ * as the processor records it in `metadata.lastIndexError`. A dead source URL
+ * carries its HTTP `status` and `url`; anything else one of the
+ * {@link DOCUMENT_INDEX_ERROR_REASONS}, with the `limitBytes` it went past
+ * when it is too large. `reason` stays a string here, so a row written by a
+ * newer processor still reads. `message` is the English one of the logs.
+ */
+export declare const DocumentIndexErrorSchema: z.ZodObject<{
+    reason: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodNumber>;
+    url: z.ZodOptional<z.ZodString>;
+    limitBytes: z.ZodOptional<z.ZodNumber>;
+    message: z.ZodOptional<z.ZodString>;
+    at: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type DocumentIndexError = z.infer<typeof DocumentIndexErrorSchema>;
 /**
  * Metadata structure for document.metadata column
  * Consolidates all metadata from converters and source info
@@ -884,7 +925,51 @@ export declare const DocumentMetadataSchema: z.ZodObject<{
         language: z.ZodOptional<z.ZodString>;
         forceOcr: z.ZodDefault<z.ZodBoolean>;
         pages: z.ZodOptional<z.ZodString>;
+        asTables: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
+    tabular: z.ZodOptional<z.ZodObject<{
+        converterVersion: z.ZodNumber;
+        tables: z.ZodArray<z.ZodObject<{
+            sheet: z.ZodString;
+            table: z.ZodString;
+            headerRow: z.ZodOptional<z.ZodNumber>;
+            rowCount: z.ZodNumber;
+            columns: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodString;
+                column: z.ZodOptional<z.ZodString>;
+                formulas: z.ZodOptional<z.ZodNumber>;
+                mostly: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        number: "number";
+                        boolean: "boolean";
+                        date: "date";
+                    }>;
+                    share: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            sample: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>;
+        skipped: z.ZodArray<z.ZodObject<{
+            sheet: z.ZodString;
+            reason: z.ZodEnum<{
+                chart: "chart";
+                "no-table": "no-table";
+                "too-wide": "too-wide";
+                unreadable: "unreadable";
+            }>;
+        }, z.core.$strip>>;
+        staleFormulas: z.ZodBoolean;
+        sourceHash: z.ZodString;
+    }, z.core.$strip>>;
+    lastIndexError: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+        reason: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodNumber>;
+        url: z.ZodOptional<z.ZodString>;
+        limitBytes: z.ZodOptional<z.ZodNumber>;
+        message: z.ZodOptional<z.ZodString>;
+        at: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
 }, z.core.$loose>;
 export type DocumentMetadata = z.infer<typeof DocumentMetadataSchema>;
 /**
@@ -1324,7 +1409,51 @@ export declare const DocumentSchema: z.ZodObject<{
             language: z.ZodOptional<z.ZodString>;
             forceOcr: z.ZodDefault<z.ZodBoolean>;
             pages: z.ZodOptional<z.ZodString>;
+            asTables: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>;
+        tabular: z.ZodOptional<z.ZodObject<{
+            converterVersion: z.ZodNumber;
+            tables: z.ZodArray<z.ZodObject<{
+                sheet: z.ZodString;
+                table: z.ZodString;
+                headerRow: z.ZodOptional<z.ZodNumber>;
+                rowCount: z.ZodNumber;
+                columns: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    type: z.ZodString;
+                    column: z.ZodOptional<z.ZodString>;
+                    formulas: z.ZodOptional<z.ZodNumber>;
+                    mostly: z.ZodOptional<z.ZodObject<{
+                        kind: z.ZodEnum<{
+                            number: "number";
+                            boolean: "boolean";
+                            date: "date";
+                        }>;
+                        share: z.ZodString;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+                sample: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>;
+            skipped: z.ZodArray<z.ZodObject<{
+                sheet: z.ZodString;
+                reason: z.ZodEnum<{
+                    chart: "chart";
+                    "no-table": "no-table";
+                    "too-wide": "too-wide";
+                    unreadable: "unreadable";
+                }>;
+            }, z.core.$strip>>;
+            staleFormulas: z.ZodBoolean;
+            sourceHash: z.ZodString;
+        }, z.core.$strip>>;
+        lastIndexError: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+            reason: z.ZodOptional<z.ZodString>;
+            status: z.ZodOptional<z.ZodNumber>;
+            url: z.ZodOptional<z.ZodString>;
+            limitBytes: z.ZodOptional<z.ZodNumber>;
+            message: z.ZodOptional<z.ZodString>;
+            at: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>>;
     }, z.core.$loose>;
     chunksCount: z.ZodOptional<z.ZodNumber>;
     redundantChunksCount: z.ZodOptional<z.ZodNumber>;
@@ -1780,7 +1909,51 @@ export declare const DocumentRestoreResultSchema: z.ZodObject<{
                 language: z.ZodOptional<z.ZodString>;
                 forceOcr: z.ZodDefault<z.ZodBoolean>;
                 pages: z.ZodOptional<z.ZodString>;
+                asTables: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            tabular: z.ZodOptional<z.ZodObject<{
+                converterVersion: z.ZodNumber;
+                tables: z.ZodArray<z.ZodObject<{
+                    sheet: z.ZodString;
+                    table: z.ZodString;
+                    headerRow: z.ZodOptional<z.ZodNumber>;
+                    rowCount: z.ZodNumber;
+                    columns: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        type: z.ZodString;
+                        column: z.ZodOptional<z.ZodString>;
+                        formulas: z.ZodOptional<z.ZodNumber>;
+                        mostly: z.ZodOptional<z.ZodObject<{
+                            kind: z.ZodEnum<{
+                                number: "number";
+                                boolean: "boolean";
+                                date: "date";
+                            }>;
+                            share: z.ZodString;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>>;
+                    sample: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.core.$strip>>;
+                skipped: z.ZodArray<z.ZodObject<{
+                    sheet: z.ZodString;
+                    reason: z.ZodEnum<{
+                        chart: "chart";
+                        "no-table": "no-table";
+                        "too-wide": "too-wide";
+                        unreadable: "unreadable";
+                    }>;
+                }, z.core.$strip>>;
+                staleFormulas: z.ZodBoolean;
+                sourceHash: z.ZodString;
             }, z.core.$strip>>;
+            lastIndexError: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+                reason: z.ZodOptional<z.ZodString>;
+                status: z.ZodOptional<z.ZodNumber>;
+                url: z.ZodOptional<z.ZodString>;
+                limitBytes: z.ZodOptional<z.ZodNumber>;
+                message: z.ZodOptional<z.ZodString>;
+                at: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>>>;
         }, z.core.$loose>;
         chunksCount: z.ZodOptional<z.ZodNumber>;
         redundantChunksCount: z.ZodOptional<z.ZodNumber>;

package/dist-vue/packages/models/src/schema/Tabular.d.ts

@@ -0,0 +1,181 @@
+import * as z from 'zod';
+export declare const TabularColumnSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodString;
+    column: z.ZodOptional<z.ZodString>;
+    formulas: z.ZodOptional<z.ZodNumber>;
+    mostly: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            number: "number";
+            boolean: "boolean";
+            date: "date";
+        }>;
+        share: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const TabularTableSchema: z.ZodObject<{
+    sheet: z.ZodString;
+    table: z.ZodString;
+    headerRow: z.ZodOptional<z.ZodNumber>;
+    rowCount: z.ZodNumber;
+    columns: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        column: z.ZodOptional<z.ZodString>;
+        formulas: z.ZodOptional<z.ZodNumber>;
+        mostly: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodEnum<{
+                number: "number";
+                boolean: "boolean";
+                date: "date";
+            }>;
+            share: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    sample: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const TabularSkippedSheetSchema: z.ZodObject<{
+    sheet: z.ZodString;
+    reason: z.ZodEnum<{
+        chart: "chart";
+        "no-table": "no-table";
+        "too-wide": "too-wide";
+        unreadable: "unreadable";
+    }>;
+}, z.core.$strip>;
+export declare const TabularConversionSchema: z.ZodObject<{
+    converterVersion: z.ZodNumber;
+    tables: z.ZodArray<z.ZodObject<{
+        sheet: z.ZodString;
+        table: z.ZodString;
+        headerRow: z.ZodOptional<z.ZodNumber>;
+        rowCount: z.ZodNumber;
+        columns: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodString;
+            column: z.ZodOptional<z.ZodString>;
+            formulas: z.ZodOptional<z.ZodNumber>;
+            mostly: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    number: "number";
+                    boolean: "boolean";
+                    date: "date";
+                }>;
+                share: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        sample: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    skipped: z.ZodArray<z.ZodObject<{
+        sheet: z.ZodString;
+        reason: z.ZodEnum<{
+            chart: "chart";
+            "no-table": "no-table";
+            "too-wide": "too-wide";
+            unreadable: "unreadable";
+        }>;
+    }, z.core.$strip>>;
+    staleFormulas: z.ZodBoolean;
+}, z.core.$strip>;
+export type TabularColumn = z.infer<typeof TabularColumnSchema>;
+export type TabularTable = z.infer<typeof TabularTableSchema>;
+export type TabularSkippedSheet = z.infer<typeof TabularSkippedSheetSchema>;
+export type TabularConversion = z.infer<typeof TabularConversionSchema>;
+/** The conversion of a chat attachment, in `chat_attachments.tabular`. */
+export declare const TabularStateSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        pending: "pending";
+        ready: "ready";
+        failed: "failed";
+    }>;
+    requestedAt: z.ZodString;
+    conversion: z.ZodOptional<z.ZodObject<{
+        converterVersion: z.ZodNumber;
+        tables: z.ZodArray<z.ZodObject<{
+            sheet: z.ZodString;
+            table: z.ZodString;
+            headerRow: z.ZodOptional<z.ZodNumber>;
+            rowCount: z.ZodNumber;
+            columns: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodString;
+                column: z.ZodOptional<z.ZodString>;
+                formulas: z.ZodOptional<z.ZodNumber>;
+                mostly: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        number: "number";
+                        boolean: "boolean";
+                        date: "date";
+                    }>;
+                    share: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            sample: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>;
+        skipped: z.ZodArray<z.ZodObject<{
+            sheet: z.ZodString;
+            reason: z.ZodEnum<{
+                chart: "chart";
+                "no-table": "no-table";
+                "too-wide": "too-wide";
+                unreadable: "unreadable";
+            }>;
+        }, z.core.$strip>>;
+        staleFormulas: z.ZodBoolean;
+    }, z.core.$strip>>;
+    failure: z.ZodOptional<z.ZodString>;
+    failedConverterVersion: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type TabularState = z.infer<typeof TabularStateSchema>;
+/** The conversion of a knowledge-base file, in `documents.metadata.tabular`. */
+export declare const DocumentTabularSchema: z.ZodObject<{
+    converterVersion: z.ZodNumber;
+    tables: z.ZodArray<z.ZodObject<{
+        sheet: z.ZodString;
+        table: z.ZodString;
+        headerRow: z.ZodOptional<z.ZodNumber>;
+        rowCount: z.ZodNumber;
+        columns: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodString;
+            column: z.ZodOptional<z.ZodString>;
+            formulas: z.ZodOptional<z.ZodNumber>;
+            mostly: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    number: "number";
+                    boolean: "boolean";
+                    date: "date";
+                }>;
+                share: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        sample: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    skipped: z.ZodArray<z.ZodObject<{
+        sheet: z.ZodString;
+        reason: z.ZodEnum<{
+            chart: "chart";
+            "no-table": "no-table";
+            "too-wide": "too-wide";
+            unreadable: "unreadable";
+        }>;
+    }, z.core.$strip>>;
+    staleFormulas: z.ZodBoolean;
+    sourceHash: z.ZodString;
+}, z.core.$strip>;
+export type DocumentTabular = z.infer<typeof DocumentTabularSchema>;
+/** A knowledge-base spreadsheet an agent can query, with its schema. */
+export interface TabularDocument {
+    id: string;
+    name: string;
+    tabular: DocumentTabular;
+}
+/**
+ * The `document-processing` message that asks for the conversion of a chat
+ * attachment, an uploaded spreadsheet or a version the agent wrote. It shares
+ * the documents' queue, so no new queue is needed in Azure.
+ */
+export interface SpreadsheetConversionJob {
+    kind: 'spreadsheet';
+    attachmentId: string;
+}