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

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

@@ -1,5 +1,32 @@
-import { DocumentSourceProvider } from './Document';
+import { DocumentRefreshInterval, DocumentSourceProvider } from './Document';
 import * as z from 'zod';
+/**
+ * What a provider's sources do with the documents they bring in.
+ *
+ * - `materialize`: `download` stores the remote file in a blob and makes a
+ *   `file` document of it; `url` makes a `url` document and leaves the reading
+ *   to the processor, so there is nothing to download.
+ * - `ownsDocuments`: true makes the source's folder read-only and propagates
+ *   remote deletions; false only discovers, and the documents stay as
+ *   editable as anything a person imported.
+ *
+ * These two values are everything the backend, the sync function and the
+ * interface read to decide how a document is created and whether it can be
+ * touched by hand. A web source that removes the pages leaving its sitemap does
+ * so through an option of that source, not by owning its documents.
+ */
+export interface DocumentSourcePolicy {
+    materialize: 'download' | 'url';
+    ownsDocuments: boolean;
+}
+export declare const DOCUMENT_SOURCE_POLICIES: Record<DocumentSourceProvider, DocumentSourcePolicy>;
+/**
+ * Whether a provider's sources govern their documents.
+ *
+ * An unknown provider counts as owning: the mistake in that direction makes a
+ * folder read-only, the other one lets people edit what a job will overwrite.
+ */
+export declare function sourceOwnsDocuments(provider: string): boolean;
 /**
  * How often a source is checked.
  *
@@ -96,8 +123,42 @@ export declare const DocumentSyncRunStatsSchema: z.ZodObject<{
     skippedUnsupported: z.ZodDefault<z.ZodNumber>;
     skippedTooLarge: z.ZodDefault<z.ZodNumber>;
     failed: z.ZodDefault<z.ZodNumber>;
+    capped: z.ZodDefault<z.ZodNumber>;
+    removalHeld: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 export type DocumentSyncRunStats = z.infer<typeof DocumentSyncRunStatsSchema>;
+/**
+ * Where a web source reads its pages: a sitemap, or a walk from one page.
+ *
+ * The same fields as the crawler dialog's two modes, because the source is
+ * that dialog's parameters saved.
+ */
+export declare const WebSourceRemoteSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    sitemapUrl: z.ZodURL;
+    kind: z.ZodLiteral<"sitemap">;
+}, z.core.$strip>, z.ZodObject<{
+    startUrl: z.ZodURL;
+    maxPages: z.ZodDefault<z.ZodNumber>;
+    maxDepth: z.ZodDefault<z.ZodNumber>;
+    followExternal: z.ZodDefault<z.ZodBoolean>;
+    kind: z.ZodLiteral<"depth">;
+}, z.core.$strip>], "kind">;
+export type WebSourceRemote = z.infer<typeof WebSourceRemoteSchema>;
+/**
+ * The keys of a web source's `options` that are about the source rather than
+ * about converting a page. Everything else in `options` is conversion options,
+ * handed to the processor as they are.
+ */
+export declare const WebSourceOptionsSchema: z.ZodObject<{
+    refreshInterval: z.ZodOptional<z.ZodNullable<z.ZodEnum<typeof DocumentRefreshInterval>>>;
+    removeMissing: z.ZodOptional<z.ZodBoolean>;
+    confirmedRemovals: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+export type WebSourceOptions = z.infer<typeof WebSourceOptionsSchema>;
+/** The `options` keys that never reach the processor as conversion options. */
+export declare const WEB_SOURCE_OWN_OPTION_KEYS: readonly ["refreshInterval", "removeMissing", "confirmedRemovals"];
+/** The URL a web source reads, whichever mode it is in. */
+export declare function webSourceUrl(remote: Record<string, unknown>): string;
 export declare const DocumentSyncSourceSchema: z.ZodObject<{
     id: z.ZodUUID;
     organizationId: z.ZodUUID;
@@ -123,6 +184,8 @@ export declare const DocumentSyncSourceSchema: z.ZodObject<{
         skippedUnsupported: z.ZodDefault<z.ZodNumber>;
         skippedTooLarge: z.ZodDefault<z.ZodNumber>;
         failed: z.ZodDefault<z.ZodNumber>;
+        capped: z.ZodDefault<z.ZodNumber>;
+        removalHeld: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
     lastSyncAt: z.ZodNullable<z.ZodCoercedDate<unknown>>;
     lastError: z.ZodNullable<z.ZodString>;
@@ -149,13 +212,20 @@ export declare const DocumentSyncSourceCreateDtoSchema: z.ZodObject<{
     remote: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     interval: z.ZodDefault<z.ZodEnum<typeof DocumentSyncInterval>>;
     options: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    deferFirstRun: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type DocumentSyncSourceCreateDto = z.infer<typeof DocumentSyncSourceCreateDtoSchema>;
 export declare const DocumentSyncSourceUpdateDtoSchema: z.ZodObject<{
     interval: z.ZodOptional<z.ZodEnum<typeof DocumentSyncInterval>>;
     enabled: z.ZodOptional<z.ZodBoolean>;
+    removeMissing: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type DocumentSyncSourceUpdateDto = z.infer<typeof DocumentSyncSourceUpdateDtoSchema>;
+/** "Sync now", optionally approving the removal the last run held back. */
+export declare const DocumentSyncSourceSyncDtoSchema: z.ZodObject<{
+    confirmRemovals: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type DocumentSyncSourceSyncDto = z.infer<typeof DocumentSyncSourceSyncDtoSchema>;
 export declare const DocumentSyncSourceQuerystringSchema: z.ZodObject<{
     agentId: z.ZodUUID;
 }, z.core.$strip>;

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

@@ -9,7 +9,7 @@ export declare const LeadSchema: z.ZodObject<{
     phone: z.ZodNullable<z.ZodString>;
     agentId: z.ZodString;
     organizationId: z.ZodString;
-    chatId: z.ZodString;
+    chatId: z.ZodNullable<z.ZodString>;
     metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     createdAt: z.ZodCoercedDate<unknown>;
     createdBy: z.ZodString;

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

@@ -134,7 +134,20 @@ export declare const McpServerInfoSchema: z.ZodObject<{
         version: z.ZodString;
     }, z.core.$strip>;
 }, z.core.$strip>;
+/**
+ * One integration the current user has signed in to with their own account,
+ * as the profile lists it: across every organization, so a connection can be
+ * ended wherever it was made. `organizationName` is null where the user is not
+ * a member (a public agent of another tenant).
+ */
+export declare const McpServerConnectionSchema: z.ZodObject<{
+    mcpServerId: z.ZodString;
+    serverName: z.ZodString;
+    organizationName: z.ZodNullable<z.ZodString>;
+    connectedAt: z.ZodCoercedDate<unknown>;
+}, z.core.$strip>;
 export type McpServerInfo = z.infer<typeof McpServerInfoSchema>;
+export type McpServerConnection = z.infer<typeof McpServerConnectionSchema>;
 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/Media.d.ts

@@ -2,7 +2,6 @@ import { z } from 'zod';
 export declare const MAX_FILE_SIZE: number;
 export declare const MIME_TYPE_REGEX: RegExp;
 export declare const SUPPORTED_IMAGE_TYPES: readonly ["image/jpeg", "image/png", "image/gif", "image/webp", "image/svg+xml"];
-export declare const SUPPORTED_DOCUMENT_TYPES: readonly ["application/pdf", "application/msword", "application/vnd.openxmlformats-officedocument.wordprocessingml.document", "application/vnd.ms-excel", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "text/plain", "text/markdown"];
 export declare const SUPPORTED_VIDEO_TYPES: readonly ["video/mp4", "video/webm", "video/ogg"];
 export declare const SUPPORTED_AUDIO_TYPES: readonly ["audio/mpeg", "audio/wav", "audio/ogg"];
 export declare enum StoragePolicy {

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

@@ -119,6 +119,16 @@ export declare const MemberSchema: z.ZodObject<{
             user: "user";
             admin: "admin";
         }>;
+        twoFactorEnabled: z.ZodOptional<z.ZodBoolean>;
+        hasPassword: z.ZodOptional<z.ZodBoolean>;
+        hasPasskey: z.ZodOptional<z.ZodBoolean>;
+        signInSecurity: z.ZodOptional<z.ZodEnum<{
+            required: "required";
+            none: "none";
+            totp: "totp";
+            otp: "otp";
+            passkey: "passkey";
+        }>>;
     }, z.core.$strip>;
 }, z.core.$strip>;
 export type Member = z.infer<typeof MemberSchema>;

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

@@ -4,13 +4,44 @@ export declare const NotificationType: {
     readonly ApiKeyExpiring: "api_key_expiring";
     readonly Organization: "organization";
     readonly PasswordResetRequested: "password_reset_requested";
+    /** Two-step verification turned on, off, or reset by an administrator. */
+    readonly TwoFactor: "two_factor";
     /** A sync took documents out because the remote no longer has them. */
     readonly DocumentSyncRemoved: "document_sync_removed";
+    /** A web source took out pages its sitemap no longer lists. */
+    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";
     readonly ChatWarning: "chat_warning";
     readonly ChatBlocked: "chat_blocked";
     readonly Generic: "generic";
 };
 export type NotificationType = (typeof NotificationType)[keyof typeof NotificationType];
+/**
+ * Group key of the admins' notification about a flagged conversation: one row
+ * per chat and admin, bumped by every later analysis of that chat.
+ */
+export declare const chatAnalysisNotificationGroupKey: (chatId: string) => string;
+/**
+ * Title of the admins' notification about a flagged conversation. It tells a
+ * block from a warning on a stored row better than `type` does: a group bump
+ * rewrites the title, the body and the metadata, never the type, so a chat
+ * warned first and blocked later keeps `type = chat_warning`.
+ */
+export declare const chatAnalysisNotificationTitle: (blocked: boolean) => string;
+/**
+ * Body of the admins' notification about a flagged conversation
+ * (`chat_warning` or `chat_blocked`). The writer quotes the chat's title; the
+ * GDPR erasure (`eraseConversationRows`) rebuilds the body without it, from the
+ * same sentences, so the notification and its link to the chat survive with
+ * nothing the user wrote. Migration `erase_chat_residuals` holds a SQL copy
+ * of these sentences for the rows erased before it.
+ */
+export declare function chatAnalysisNotificationBody({ blocked, riskScore, chatTitle, }: {
+    blocked: boolean;
+    riskScore?: number;
+    chatTitle?: string;
+}): string;
 export declare const NotificationSchema: z.ZodObject<{
     id: z.ZodString;
     organizationId: z.ZodNullable<z.ZodString>;

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

@@ -106,6 +106,7 @@ export declare const OrganizationSchema: z.ZodObject<{
     deletedAt: z.ZodNullable<z.ZodCoercedDate<unknown>>;
     deletedBy: z.ZodNullable<z.ZodString>;
     metadata: z.ZodNullable<z.ZodString>;
+    requireTwoFactor: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type Organization = z.infer<typeof OrganizationSchema>;
 export declare const OrganizationDtoSchema: z.ZodObject<{
@@ -221,6 +222,16 @@ export declare const OrganizationRetentionPolicySchema: z.ZodObject<{
     anonymousRetentionDays: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
 }, z.core.$strip>;
 export type OrganizationRetentionPolicy = z.infer<typeof OrganizationRetentionPolicySchema>;
+/**
+ * Per-organization limits an operator sets from the system panel, persisted
+ * inside the `organization.metadata` text column. `members` counts every
+ * member, the ones the widget's external login brings in included; absent or
+ * `null` means no limit.
+ */
+export declare const OrganizationLimitsSchema: z.ZodObject<{
+    members: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+export type OrganizationLimits = z.infer<typeof OrganizationLimitsSchema>;
 /**
  * Product features an operator can switch on or off per organization from the
  * system panel. A feature is listed here when a contract can plausibly exclude
@@ -357,6 +368,9 @@ export declare const OrganizationMetadataSchema: z.ZodObject<{
         utilityModel: z.ZodOptional<z.ZodString>;
         disabledGatewayModels: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodString>>>;
     }, z.core.$strip>>>;
+    limits: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+        members: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>>>;
 }, z.core.$loose>;
 export type OrganizationMetadata = z.infer<typeof OrganizationMetadataSchema>;
 /**
@@ -381,6 +395,12 @@ export declare function parseOrganizationMetadata(metadata: string | Record<stri
  * malformed metadata resolves to the platform defaults instead of failing.
  */
 export declare function resolveOrganizationFeatures(metadata: string | Record<string, unknown> | null | undefined): OrganizationFeatures;
+/**
+ * The most members an organization may hold, from its raw `metadata` value,
+ * or `null` when it sets no limit. A malformed value reads as no limit, so a
+ * bad write can never lock an organization out of adding people.
+ */
+export declare function resolveOrganizationMemberLimit(metadata: string | Record<string, unknown> | null | undefined): number | null;
 export declare const OrganizationPublicSchema: z.ZodObject<{
     id: z.ZodString;
     name: z.ZodString;

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

@@ -0,0 +1,168 @@
+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/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.
+ */
+export declare const SignInSecurityStateSchema: z.ZodEnum<{
+    required: "required";
+    none: "none";
+    totp: "totp";
+    otp: "otp";
+    passkey: "passkey";
+}>;
+export type SignInSecurityState = z.infer<typeof SignInSecurityStateSchema>;
+/** A row of the system users list. */
+export declare const SignInSecurityUserSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    email: z.ZodString;
+    emailVerified: z.ZodBoolean;
+    image: z.ZodNullable<z.ZodString>;
+    media: z.ZodNullable<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>>>;
+    createdAt: z.ZodCoercedDate<unknown>;
+    updatedAt: z.ZodCoercedDate<unknown>;
+    banned: z.ZodNullable<z.ZodBoolean>;
+    banReason: z.ZodNullable<z.ZodString>;
+    banExpires: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+    isAnonymous: z.ZodNullable<z.ZodBoolean>;
+    role: z.ZodEnum<{
+        user: "user";
+        admin: "admin";
+    }>;
+    twoFactorEnabled: z.ZodOptional<z.ZodBoolean>;
+    signInSecurity: z.ZodEnum<{
+        required: "required";
+        none: "none";
+        totp: "totp";
+        otp: "otp";
+        passkey: "passkey";
+    }>;
+}, z.core.$strip>;
+export type SignInSecurityUser = z.infer<typeof SignInSecurityUserSchema>;
+export declare const SignInSecurityUsersQuerystringSchema: z.ZodObject<{
+    signInSecurity: z.ZodOptional<z.ZodEnum<{
+        required: "required";
+        none: "none";
+        totp: "totp";
+        otp: "otp";
+        passkey: "passkey";
+    }>>;
+    "filter[fullText]": z.ZodOptional<z.ZodString>;
+    sort: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        name: "name";
+        createdAt: "createdAt";
+        updatedAt: "updatedAt";
+        "-name": "-name";
+        "-createdAt": "-createdAt";
+        "-updatedAt": "-updatedAt";
+        email: "email";
+        "-email": "-email";
+    }>>>;
+    '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>>>;
+}, z.core.$strip>;
+export type SignInSecurityUsersQuerystring = z.infer<typeof SignInSecurityUsersQuerystringSchema>;
+/** How many users are in each state. */
+export declare const SignInSecuritySummarySchema: z.ZodRecord<z.ZodEnum<{
+    required: "required";
+    none: "none";
+    totp: "totp";
+    otp: "otp";
+    passkey: "passkey";
+}>, z.ZodNumber>;
+export type SignInSecuritySummary = z.infer<typeof SignInSecuritySummarySchema>;

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

@@ -118,6 +118,7 @@ export declare const UserSchema: z.ZodObject<{
         user: "user";
         admin: "admin";
     }>;
+    twoFactorEnabled: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type User = z.infer<typeof UserSchema>;
 /**

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

@@ -33,6 +33,7 @@ export * from './Integration';
 export * from './Platform';
 export * from './ReasoningChat';
 export * from './RevisedAnswer';
+export * from './SignInSecurity';
 export * from './StreamError';
 export * from './SubAgent';
 export * from './TimingLog';