@8wave/ai-elements 0.114.0-beta.30 → 0.114.0-beta.7

package/dist-vue/locales.js

@@ -305,7 +305,6 @@ var e = {
 		toolApprovalBadge: "User confirm",
 		calendarEvent: "Event",
 		comparison: "Comparison",
-		recommended: "Recommended",
 		contactUs: "Contact us",
 		phone: "Phone number",
 		diagram: "Diagram",
@@ -471,18 +470,6 @@ var e = {
 		untitled: "Untitled file",
 		exclude: "Remove file"
 	},
-	twoFactor: {
-		challengeBackup: "Enter one of the backup codes you saved.",
-		challengeEmailSent: "We sent a 6-digit code to your email. It expires in 5 minutes.",
-		challengeApp: "Enter the 6-digit code from your authenticator app.",
-		challengeTitle: "Two-step verification",
-		backupCode: "Backup code",
-		code: "6-digit code",
-		verify: "Verify",
-		useBackupCode: "Use a backup code",
-		useApp: "Use the authenticator app",
-		sendAgain: "Send a new code"
-	},
 	auth: {
 		signInTitle: "Sign in to your account",
 		signUpTitle: "Create your account",
@@ -580,14 +567,6 @@ var e = {
 		feelsLike: "Feels like",
 		dailyForecast: "Daily forecast",
 		airQuality: "Air quality"
-	},
-	turnEvaluation: {
-		cost: "Cost, not charged to the organization: {cost}",
-		title: "Evaluation after the reply",
-		modeHint: "Recorded after the reply, with no effect: nothing reads these probabilities yet.",
-		version: "Questions version {version}",
-		leadFailed: "The evaluation failed or did not answer within {budget} ms: nothing was recorded.",
-		probability: "Probability the evaluation model gives to the question: from 0.5 it leans towards yes"
 	}
 }, t = {
 	agentType: {
@@ -895,7 +874,6 @@ var e = {
 		toolApprovalBadge: "Conferma utente",
 		calendarEvent: "Evento",
 		comparison: "Confronto",
-		recommended: "Consigliato",
 		contactUs: "Contattaci",
 		phone: "Telefono",
 		diagram: "Diagramma",
@@ -1061,18 +1039,6 @@ var e = {
 		untitled: "File senza nome",
 		exclude: "Rimuovi file"
 	},
-	twoFactor: {
-		challengeBackup: "Scrivi uno dei codici di recupero che hai salvato.",
-		challengeEmailSent: "Ti abbiamo inviato un codice a 6 cifre via email. Scade fra 5 minuti.",
-		challengeApp: "Scrivi il codice a 6 cifre della tua app di autenticazione.",
-		challengeTitle: "Verifica in due passaggi",
-		backupCode: "Codice di recupero",
-		code: "Codice a 6 cifre",
-		verify: "Verifica",
-		useBackupCode: "Usa un codice di recupero",
-		useApp: "Usa l'app di autenticazione",
-		sendAgain: "Invia un nuovo codice"
-	},
 	auth: {
 		signInTitle: "Accedi al tuo account",
 		signUpTitle: "Crea il tuo account",
@@ -1170,14 +1136,6 @@ var e = {
 		feelsLike: "Percepita",
 		dailyForecast: "Previsioni giornaliere",
 		airQuality: "Qualità dell'aria"
-	},
-	turnEvaluation: {
-		cost: "Costo, non addebitato all'organizzazione: {cost}",
-		title: "Valutazione a fine turno",
-		modeHint: "Registrata dopo la risposta, senza effetti: per ora nessuno legge queste probabilità.",
-		version: "Versione delle domande: {version}",
-		leadFailed: "La valutazione non è riuscita o non ha risposto entro {budget} ms: non è stato registrato niente.",
-		probability: "Probabilità che il modello di valutazione dà alla domanda: da 0,5 in su propende per il sì"
 	}
 };
 //#endregion

package/dist-vue/packages/ability/src/index.d.ts

@@ -1,5 +1,6 @@
-import { MongoAbility, InferSubjects, ForcedSubject } from '@casl/ability';
+import { MongoAbility, InferSubjects, ForcedSubject, Ability as PureAbility } from '@casl/ability';
 import { Action, Capability, Subject, Session } from './types';
+import { MongoQueryTopLevelOperators } from '@ucast/mongo2js';
 import { Statements, RoleInput, Role, ExactRoleStatements } from 'better-auth/plugins';
 export declare const OrganizationRoles: {
     readonly admin: "admin";
@@ -12,20 +13,23 @@ export declare const UserRoles: {
     readonly user: "user";
 };
 export type AbilitySubject = InferSubjects<'all' | Subject, true> | ForcedSubject<InferSubjects<'all' | Subject, true>>;
-export type AppAbility = MongoAbility<[Action, AbilitySubject]>;
+type Ability = MongoAbility<[Action, AbilitySubject]>;
+export declare const ability: PureAbility<[Action, AbilitySubject], {
+    [x: string]: any;
+    [x: number]: any;
+    [x: symbol]: any;
+} & MongoQueryTopLevelOperators<Record<PropertyKey, any>>>;
 export declare const isValidOrganizationRole: (role?: string | null) => role is keyof typeof OrganizationRoles;
 export declare const isValidUserRole: (role?: string | null) => role is keyof typeof UserRoles;
 export declare const getOrganizationRoleCapabilities: (currentSession?: Session | null) => Capability[];
 export declare const getUserRoleCapabilities: (currentSession?: Session | null) => Capability[];
 /**
- * Builds the ability of one caller: the session's roles, or the guest rules
- * when there is no session. Every call returns a new instance and this package
- * keeps none: a server judges many callers at once, so an instance shared
- * between them is judged by whoever wrote it last. The backend builds one per
- * request (`request.ability`), the Platform MCP one per tool call, and the
- * frontend keeps its own for the single user of the tab.
+ * Builds a standalone ability instance for a session, without touching the
+ * shared singleton. Use for per-call checks outside the HTTP request flow
+ * (e.g. MCP tool handlers).
  */
-export declare const buildAbilityForSession: (currentSession?: Session | null) => AppAbility;
+export declare const buildAbilityForSession: (currentSession?: Session | null) => Ability;
+export declare const updateAbilityFromSession: (currentSession?: Session | null) => void;
 export type PermissionMap = Partial<Record<Action, Subject>>;
 /**
  * Evaluates a route-style permission map ({ action: Subject }) against an
@@ -35,7 +39,7 @@ export type PermissionMap = Partial<Record<Action, Subject>>;
  * Single source of truth for both the HTTP preHandler and the Platform MCP
  * tool handlers.
  */
-export declare const findDeniedPermission: (abilityInstance: Pick<AppAbility, "can">, permissions: PermissionMap, payload?: unknown) => {
+export declare const findDeniedPermission: (abilityInstance: Pick<Ability, "can">, permissions: PermissionMap, payload?: unknown) => {
     action: Action;
     subject: Subject;
 } | null;

package/dist-vue/packages/auth/src/social-redirect-plugin.d.ts

@@ -1,28 +1,22 @@
 import { BetterAuthPlugin } from 'better-auth';
 /**
- * Whether `value` is exactly one of the trusted origins: a bare origin, listed
- * as it is. better-auth matches its trusted origins as patterns, so an agent
- * whose trusted origins hold `*` would let any page through; the CORS plugin
- * (apps/backend/src/plugins/fastifyCors.ts) compares them exactly, and a widget
- * whose host it refuses cannot run anyway.
- */
-export declare function isListedOrigin(value: string, trusted: string[]): boolean;
-/**
- * Backs the social sign-in that runs in a browser window on the backend origin.
+ * Backs the widget social-login OAuth popup flow end to end.
  *
  * `socialRedirect` initiates the flow through a top-level GET navigation instead
  * of the default `POST /sign-in/social` XHR call. Better-auth's social sign-in
  * sets a signed `state` cookie that the OAuth callback verifies (CSRF
- * protection). When the flow is started from an XHR on a different origin, that
- * `Set-Cookie` is a third-party cookie and modern browsers drop it, so the
- * callback fails with `state_mismatch`. By navigating the browser directly to
+ * protection). When the flow is started from an XHR on a different origin (e.g.
+ * the embeddable widget, or any cross-site context), that `Set-Cookie` is a
+ * third-party cookie and modern browsers drop it, so the callback fails with
+ * `state_mismatch`. By navigating the browser (popup or full page) directly to
  * this endpoint on the backend origin, the `state` cookie is set first-party and
- * survives. It mirrors the redirect branch of core `signInSocial`, reusing
- * `generateState` so the stored state stays compatible with the standard OAuth
- * callback. The frontend uses it; the widget's popup uses `oauthPopup`, whose
- * callback hands back the token of the session it just created, and only to the
- * origin that started it.
+ * survives, both in development and in production on customer domains. It mirrors
+ * the redirect branch of core `signInSocial`, reusing `generateState` so the
+ * stored state stays compatible with the standard OAuth callback.
  *
- * The before hook narrows the origin `oauthPopup` accepts to the listed ones.
+ * `widgetOAuthCallback` is the landing page the popup ends on after the OAuth
+ * callback completes (it's the `callbackURL` passed to `socialRedirect`). It runs
+ * on the backend origin so it can read the first-party session cookie and post the
+ * Bearer token back to the widget opener.
  */
 export declare function socialRedirect(): BetterAuthPlugin;

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

@@ -4,12 +4,6 @@ type __VLS_Props = {
     branding?: AgentBranding;
     authMethods?: AuthMethods;
     loading?: boolean;
-    /**
-     * Set while an email sign-in waits for its second factor: the
-     * methods the account has (`totp`, `otp`). The code step replaces
-     * the forms until it is answered or cancelled.
-     */
-    twoFactorMethods?: string[];
 };
 type __VLS_ModelProps = {
     'errorMessage'?: string | undefined;
@@ -49,12 +43,6 @@ declare const __VLS_export: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, C
         email: string;
     }) => any;
     social: (provider: "google" | "microsoft") => any;
-    "verify-two-factor": (payload: {
-        kind: "totp" | "otp" | "backup";
-        code: string;
-    }) => any;
-    "send-two-factor-code": () => any;
-    "cancel-two-factor": () => any;
 }, string, PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
     "onUpdate:errorMessage"?: ((message?: string | undefined) => any) | undefined;
     "onUpdate:success"?: ((value?: {
@@ -75,17 +63,10 @@ declare const __VLS_export: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, C
         email: string;
     }) => any) | undefined;
     onSocial?: ((provider: "google" | "microsoft") => any) | undefined;
-    "onVerify-two-factor"?: ((payload: {
-        kind: "totp" | "otp" | "backup";
-        code: string;
-    }) => any) | undefined;
-    "onSend-two-factor-code"?: (() => any) | undefined;
-    "onCancel-two-factor"?: (() => any) | undefined;
 }>, {
     branding: AgentBranding;
     authMethods: AuthMethods;
     loading: boolean;
-    twoFactorMethods: string[];
 }, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

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

@@ -1,5 +1,5 @@
 import { ChatMessageActions, MessageFeedback, RevisedAnswer, UIChatMessage } from '../../../models/src';
-import { TextUIPart, CustomContentUIPart, ReasoningUIPart, DynamicToolUIPart, SourceUrlUIPart, SourceDocumentUIPart, ReasoningFileUIPart, StepStartUIPart, UIToolInvocation, UITool } from 'ai';
+import { TextUIPart, UIToolInvocation, UITool } from 'ai';
 import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 type __VLS_Props = {
     status?: 'submitted' | 'streaming' | 'ready' | 'error';
@@ -55,15 +55,11 @@ declare var __VLS_25: {
     part: TextUIPart;
     index: number;
     isLoading: boolean;
-}, __VLS_73: "custom" | "reasoning" | "text" | "dynamic-tool" | "source-url" | "source-document" | "reasoning-file" | "step-start" | `data-${string}` | `tool-${string}`, __VLS_74: {
+}, __VLS_73: `tool-${string}`, __VLS_74: {
     message: UIChatMessage;
-    part: TextUIPart | CustomContentUIPart | ReasoningUIPart | DynamicToolUIPart | SourceUrlUIPart | SourceDocumentUIPart | ReasoningFileUIPart | StepStartUIPart | ({
+    part: {
         type: `tool-${string}`;
-    } & UIToolInvocation<UITool>) | {
-        type: `data-${string}`;
-        id?: string;
-        data: unknown;
-    };
+    } & UIToolInvocation<UITool>;
     index: number;
     isLoading: boolean;
 };

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

@@ -3,7 +3,6 @@ import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOp
 type __VLS_Props = {
     message: UIChatMessage;
     isStreaming?: boolean;
-    hasContent?: boolean;
     isDark?: boolean;
 };
 declare const __VLS_export: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

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

@@ -7,15 +7,6 @@ export { isTextPart, isFilePart, isToolPart, isReasoningPart, hasPartText, hasTe
  * that should logically be a single block of text.
  */
 export declare function mergeConsecutiveTextParts(parts: UIMessage['parts']): UIMessage['parts'];
-/**
- * Drops a widget call refused for its arguments when a later call of the same
- * widget in the message was drawn: the turn corrected it (the backend's
- * `correctableInputRefusals`), and the refusal would sit next to the working
- * widget, `showForm` drawing its render error above the form. A refusal with
- * nothing drawn after it stays. Only the feed reads this: the steps timeline
- * keeps every call, the refused one included.
- */
-export declare function dropCorrectedWidgetErrors(parts: UIMessage['parts']): UIMessage['parts'];
 export declare function isStreamingPart(part: UIMessage['parts'][number] | null | undefined): part is Extract<UIMessage['parts'][number], {
     streaming?: boolean;
 }>;

package/dist-vue/packages/components/src/index.d.ts

@@ -22,7 +22,6 @@ import { default as PkLoader } from './PkLoader';
 import { default as PkMedia } from './PkMedia';
 import { default as PkOfflineScreen } from './PkOfflineScreen';
 import { default as PkPwaNotices } from './PkPwaNotices';
-import { default as PkQrCode } from './PkQrCode';
 import { default as PkRelativeTime } from './PkRelativeTime';
 import { default as PkSkeleton } from './PkSkeleton';
 import { default as PkSvgViewer } from './PkSvgViewer';
@@ -33,4 +32,4 @@ export * from './chat';
 export * from './input';
 export * from './table';
 export * from './types';
-export { PkBadge, PkEditorAgentType, PkEditorDocumentType, PkEditorNotificationType, PkEditorCode, PkEditorJsonSchema, PkEditorMarkdown, PkEditorMedia, PkEditorPrompt, PkEditorRadioButtons, PkEditorCheckboxButtons, PkEditorRepeater, PkEditorWyswyg, PkCheckboxField, PkFieldset, PkInfobox, PkSchemaField, PkIntegrationProvider, PkLazyImg, PkLightbox, PkLoader, PkMedia, PkOfflineScreen, PkPwaNotices, PkQrCode, PkRelativeTime, PkSkeleton, PkSvgViewer, PkUrl, };
+export { PkBadge, PkEditorAgentType, PkEditorDocumentType, PkEditorNotificationType, PkEditorCode, PkEditorJsonSchema, PkEditorMarkdown, PkEditorMedia, PkEditorPrompt, PkEditorRadioButtons, PkEditorCheckboxButtons, PkEditorRepeater, PkEditorWyswyg, PkCheckboxField, PkFieldset, PkInfobox, PkSchemaField, PkIntegrationProvider, PkLazyImg, PkLightbox, PkLoader, PkMedia, PkOfflineScreen, PkPwaNotices, PkRelativeTime, PkSkeleton, PkSvgViewer, PkUrl, };

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

@@ -633,16 +633,6 @@ export declare function useChatbotStore(agentId: string): Store<`chatbot-${strin
                         failed?: boolean | undefined;
                     } | undefined;
                 } | undefined;
-                turnEvaluation?: {
-                    version: number;
-                    mode: "shadow";
-                    probabilities: Record<string, number>;
-                    latencyMs: number;
-                    budgetMs: number;
-                    cost?: number | undefined;
-                    inputTokens?: number | undefined;
-                    failed?: true | undefined;
-                } | undefined;
             } | undefined;
             parts: ({
                 type: "text";
@@ -1149,16 +1139,6 @@ export declare function useChatbotStore(agentId: string): Store<`chatbot-${strin
                         failed?: boolean | undefined;
                     } | undefined;
                 } | undefined;
-                turnEvaluation?: {
-                    version: number;
-                    mode: "shadow";
-                    probabilities: Record<string, number>;
-                    latencyMs: number;
-                    budgetMs: number;
-                    cost?: number | undefined;
-                    inputTokens?: number | undefined;
-                    failed?: true | undefined;
-                } | undefined;
             } | undefined;
             parts: ({
                 type: "text";
@@ -2363,16 +2343,6 @@ export declare function useChatbotStore(agentId: string): Store<`chatbot-${strin
                         failed?: boolean | undefined;
                     } | undefined;
                 } | undefined;
-                turnEvaluation?: {
-                    version: number;
-                    mode: "shadow";
-                    probabilities: Record<string, number>;
-                    latencyMs: number;
-                    budgetMs: number;
-                    cost?: number | undefined;
-                    inputTokens?: number | undefined;
-                    failed?: true | undefined;
-                } | undefined;
             } | undefined;
             parts: ({
                 type: "text";
@@ -2879,16 +2849,6 @@ export declare function useChatbotStore(agentId: string): Store<`chatbot-${strin
                         failed?: boolean | undefined;
                     } | undefined;
                 } | undefined;
-                turnEvaluation?: {
-                    version: number;
-                    mode: "shadow";
-                    probabilities: Record<string, number>;
-                    latencyMs: number;
-                    budgetMs: number;
-                    cost?: number | undefined;
-                    inputTokens?: number | undefined;
-                    failed?: true | undefined;
-                } | undefined;
             } | undefined;
             parts: ({
                 type: "text";
@@ -4093,16 +4053,6 @@ export declare function useChatbotStore(agentId: string): Store<`chatbot-${strin
                         failed?: boolean | undefined;
                     } | undefined;
                 } | undefined;
-                turnEvaluation?: {
-                    version: number;
-                    mode: "shadow";
-                    probabilities: Record<string, number>;
-                    latencyMs: number;
-                    budgetMs: number;
-                    cost?: number | undefined;
-                    inputTokens?: number | undefined;
-                    failed?: true | undefined;
-                } | undefined;
             } | undefined;
             parts: ({
                 type: "text";
@@ -4609,16 +4559,6 @@ export declare function useChatbotStore(agentId: string): Store<`chatbot-${strin
                         failed?: boolean | undefined;
                     } | undefined;
                 } | undefined;
-                turnEvaluation?: {
-                    version: number;
-                    mode: "shadow";
-                    probabilities: Record<string, number>;
-                    latencyMs: number;
-                    budgetMs: number;
-                    cost?: number | undefined;
-                    inputTokens?: number | undefined;
-                    failed?: true | undefined;
-                } | undefined;
             } | undefined;
             parts: ({
                 type: "text";

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

@@ -492,52 +492,10 @@ export type UIChatMessageMetadata = {
      * organization ({@link withoutToolCatalogue}).
      */
     toolCatalogue?: ToolCatalogueRecord;
-    /**
-     * The evaluation of the turn after the reply (spec post-turn-evaluation):
-     * a probability per question. Written after the answer, and removed from
-     * a public read ({@link withoutTurnEvaluation}).
-     */
-    turnEvaluation?: TurnEvaluationRecord;
-};
-/**
- * The questions of the post-turn evaluation, in the order they are asked and
- * listed. The backend's questions are typed against it, so the two cannot
- * drift. A reader orders by this list and not by the record: jsonb keeps the
- * keys of an object sorted by length, not in the order they were written.
- */
-export declare const TURN_EVALUATION_QUESTION_IDS: readonly ["durableFact", "abusive", "manipulation", "asksHuman", "missingInfo", "informationGap"];
-export type TurnEvaluationQuestionId = (typeof TURN_EVALUATION_QUESTION_IDS)[number];
-/**
- * The evaluation model's answers on a finished turn (spec
- * post-turn-evaluation, F1). Recorded in shadow only: nothing reads it yet.
- */
-export type TurnEvaluationRecord = {
-    /**
-     * The wording of the questions: a threshold holds only for the wording
-     * it was measured on, so a record says which one it answered.
-     */
-    version: number;
-    mode: 'shadow';
-    /** Probability per question, two decimals. Empty when the request failed. */
-    probabilities: Record<string, number>;
-    latencyMs: number;
-    budgetMs: number;
-    /** Market cost of the request in USD. */
-    cost?: number;
-    inputTokens?: number;
-    /** The request failed or ran past its budget: no answer was recorded. */
-    failed?: true;
 };
 export type UIChatMessage = UIMessage & {
     metadata?: UIChatMessageMetadata;
 };
-/**
- * The history without the turn evaluations, for a public read: a probability
- * of abuse on a user must not reach the widget. Kept apart from
- * {@link withoutToolCatalogue}, which the data export uses too, because
- * whether the export includes this judgment is still to be decided.
- */
-export declare function withoutTurnEvaluation(messages: UIChatMessage[]): UIChatMessage[];
 /**
  * The history without the tool catalogue records, for a reader outside the
  * organization (a public chat read, the data export): a record names every

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

@@ -118,8 +118,6 @@ declare const WebDocumentSourceSchema: z.ZodObject<{
     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>;
 /**
  * `metadata.source`, discriminated on `provider`.
@@ -151,8 +149,6 @@ export declare const DocumentSourceSchema: z.ZodPreprocess<z.ZodDiscriminatedUni
     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<{
@@ -428,14 +424,6 @@ export interface DocumentProcessingJob {
      * that really did get shorter, so the guard would only stand in their way.
      */
     guarded?: boolean;
-    /**
-     * The web source whose sitemap asked for this early refresh. Nobody is
-     * watching it either, so it enforces the shrink guard; and it is void if
-     * the page no longer belongs to that source, which is what editing its text
-     * by hand does. Not `guarded`, which also voids a page without a trigger:
-     * a source reads its pages whether they have one or not.
-     */
-    sourceId?: string;
 }
 /**
  * Metadata structure for document.metadata column
@@ -459,8 +447,6 @@ export declare const DocumentMetadataSchema: z.ZodObject<{
         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<{
@@ -897,8 +883,6 @@ export declare const DocumentSchema: z.ZodObject<{
             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<{
@@ -1442,7 +1426,6 @@ export declare const DocumentCreateDtoSchema: z.ZodObject<{
     pages: z.ZodOptional<z.ZodString>;
     priority: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
     refreshInterval: z.ZodOptional<z.ZodNullable<z.ZodEnum<typeof DocumentRefreshInterval>>>;
-    syncSourceId: z.ZodOptional<z.ZodUUID>;
 }, z.core.$strip>;
 /**
  * Document update schema for PUT /documents/:id endpoint

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

@@ -39,16 +39,6 @@ export type DocumentFolder = z.infer<typeof DocumentFolderSchema>;
  * business, which is why it reads the first segment and stops.
  */
 export declare function documentFolderProvider(folder: Pick<DocumentFolder, 'externalId'>): DocumentSourceProvider | undefined;
-/**
- * Whether a folder is read-only because a source that owns its documents
- * fills it.
- *
- * Not the same question as `documentFolderProvider`: a web source's folder has
- * a provider, and an icon and a badge that say so, but its pages stay editable
- * and anything can be added to it. The backend answers the same question with
- * `owningSourceCondition`, from the same policy.
- */
-export declare function documentFolderIsReadOnly(folder: Pick<DocumentFolder, 'externalId'>): boolean;
 export type DocumentFolderCreateDto = z.infer<typeof DocumentFolderCreateDtoSchema>;
 export type DocumentFolderUpdateDto = z.infer<typeof DocumentFolderUpdateDtoSchema>;
 export type DocumentFolderQuerystring = z.infer<typeof DocumentFolderQuerystringSchema>;

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

@@ -1,32 +1,5 @@
-import { DocumentRefreshInterval, DocumentSourceProvider } from './Document';
+import { 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.
  *
@@ -123,42 +96,8 @@ 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;
@@ -184,8 +123,6 @@ 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>;
@@ -212,20 +149,13 @@ 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/Media.d.ts

@@ -2,6 +2,7 @@ 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,9 +119,6 @@ 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>;
     }, z.core.$strip>;
 }, z.core.$strip>;
 export type Member = z.infer<typeof MemberSchema>;