@8wave/ai-elements 0.114.0 → 0.115.0-beta.16

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

@@ -1288,6 +1288,473 @@ export declare const DocumentSchema: z.ZodObject<{
     agentIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     folderId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     folderPath: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    deletedByName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * The document types the trash holds: the ones a person adds to a knowledge
+ * base by hand. A revised answer lives and dies with its own page, so it is
+ * never listed, restored or emptied from here.
+ */
+export declare const DOCUMENT_TRASH_TYPES: readonly [DocumentType.File, DocumentType.Url, DocumentType.PlainText];
+/**
+ * Why a restore was refused (docs/specs/document-trash.md, Decision 3), sent
+ * as `additionalData.reason` of a `conflict` problem. The third case of the
+ * decision, a folder that no longer exists, is not a refusal: the document
+ * goes back to the root and the answer says so.
+ */
+export declare enum DocumentRestoreRefusal {
+    /** Every agent the document belonged to has been deleted. */
+    AgentGone = "agent-gone",
+    /**
+     * A live document of the same source holds its remote identity; its id
+     * travels as `additionalData.documentId`.
+     */
+    IdentityTaken = "identity-taken"
+}
+export declare const DocumentRestoreResultSchema: z.ZodObject<{
+    document: z.ZodObject<{
+        id: z.ZodString;
+        externalId: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        content: z.ZodString;
+        language: z.ZodString;
+        processedAt: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+        createdAt: z.ZodCoercedDate<unknown>;
+        createdBy: z.ZodString;
+        updatedAt: z.ZodCoercedDate<unknown>;
+        updatedBy: z.ZodString;
+        deleted: z.ZodBoolean;
+        deletedAt: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+        deletedBy: z.ZodNullable<z.ZodString>;
+        organizationId: z.ZodString;
+        priority: z.ZodDefault<z.ZodNumber>;
+        refreshInterval: z.ZodOptional<z.ZodNullable<z.ZodEnum<typeof DocumentRefreshInterval>>>;
+        nextRefreshAt: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
+        sourceProvider: z.ZodOptional<z.ZodNullable<z.ZodEnum<typeof DocumentSourceProvider>>>;
+        type: z.ZodEnum<typeof DocumentType>;
+        indexStatus: z.ZodEnum<typeof IndexStatus>;
+        metadata: z.ZodObject<{
+            source: z.ZodOptional<z.ZodPreprocess<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                contentHash: z.ZodOptional<z.ZodString>;
+                lastRefresh: z.ZodOptional<z.ZodObject<{
+                    at: z.ZodString;
+                    result: z.ZodEnum<typeof DocumentRefreshResult>;
+                    httpStatus: z.ZodOptional<z.ZodNumber>;
+                    error: z.ZodOptional<z.ZodString>;
+                    consecutiveFailures: z.ZodOptional<z.ZodNumber>;
+                    previousWordCount: z.ZodOptional<z.ZodNumber>;
+                    newWordCount: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+                provider: z.ZodLiteral<DocumentSourceProvider.Web>;
+                url: z.ZodString;
+                lastScrapedAt: z.ZodOptional<z.ZodString>;
+                extractionInputHash: z.ZodOptional<z.ZodString>;
+                finalUrl: z.ZodOptional<z.ZodString>;
+                sourceId: z.ZodOptional<z.ZodUUID>;
+                lastSyncedAt: z.ZodOptional<z.ZodString>;
+                lastmod: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>, z.ZodObject<{
+                contentHash: z.ZodOptional<z.ZodString>;
+                lastRefresh: z.ZodOptional<z.ZodObject<{
+                    at: z.ZodString;
+                    result: z.ZodEnum<typeof DocumentRefreshResult>;
+                    httpStatus: z.ZodOptional<z.ZodNumber>;
+                    error: z.ZodOptional<z.ZodString>;
+                    consecutiveFailures: z.ZodOptional<z.ZodNumber>;
+                    previousWordCount: z.ZodOptional<z.ZodNumber>;
+                    newWordCount: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+                sourceId: z.ZodUUID;
+                remoteId: z.ZodString;
+                webUrl: z.ZodString;
+                path: z.ZodString;
+                fingerprint: z.ZodString;
+                lastSyncedAt: z.ZodString;
+                lastModified: z.ZodOptional<z.ZodString>;
+                candidate: z.ZodOptional<z.ZodObject<{
+                    media: z.ZodObject<{
+                        name: z.ZodString;
+                        src: z.ZodObject<{
+                            type: z.ZodString;
+                            name: z.ZodString;
+                            mimeType: z.ZodString;
+                            bytesCount: z.ZodNumber;
+                            extension: z.ZodString;
+                            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+                            tags: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+                            storageHandle: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                                type: z.ZodLiteral<"azure-blob">;
+                                blobUri: z.ZodURL;
+                                containerName: z.ZodString;
+                                pathRelativeToContainer: z.ZodString;
+                            }, z.core.$strip>, z.ZodObject<{
+                                type: z.ZodLiteral<"s3">;
+                                bucket: z.ZodString;
+                                key: z.ZodString;
+                                region: z.ZodString;
+                            }, z.core.$strip>], "type">;
+                            storagePolicy: z.ZodEnum<typeof StoragePolicy>;
+                            signData: z.ZodOptional<z.ZodString>;
+                            storedFileName: z.ZodString;
+                        }, z.core.$strip>;
+                        srcSet: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                            type: z.ZodString;
+                            name: z.ZodString;
+                            mimeType: z.ZodString;
+                            bytesCount: z.ZodNumber;
+                            extension: z.ZodString;
+                            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+                            tags: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+                            storageHandle: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                                type: z.ZodLiteral<"azure-blob">;
+                                blobUri: z.ZodURL;
+                                containerName: z.ZodString;
+                                pathRelativeToContainer: z.ZodString;
+                            }, z.core.$strip>, z.ZodObject<{
+                                type: z.ZodLiteral<"s3">;
+                                bucket: z.ZodString;
+                                key: z.ZodString;
+                                region: z.ZodString;
+                            }, z.core.$strip>], "type">;
+                            storagePolicy: z.ZodEnum<typeof StoragePolicy>;
+                            signData: z.ZodOptional<z.ZodString>;
+                            storedFileName: z.ZodString;
+                        }, z.core.$strip>>>;
+                        rawOptions: z.ZodOptional<z.ZodCustom<{
+                            type: import('./Media').MediaType.picture;
+                            width: number;
+                            height: number;
+                            blurhash?: string | undefined;
+                        } | {
+                            type: import('./Media').MediaType.video;
+                            width: number;
+                            height: number;
+                            duration: number;
+                        } | {
+                            type: import('./Media').MediaType.audio;
+                            duration: number;
+                        } | {
+                            type: import('./Media').MediaType.office;
+                        } | {
+                            type: import('./Media').MediaType.archive;
+                        } | {
+                            type: import('./Media').MediaType.binary;
+                        } | {
+                            type: import('./Media').MediaType.executable;
+                        }, {
+                            type: import('./Media').MediaType.picture;
+                            width: number;
+                            height: number;
+                            blurhash?: string | undefined;
+                        } | {
+                            type: import('./Media').MediaType.video;
+                            width: number;
+                            height: number;
+                            duration: number;
+                        } | {
+                            type: import('./Media').MediaType.audio;
+                            duration: number;
+                        } | {
+                            type: import('./Media').MediaType.office;
+                        } | {
+                            type: import('./Media').MediaType.archive;
+                        } | {
+                            type: import('./Media').MediaType.binary;
+                        } | {
+                            type: import('./Media').MediaType.executable;
+                        }>>;
+                    }, z.core.$strip>;
+                    fingerprint: z.ZodString;
+                    name: z.ZodString;
+                    webUrl: z.ZodString;
+                    path: z.ZodString;
+                    lastModified: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                provider: z.ZodLiteral<DocumentSourceProvider.SharePoint>;
+            }, z.core.$strip>, z.ZodObject<{
+                contentHash: z.ZodOptional<z.ZodString>;
+                lastRefresh: z.ZodOptional<z.ZodObject<{
+                    at: z.ZodString;
+                    result: z.ZodEnum<typeof DocumentRefreshResult>;
+                    httpStatus: z.ZodOptional<z.ZodNumber>;
+                    error: z.ZodOptional<z.ZodString>;
+                    consecutiveFailures: z.ZodOptional<z.ZodNumber>;
+                    previousWordCount: z.ZodOptional<z.ZodNumber>;
+                    newWordCount: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+                sourceId: z.ZodUUID;
+                remoteId: z.ZodString;
+                webUrl: z.ZodString;
+                path: z.ZodString;
+                fingerprint: z.ZodString;
+                lastSyncedAt: z.ZodString;
+                lastModified: z.ZodOptional<z.ZodString>;
+                candidate: z.ZodOptional<z.ZodObject<{
+                    media: z.ZodObject<{
+                        name: z.ZodString;
+                        src: z.ZodObject<{
+                            type: z.ZodString;
+                            name: z.ZodString;
+                            mimeType: z.ZodString;
+                            bytesCount: z.ZodNumber;
+                            extension: z.ZodString;
+                            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+                            tags: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+                            storageHandle: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                                type: z.ZodLiteral<"azure-blob">;
+                                blobUri: z.ZodURL;
+                                containerName: z.ZodString;
+                                pathRelativeToContainer: z.ZodString;
+                            }, z.core.$strip>, z.ZodObject<{
+                                type: z.ZodLiteral<"s3">;
+                                bucket: z.ZodString;
+                                key: z.ZodString;
+                                region: z.ZodString;
+                            }, z.core.$strip>], "type">;
+                            storagePolicy: z.ZodEnum<typeof StoragePolicy>;
+                            signData: z.ZodOptional<z.ZodString>;
+                            storedFileName: z.ZodString;
+                        }, z.core.$strip>;
+                        srcSet: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                            type: z.ZodString;
+                            name: z.ZodString;
+                            mimeType: z.ZodString;
+                            bytesCount: z.ZodNumber;
+                            extension: z.ZodString;
+                            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+                            tags: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+                            storageHandle: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                                type: z.ZodLiteral<"azure-blob">;
+                                blobUri: z.ZodURL;
+                                containerName: z.ZodString;
+                                pathRelativeToContainer: z.ZodString;
+                            }, z.core.$strip>, z.ZodObject<{
+                                type: z.ZodLiteral<"s3">;
+                                bucket: z.ZodString;
+                                key: z.ZodString;
+                                region: z.ZodString;
+                            }, z.core.$strip>], "type">;
+                            storagePolicy: z.ZodEnum<typeof StoragePolicy>;
+                            signData: z.ZodOptional<z.ZodString>;
+                            storedFileName: z.ZodString;
+                        }, z.core.$strip>>>;
+                        rawOptions: z.ZodOptional<z.ZodCustom<{
+                            type: import('./Media').MediaType.picture;
+                            width: number;
+                            height: number;
+                            blurhash?: string | undefined;
+                        } | {
+                            type: import('./Media').MediaType.video;
+                            width: number;
+                            height: number;
+                            duration: number;
+                        } | {
+                            type: import('./Media').MediaType.audio;
+                            duration: number;
+                        } | {
+                            type: import('./Media').MediaType.office;
+                        } | {
+                            type: import('./Media').MediaType.archive;
+                        } | {
+                            type: import('./Media').MediaType.binary;
+                        } | {
+                            type: import('./Media').MediaType.executable;
+                        }, {
+                            type: import('./Media').MediaType.picture;
+                            width: number;
+                            height: number;
+                            blurhash?: string | undefined;
+                        } | {
+                            type: import('./Media').MediaType.video;
+                            width: number;
+                            height: number;
+                            duration: number;
+                        } | {
+                            type: import('./Media').MediaType.audio;
+                            duration: number;
+                        } | {
+                            type: import('./Media').MediaType.office;
+                        } | {
+                            type: import('./Media').MediaType.archive;
+                        } | {
+                            type: import('./Media').MediaType.binary;
+                        } | {
+                            type: import('./Media').MediaType.executable;
+                        }>>;
+                    }, z.core.$strip>;
+                    fingerprint: z.ZodString;
+                    name: z.ZodString;
+                    webUrl: z.ZodString;
+                    path: z.ZodString;
+                    lastModified: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                provider: z.ZodLiteral<DocumentSourceProvider.GoogleDrive>;
+            }, z.core.$strip>], "provider">, unknown>>;
+            media: z.ZodOptional<z.ZodObject<{
+                name: z.ZodString;
+                src: z.ZodObject<{
+                    type: z.ZodString;
+                    name: z.ZodString;
+                    mimeType: z.ZodString;
+                    bytesCount: z.ZodNumber;
+                    extension: z.ZodString;
+                    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+                    tags: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+                    storageHandle: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        type: z.ZodLiteral<"azure-blob">;
+                        blobUri: z.ZodURL;
+                        containerName: z.ZodString;
+                        pathRelativeToContainer: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        type: z.ZodLiteral<"s3">;
+                        bucket: z.ZodString;
+                        key: z.ZodString;
+                        region: z.ZodString;
+                    }, z.core.$strip>], "type">;
+                    storagePolicy: z.ZodEnum<typeof StoragePolicy>;
+                    signData: z.ZodOptional<z.ZodString>;
+                    storedFileName: z.ZodString;
+                }, z.core.$strip>;
+                srcSet: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    type: z.ZodString;
+                    name: z.ZodString;
+                    mimeType: z.ZodString;
+                    bytesCount: z.ZodNumber;
+                    extension: z.ZodString;
+                    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+                    tags: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+                    storageHandle: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        type: z.ZodLiteral<"azure-blob">;
+                        blobUri: z.ZodURL;
+                        containerName: z.ZodString;
+                        pathRelativeToContainer: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        type: z.ZodLiteral<"s3">;
+                        bucket: z.ZodString;
+                        key: z.ZodString;
+                        region: z.ZodString;
+                    }, z.core.$strip>], "type">;
+                    storagePolicy: z.ZodEnum<typeof StoragePolicy>;
+                    signData: z.ZodOptional<z.ZodString>;
+                    storedFileName: z.ZodString;
+                }, z.core.$strip>>>;
+                rawOptions: z.ZodOptional<z.ZodCustom<{
+                    type: import('./Media').MediaType.picture;
+                    width: number;
+                    height: number;
+                    blurhash?: string | undefined;
+                } | {
+                    type: import('./Media').MediaType.video;
+                    width: number;
+                    height: number;
+                    duration: number;
+                } | {
+                    type: import('./Media').MediaType.audio;
+                    duration: number;
+                } | {
+                    type: import('./Media').MediaType.office;
+                } | {
+                    type: import('./Media').MediaType.archive;
+                } | {
+                    type: import('./Media').MediaType.binary;
+                } | {
+                    type: import('./Media').MediaType.executable;
+                }, {
+                    type: import('./Media').MediaType.picture;
+                    width: number;
+                    height: number;
+                    blurhash?: string | undefined;
+                } | {
+                    type: import('./Media').MediaType.video;
+                    width: number;
+                    height: number;
+                    duration: number;
+                } | {
+                    type: import('./Media').MediaType.audio;
+                    duration: number;
+                } | {
+                    type: import('./Media').MediaType.office;
+                } | {
+                    type: import('./Media').MediaType.archive;
+                } | {
+                    type: import('./Media').MediaType.binary;
+                } | {
+                    type: import('./Media').MediaType.executable;
+                }>>;
+            }, z.core.$strip>>;
+            title: z.ZodOptional<z.ZodString>;
+            author: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            summary: z.ZodOptional<z.ZodString>;
+            keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            subject: z.ZodOptional<z.ZodString>;
+            creator: z.ZodOptional<z.ZodString>;
+            producer: z.ZodOptional<z.ZodString>;
+            creationDate: z.ZodOptional<z.ZodString>;
+            modificationDate: z.ZodOptional<z.ZodString>;
+            pageCount: z.ZodOptional<z.ZodCodec<z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodUnknown>]>, z.ZodNumber>>;
+            encrypted: z.ZodOptional<z.ZodBoolean>;
+            characterCount: z.ZodOptional<z.ZodNumber>;
+            lineCount: z.ZodOptional<z.ZodNumber>;
+            siteName: z.ZodOptional<z.ZodString>;
+            canonicalUrl: z.ZodOptional<z.ZodURL>;
+            imageUrl: z.ZodOptional<z.ZodURL>;
+            favicon: z.ZodOptional<z.ZodURL>;
+            type: z.ZodOptional<z.ZodString>;
+            locale: z.ZodOptional<z.ZodString>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            publishedTime: z.ZodOptional<z.ZodString>;
+            modifiedTime: z.ZodOptional<z.ZodString>;
+            wordCount: z.ZodOptional<z.ZodNumber>;
+            paragraphCount: z.ZodOptional<z.ZodNumber>;
+            readingTime: z.ZodOptional<z.ZodNumber>;
+            ocrUsed: z.ZodOptional<z.ZodBoolean>;
+            ocrProvider: z.ZodOptional<z.ZodString>;
+            ocrModel: z.ZodOptional<z.ZodString>;
+            ocrPages: z.ZodOptional<z.ZodString>;
+            ocrCost: z.ZodOptional<z.ZodNumber>;
+            ocrError: z.ZodOptional<z.ZodString>;
+            chunksCount: z.ZodOptional<z.ZodNumber>;
+            redundantChunksCount: z.ZodOptional<z.ZodNumber>;
+            hasRedundantChunks: z.ZodOptional<z.ZodBoolean>;
+            qdrantSynced: z.ZodOptional<z.ZodBoolean>;
+            conversionOptions: z.ZodOptional<z.ZodObject<{
+                extractionStrategy: z.ZodOptional<z.ZodEnum<typeof ExtractionStrategy>>;
+                browserEngine: z.ZodDefault<z.ZodOptional<z.ZodEnum<typeof BrowserEngine>>>;
+                headers: z.ZodOptional<z.ZodNullable<z.ZodCodec<z.ZodArray<z.ZodObject<{
+                    key: z.ZodOptional<z.ZodString>;
+                    value: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>, z.ZodArray<z.ZodObject<{
+                    key: z.ZodString;
+                    value: z.ZodString;
+                }, z.core.$strip>>>>>;
+                aiDescriptionModel: z.ZodOptional<z.ZodString>;
+                aiDescriptionPrompt: z.ZodOptional<z.ZodString>;
+                language: z.ZodOptional<z.ZodString>;
+                forceOcr: z.ZodDefault<z.ZodBoolean>;
+                pages: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$loose>;
+        chunksCount: z.ZodOptional<z.ZodNumber>;
+        redundantChunksCount: z.ZodOptional<z.ZodNumber>;
+        hasRedundantChunks: z.ZodOptional<z.ZodBoolean>;
+        qdrantSynced: z.ZodOptional<z.ZodBoolean>;
+        agentIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        folderId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        folderPath: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        deletedByName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+    returnedToRoot: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const DocumentTrashSummarySchema: z.ZodObject<{
+    count: z.ZodNumber;
+}, z.core.$strip>;
+export declare const DocumentEmptyTrashDtoSchema: z.ZodObject<{
+    agentId: z.ZodUUID;
+}, z.core.$strip>;
+export declare const DocumentEmptyTrashResultSchema: z.ZodObject<{
+    purged: z.ZodNumber;
+    remaining: z.ZodNumber;
 }, z.core.$strip>;
 /**
  * Query parameters for listing documents with pagination, sorting, and filters
@@ -1300,6 +1767,10 @@ export declare const DocumentQuerystringSchema: z.ZodObject<{
     'filter[sourceProvider]': z.ZodOptional<z.ZodString>;
     ids: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
     "filter[fullText]": z.ZodOptional<z.ZodString>;
+    'filter[deleted]': z.ZodOptional<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>>;
     "filter[type]": z.ZodOptional<z.ZodString | z.ZodArray<z.ZodString>>;
     "filter[agentId]": z.ZodOptional<z.ZodString | z.ZodArray<z.ZodString>>;
     "filter[language]": z.ZodOptional<z.ZodString | z.ZodArray<z.ZodString>>;
@@ -1309,10 +1780,12 @@ export declare const DocumentQuerystringSchema: z.ZodObject<{
         id: "id";
         createdAt: "createdAt";
         updatedAt: "updatedAt";
+        deletedAt: "deletedAt";
         "-name": "-name";
         "-id": "-id";
         "-createdAt": "-createdAt";
         "-updatedAt": "-updatedAt";
+        "-deletedAt": "-deletedAt";
     }>>>;
     'page[number]': z.ZodDefault<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
     'page[size]': z.ZodDefault<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
@@ -1480,6 +1953,10 @@ export type DocumentUpdateDto = z.infer<typeof DocumentUpdateDtoSchema>;
 export type DocumentRefreshIntervalDto = z.infer<typeof DocumentRefreshIntervalDtoSchema>;
 export type DocumentBulkRefreshIntervalDto = z.infer<typeof DocumentBulkRefreshIntervalDtoSchema>;
 export type DocumentBulkRefreshDto = z.infer<typeof DocumentBulkRefreshDtoSchema>;
+export type DocumentRestoreResult = z.infer<typeof DocumentRestoreResultSchema>;
+export type DocumentTrashSummary = z.infer<typeof DocumentTrashSummarySchema>;
+export type DocumentEmptyTrashDto = z.infer<typeof DocumentEmptyTrashDtoSchema>;
+export type DocumentEmptyTrashResult = z.infer<typeof DocumentEmptyTrashResultSchema>;
 export declare const getStatusColor: (status: IndexStatus) => "success" | "danger" | "warning" | "info";
 export declare const getStatusIcon: (status: IndexStatus) => "ri:check-line" | "ri:error-warning-line" | "ri:hourglass-line" | "ri:time-line";
 export declare const getTypeIcon: (type: DocumentType) => "ri:file-line" | "ri:link" | "ri:feedback-line" | "ri:input-method-line";

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

@@ -3,6 +3,20 @@ import * as z from 'zod';
 export declare const PLATFORM_MCP_SERVER_NAME = "Agents Studio Platform MCP";
 /** Name of the per-org Platform Agent created by seedPlatformMcp.ts */
 export declare const PLATFORM_AGENT_NAME = "Assistente piattaforma";
+/**
+ * How long the backend may spend discovering an integration's OAuth endpoints
+ * when a user starts a sign-in (Connect in the chat, the profile, the
+ * backoffice): long enough for a server scaled to zero to start, about 45 s
+ * on one of ours. The refresh inside a chat turn keeps a short budget of its
+ * own, bound to the refresh lock.
+ */
+export declare const MCP_OAUTH_AUTHORIZE_DISCOVERY_BUDGET_MS = 120000;
+/**
+ * How long a client waits for an authorize URL: the discovery above, then the
+ * client registration that may follow it. Below the 240 s the Container Apps
+ * ingress gives a request.
+ */
+export declare const MCP_OAUTH_AUTHORIZE_TIMEOUT_MS: number;
 export declare enum McpServerStatus {
     Active = "active",
     Inactive = "inactive",
@@ -146,8 +160,50 @@ export declare const McpServerConnectionSchema: z.ZodObject<{
     organizationName: z.ZodNullable<z.ZodString>;
     connectedAt: z.ZodCoercedDate<unknown>;
 }, z.core.$strip>;
+/**
+ * Whether a stored sign-in still does anything, as the system user page shows
+ * it. `active`: usable now or renewable. `stale`: expired with nothing to
+ * renew it from, the next turn deletes it. `orphan`: the integration was
+ * deleted, switched off or detached from every agent, so nothing uses the
+ * sign-in, yet it is still a credential and still revocable.
+ */
+export declare enum McpUserConnectionStatus {
+    Active = "active",
+    Stale = "stale",
+    Orphan = "orphan"
+}
+/**
+ * One sign-in of a user, as a platform administrator sees it: every row the
+ * user owns, the orphaned ones included, since offboarding is about the
+ * credentials that are left and not only the ones in use. Never a token, a
+ * refresh token or a client secret: whether a refresh token exists is all it
+ * says about one.
+ */
+export declare const McpUserConnectionAdminSchema: z.ZodObject<{
+    mcpServerId: z.ZodString;
+    serverName: z.ZodString;
+    organizationId: z.ZodString;
+    organizationName: z.ZodString;
+    agents: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>>;
+    connectedAt: z.ZodCoercedDate<unknown>;
+    renewedAt: z.ZodCoercedDate<unknown>;
+    expiresAt: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+    scope: z.ZodNullable<z.ZodString>;
+    refreshable: z.ZodBoolean;
+    status: z.ZodEnum<typeof McpUserConnectionStatus>;
+}, z.core.$strip>;
+/** What ending a sign-in did beyond deleting our copy of the token. */
+export declare const McpConnectionRevocationSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    revokedAtProvider: z.ZodBoolean;
+}, z.core.$strip>;
 export type McpServerInfo = z.infer<typeof McpServerInfoSchema>;
 export type McpServerConnection = z.infer<typeof McpServerConnectionSchema>;
+export type McpUserConnectionAdmin = z.infer<typeof McpUserConnectionAdminSchema>;
+export type McpConnectionRevocation = z.infer<typeof McpConnectionRevocationSchema>;
 export type McpServer = z.infer<typeof McpServerSchema>;
 export type McpServerCreate = z.infer<typeof McpServerCreateSchema>;
 export type McpServerUpdate = z.infer<typeof McpServerUpdateSchema>;

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

@@ -12,6 +12,8 @@ export declare const NotificationType: {
     readonly WebSourcePagesRemoved: "web_source_pages_removed";
     /** A web source held back a removal too large to trust without a person. */
     readonly WebSourceRemovalHeld: "web_source_removal_held";
+    /** A platform administrator ended one of the user's integration sign-ins. */
+    readonly McpConnectionRevoked: "mcp_connection_revoked";
     readonly ChatWarning: "chat_warning";
     readonly ChatBlocked: "chat_blocked";
     readonly Generic: "generic";

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

@@ -2,7 +2,7 @@ import { StoragePolicy } from './Media';
 import * as z from 'zod';
 /**
  * Where a user stands on two-step verification and passkeys, as the system
- * panel shows it (docs/specs/two-factor-system-assistance.md, D2). One state
+ * panel shows it (docs/specs/released/two-factor-system-assistance.md, D2). One state
  * per user, decided in this order: the authenticator app, the email code, a
  * passkey alone, then `required` for a member of an organization that asks
  * for a second factor who signs in with a password and has none.

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@8wave/ai-elements",
     "private": false,
-    "version": "0.114.0",
+    "version": "0.115.0-beta.16",
     "type": "module",
     "scripts": {
         "dev": "vite --port 8082 --open --host",