@memori.ai/memori-react 8.19.3 → 8.21.0

package/esm/testUtils.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { render as rtlRender, } from '@testing-library/react';
+import { AlertProvider, AlertViewport } from '@memori.ai/ui';
+function AlertProviderWrapper({ children }) {
+    return (_jsxs(AlertProvider, { children: [children, _jsx(AlertViewport, {})] }));
+}
+function render(ui, options) {
+    return rtlRender(ui, {
+        wrapper: AlertProviderWrapper,
+        ...options,
+    });
+}
+export * from '@testing-library/react';
+export { render };
+//# sourceMappingURL=testUtils.js.map

package/esm/testUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"testUtils.js","sourceRoot":"","sources":["../src/testUtils.tsx"],"names":[],"mappings":";AACA,OAAO,EACL,MAAM,IAAI,SAAS,GAGpB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAM7D,SAAS,oBAAoB,CAAC,EAAE,QAAQ,EAAiC;IACvE,OAAO,CACL,MAAC,aAAa,eACX,QAAQ,EACT,KAAC,aAAa,KAAG,IACH,CACjB,CAAC;AACJ,CAAC;AAUD,SAAS,MAAM,CACb,EAAsB,EACtB,OAAwC;IAExC,OAAO,SAAS,CAAC,EAAE,EAAE;QACnB,OAAO,EAAE,oBAAoB;QAC7B,GAAG,OAAO;KACX,CAAC,CAAC;AACL,CAAC;AAGD,cAAc,wBAAwB,CAAC;AACvC,OAAO,EAAE,MAAM,EAAE,CAAC"}

package/esm/types/layout.d.ts

@@ -0,0 +1,16 @@
+export type LayoutName = 'DEFAULT' | 'FULLPAGE' | 'TOTEM' | 'CHAT' | 'WEBSITE_ASSISTANT' | 'HIDDEN_CHAT' | 'ZOOMED_FULL_BODY';
+export interface PiiDetectionRule {
+    id: string;
+    label: Record<string, string>;
+    pattern: string;
+    message: Record<string, string>;
+}
+export interface PiiDetectionConfig {
+    enabled: boolean;
+    rules: PiiDetectionRule[];
+    errorMessage: Record<string, string>;
+}
+export type LayoutProp = LayoutName | {
+    name: LayoutName;
+    piiDetection?: PiiDetectionConfig;
+};

package/esm/types/layout.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=layout.js.map

package/esm/types/layout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout.js","sourceRoot":"","sources":["../../src/types/layout.ts"],"names":[],"mappings":""}

package/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "8.19.3";
+export declare const version = "8.21.0";

package/esm/version.js

@@ -1,2 +1,2 @@
-export const version = '8.19.3';
+export const version = '8.21.0';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "8.19.3",
+  "version": "8.21.0",
   "name": "@memori.ai/memori-react",
   "author": "Memori Srl",
   "main": "dist/index.js",

package/src/components/ContentPreviewModal/ContentPreviewModal.css

@@ -15,7 +15,6 @@
   overflow: hidden;
   min-width: 500px;
   min-height: 500px;
-  max-height: 80vh;
   border-radius: 16px;
   background: var(--memori-content-preview-bg, #fafafa);
   box-shadow:

package/src/components/FilePreview/FilePreview.tsx

@@ -5,6 +5,7 @@ import Button from '../ui/Button';
 import ContentPreviewModal from '../ContentPreviewModal';
 import Snippet from '../Snippet/Snippet';
 import { stripHTML, stripDocumentAttachmentTags } from '../../helpers/utils';
+import { getFileExtensionFromMime } from '../MediaWidget/MediaItemWidget.utils';
 
 type FilePreviewProps = {
   previewFiles: any;
@@ -147,7 +148,9 @@ FilePreviewProps) => {
                 <div className="memori--preview-file-info">
                   <span className="memori--preview-filename">{file.name}</span>
                   <span className="memori--preview-filetype">
-                    {getFileType(file.name, file.type)}
+                    {file.mimeType
+                      ? getFileExtensionFromMime(file.mimeType)
+                      : getFileType(file.name, file.type)}
                   </span>
                 </div>
 

package/src/components/MemoriWidget/MemoriWidget.stories.tsx

@@ -259,3 +259,5 @@ WithUserAvatarAsElement.args = {
   tenant,
   userAvatar: <span>USER</span>,
 };
+
+

package/src/components/MemoriWidget/MemoriWidget.tsx

@@ -18,6 +18,8 @@ import {
 } from '@memori.ai/memori-api-client/src/types';
 import { ArtifactData } from '../MemoriArtifactSystem/types/artifact.types';
 import { ArtifactAPIBridge } from '../MemoriArtifactSystem/utils/ArtifactAPI';
+import type { LayoutName, PiiDetectionConfig } from '../../types/layout';
+import { checkPii } from '../../helpers/piiDetection'; // PII check when integrationConfig.layout has piiDetection.enabled
 
 // Libraries
 import React, {
@@ -378,14 +380,7 @@ export interface Props {
   memoriLang?: string;
   multilingual?: boolean;
   integration?: Integration;
-  layout?:
-    | 'DEFAULT'
-    | 'FULLPAGE'
-    | 'TOTEM'
-    | 'CHAT'
-    | 'WEBSITE_ASSISTANT'
-    | 'HIDDEN_CHAT'
-    | 'ZOOMED_FULL_BODY';
+  layout?: LayoutName;
   customLayout?: React.FC<LayoutProps>;
   showShare?: boolean;
   showCopyButton?: boolean;
@@ -604,7 +599,20 @@ const MemoriWidget = ({
   const [memoriTyping, setMemoriTyping] = useState<boolean>(false);
   const [typingText, setTypingText] = useState<string>();
 
-  const selectedLayout = layout || integrationConfig?.layout || 'DEFAULT';
+  // Layout: from prop (string only) or integrationConfig. PII detection is only from integrationConfig (customData.layout as object with piiDetection).
+  const layoutName =
+    typeof layout === 'string'
+      ? layout
+      : typeof integrationConfig?.layout === 'string'
+        ? integrationConfig.layout
+        : integrationConfig?.layout?.name;
+  const selectedLayout = layoutName || 'DEFAULT';
+  const piiDetection: PiiDetectionConfig | undefined =
+    typeof integrationConfig?.layout === 'object' &&
+    integrationConfig?.layout !== null &&
+    integrationConfig?.layout?.piiDetection?.enabled
+      ? integrationConfig.layout.piiDetection
+      : undefined;
 
   const defaultEnableAudio =
     enableAudio ?? integrationConfig?.enableAudio ?? true;
@@ -808,6 +816,65 @@ const MemoriWidget = ({
       (window.getMemoriState() as MemoriSession)?.sessionID;
     if (!sessionID || !text?.length) return;
 
+    // Build full message text (same as what will be sent) so we can run PII check on it.
+    // Order: user text -> optional translation -> appended document attachment content.
+    let msg = text;
+    if (
+      !hidden &&
+      translate &&
+      isMultilanguageEnabled &&
+      userLang.toUpperCase() !== language.toUpperCase()
+    ) {
+      const translation = await getTranslation(
+        text,
+        language,
+        userLang,
+        baseUrl
+      );
+      msg = translation.text;
+    }
+    const mediaDocuments = media?.filter(
+      m => (m as any).type === 'document' && m.properties?.isAttachedFile
+    );
+    if (mediaDocuments && mediaDocuments.length > 0) {
+      const documentContents = mediaDocuments
+        .map(doc => doc.content)
+        .join(' ');
+      msg = msg + ' ' + documentContents;
+    }
+
+    // PII check: when layout has piiDetection.enabled, run regex rules on the full msg.
+    // If any rule matches, add the user message to history, then push the system error bubble and return without sending.
+    if (piiDetection?.enabled) {
+      const piiResult = checkPii(
+        msg,
+        piiDetection,
+        userLang?.toLowerCase() || 'en'
+      );
+      if (piiResult.matched && piiResult.errorText) {
+        if (!hidden) {
+          pushMessage({
+            text: text,
+            translatedText,
+            fromUser: true,
+            media: media ?? [],
+            initial: sessionId
+              ? !!newSessionId && newSessionId !== sessionId
+              : !!newSessionId,
+          });
+        }
+        pushMessage({
+          text: piiResult.errorText,
+          emitter: 'system',
+          fromUser: false,
+          initial: false,
+          contextVars: {},
+          date: new Date().toISOString(),
+        });
+        return;
+      }
+    }
+
     // Add user message to chat history if not hidden
     if (!hidden)
       pushMessage({
@@ -824,37 +891,9 @@ const MemoriWidget = ({
     setMemoriTyping(true);
     setTypingText(typingText);
 
-    let msg = text;
     let gotError = false;
 
     try {
-      // Translate message if needed
-      if (
-        !hidden &&
-        translate &&
-        isMultilanguageEnabled &&
-        userLang.toUpperCase() !== language.toUpperCase()
-      ) {
-        const translation = await getTranslation(
-          text,
-          language,
-          userLang,
-          baseUrl
-        );
-        msg = translation.text;
-      }
-
-      // Handle document attachments
-      const mediaDocuments = media?.filter(
-        m => (m as any).type === 'document' && m.properties?.isAttachedFile
-      );
-      if (mediaDocuments && mediaDocuments.length > 0) {
-        const documentContents = mediaDocuments
-          .map(doc => doc.content)
-          .join(' ');
-        msg = msg + ' ' + documentContents;
-      }
-
       // Add chat reference link to the message if it exists
       // if (chatLogID) {
       //   msg =

package/src/helpers/piiDetection.test.ts

@@ -0,0 +1,186 @@
+import { checkPii } from './piiDetection';
+
+const baseConfig = {
+  enabled: true,
+  rules: [
+    {
+      id: 'email',
+      label: { it: 'Email', en: 'Email' },
+      pattern: '\\b[A-Za-z0-9._%+\\-]+@[A-Za-z0-9.\\-]+\\.[A-Za-z]{2,}\\b',
+      message: { it: 'Contiene email.', en: 'Contains email.' },
+    },
+    {
+      id: 'iban',
+      label: { it: 'IBAN', en: 'IBAN' },
+      pattern: '\\b[A-Z]{2}\\d{2}(?:[ ]?[A-Z0-9]{4}){3,7}(?:[ ]?[A-Z0-9]{1,4})?\\b',
+      message: { it: 'Contiene IBAN.', en: 'Contains IBAN.' },
+    },
+  ],
+  errorMessage: {
+    it: 'Dati sensibili.',
+    en: 'Sensitive data.',
+  },
+};
+
+describe('checkPii', () => {
+  describe('edge cases: no match', () => {
+    it('returns no match when config is disabled', () => {
+      expect(
+        checkPii('test@example.com', { ...baseConfig, enabled: false }, 'en')
+      ).toEqual({ matched: false });
+    });
+
+    it('returns no match when config is null', () => {
+      expect(checkPii('hello', null as any, 'en')).toEqual({ matched: false });
+    });
+
+    it('returns no match when config is undefined', () => {
+      expect(checkPii('hello', undefined as any, 'en')).toEqual({
+        matched: false,
+      });
+    });
+
+    it('returns no match when rules is empty array', () => {
+      expect(
+        checkPii('test@example.com', { ...baseConfig, rules: [] }, 'en')
+      ).toEqual({ matched: false });
+    });
+
+    it('returns no match when rules is not an array', () => {
+      expect(
+        checkPii('test@example.com', { ...baseConfig, rules: null as any }, 'en')
+      ).toEqual({ matched: false });
+    });
+
+    it('returns no match when no rule matches the text', () => {
+      expect(checkPii('just plain hello world', baseConfig, 'en')).toEqual({
+        matched: false,
+      });
+    });
+
+    it('skips rules with empty pattern (avoids matching everything)', () => {
+      const configWithEmptyPattern = {
+        ...baseConfig,
+        rules: [
+          { id: 'empty', label: { it: 'Empty', en: 'Empty' }, pattern: '', message: { en: 'Empty' } },
+          {
+            id: 'space',
+            label: { it: 'Space', en: 'Space' },
+            pattern: '   ',
+            message: { en: 'Space' },
+          },
+        ],
+      };
+      expect(checkPii('anything at all', configWithEmptyPattern, 'en')).toEqual(
+        { matched: false }
+      );
+    });
+
+    it('treats invalid regex as no match and does not throw', () => {
+      const warnSpy = jest.spyOn(console, 'warn').mockImplementation();
+      const configBadRegex = {
+        ...baseConfig,
+        rules: [
+          {
+            id: 'bad',
+            label: { it: 'Bad', en: 'Bad' },
+            pattern: '[unclosed',
+            message: { en: 'Bad' },
+          },
+        ],
+      };
+      expect(checkPii('test', configBadRegex, 'en')).toEqual({ matched: false });
+      expect(warnSpy).toHaveBeenCalledWith(
+        '[PII] Invalid regex for rule:',
+        'bad',
+        '[unclosed',
+        expect.any(Error)
+      );
+      warnSpy.mockRestore();
+    });
+  });
+
+  describe('single rule match', () => {
+    it('returns match and errorText when email pattern matches', () => {
+      const result = checkPii('contact me at test@example.com please', baseConfig, 'en');
+      expect(result.matched).toBe(true);
+      expect(result.errorText).toContain('Sensitive data.');
+      expect(result.errorText).toContain('Contains email.');
+      expect(result.errorText).not.toContain('Contains IBAN.');
+    });
+
+    it('returns match with Italian messages when lang is it', () => {
+      const result = checkPii('test@example.com', baseConfig, 'it');
+      expect(result.matched).toBe(true);
+      expect(result.errorText).toContain('Dati sensibili.');
+      expect(result.errorText).toContain('Contiene email.');
+    });
+
+    it('falls back to en when lang has no translation', () => {
+      const result = checkPii('test@example.com', baseConfig, 'fr');
+      expect(result.matched).toBe(true);
+      expect(result.errorText).toContain('Sensitive data.');
+      expect(result.errorText).toContain('Contains email.');
+    });
+
+    it('falls back to first available message when errorMessage has no en or requested lang', () => {
+      const configNoEn = {
+        ...baseConfig,
+        errorMessage: { it: 'Solo italiano' },
+      };
+      const result = checkPii('test@example.com', configNoEn, 'de');
+      expect(result.matched).toBe(true);
+      expect(result.errorText).toContain('Solo italiano');
+    });
+  });
+
+  describe('multiple rules and deduplication', () => {
+    it('returns match with both rule messages when text matches email and IBAN', () => {
+      const text = 'send to test@example.com and IT60X0542811101000000123456';
+      const result = checkPii(text, baseConfig, 'en');
+      expect(result.matched).toBe(true);
+      expect(result.errorText).toContain('Sensitive data.');
+      expect(result.errorText).toContain('Contains email.');
+      expect(result.errorText).toContain('Contains IBAN.');
+    });
+
+    it('deduplicates by rule id when multiple rules share same id', () => {
+      const configDupId = {
+        ...baseConfig,
+        rules: [
+          {
+            id: 'email',
+            label: { it: 'Email 1', en: 'Email 1' },
+            pattern: '\\b[A-Za-z0-9._%+\\-]+@[A-Za-z0-9.\\-]+\\.[A-Za-z]{2,}\\b',
+            message: { en: 'Email 1' },
+          },
+          {
+            id: 'email',
+            label: { it: 'Email 2', en: 'Email 2' },
+            pattern: '@',
+            message: { en: 'Email 2' },
+          },
+        ],
+      };
+      const result = checkPii('test@example.com', configDupId, 'en');
+      expect(result.matched).toBe(true);
+      const lines = result.errorText!.split('\n');
+      const emailLines = lines.filter(l => l.includes('Email'));
+      expect(emailLines.length).toBe(1);
+    });
+  });
+
+  describe('lang normalization', () => {
+    it('handles empty string lang with fallback to en', () => {
+      const result = checkPii('test@example.com', baseConfig, '');
+      expect(result.matched).toBe(true);
+      expect(result.errorText).toContain('Sensitive data.');
+    });
+
+    it('normalizes lang to lowercase for lookup', () => {
+      const result = checkPii('test@example.com', baseConfig, 'EN');
+      expect(result.matched).toBe(true);
+      expect(result.errorText).toContain('Sensitive data.');
+    });
+  });
+});

package/src/helpers/piiDetection.ts

@@ -0,0 +1,91 @@
+import type { PiiDetectionConfig, PiiDetectionRule } from '../types/layout';
+
+/**
+ * PII detection helper: runs regex rules on message text and returns whether any matched
+ * and the localized error text to show in the chat (as a system error bubble).
+ *
+ * Edge cases handled:
+ * - config disabled, null, or missing rules → no match
+ * - empty or non-array rules → no match
+ * - empty or whitespace-only regex pattern → skipped (avoid matching everything)
+ * - invalid regex (throws) → caught, treated as no match, console.warn
+ * - multiple rules with same id → deduplicated so message appears once
+ * - missing message/errorMessage for lang → fallback: lang → en → first value → default string
+ */
+
+/**
+ * Picks a localized string from a Record with fallback: lang -> 'en' -> first value -> fallback.
+ * Used for errorMessage and each rule's message so the bubble uses the chat-selected language.
+ */
+function getLocalized(
+  record: Record<string, string> | undefined,
+  lang: string,
+  fallback: string
+): string {
+  if (!record || typeof record !== 'object') return fallback;
+  const normalizedLang = lang?.toLowerCase() || 'en';
+  return (
+    record[normalizedLang] ??
+    record.en ??
+    record['en'] ??
+    Object.values(record)[0] ??
+    fallback
+  );
+}
+
+/**
+ * Runs PII detection on text: tests each rule's regex and returns matched rules and error text.
+ * - Deduplicates by rule.id so the same "kind" of PII doesn't appear twice in the message.
+ * - Invalid regexes are caught and treated as no match (with a console.warn).
+ *
+ * @param text - Full message text to check (including any attached document content).
+ * @param config - PII config from layout (enabled, rules, errorMessage).
+ * @param lang - Chat-selected language (e.g. userLang) for picking localized strings.
+ * @returns { matched: false } if no rule matches, or { matched: true, errorText } with the full error string to show.
+ */
+export function checkPii(
+  text: string,
+  config: PiiDetectionConfig,
+  lang: string
+): { matched: boolean; errorText?: string } {
+  if (!config?.enabled || !Array.isArray(config.rules) || config.rules.length === 0) {
+    return { matched: false };
+  }
+
+  const normalizedLang = lang?.toLowerCase() || 'en';
+  const matchedRulesById = new Map<string, PiiDetectionRule>();
+
+  for (const rule of config.rules) {
+    if (!rule.pattern || !rule.pattern.trim()) {
+      continue; // empty pattern would match everything; skip
+    }
+    try {
+      const regex = new RegExp(rule.pattern);
+      if (regex.test(text)) {
+        if (!matchedRulesById.has(rule.id)) {
+          matchedRulesById.set(rule.id, rule);
+        }
+      }
+    } catch (err) {
+      console.warn('[PII] Invalid regex for rule:', rule.id, rule.pattern, err);
+    }
+  }
+
+  if (matchedRulesById.size === 0) {
+    return { matched: false };
+  }
+
+  // Build one string: main errorMessage line + one line per matched rule (in selected language).
+  const mainMessage = getLocalized(
+    config.errorMessage,
+    normalizedLang,
+    'The message contains personal or sensitive data.'
+  );
+  const ruleMessages = Array.from(matchedRulesById.values()).map(rule => {
+    const labelFallback = getLocalized(rule.label, normalizedLang, rule.id);
+    return getLocalized(rule.message, normalizedLang, labelFallback);
+  });
+  const errorText = [mainMessage, ...ruleMessages].join('\n');
+
+  return { matched: true, errorText };
+}

package/src/index.stories.tsx

@@ -133,4 +133,57 @@ WithPrivateAgent.args = {
   showSettings: true,
   showShare: true,
   integrationID: '19f95abe-3493-4568-971d-14471480e5bc',
+};
+
+// PII detection: only via integration customData (layout as object with piiDetection). Try sending an email or IBAN to see the error bubble.
+const piiDetectionConfig = {
+  enabled: true,
+  rules: [
+    {
+      id: 'email',
+      label: { it: 'Email', en: 'Email' },
+      pattern: '\\b[A-Za-z0-9._%+\\-]+@[A-Za-z0-9.\\-]+\\.[A-Za-z]{2,}\\b',
+      message: {
+        it: 'Il messaggio contiene un indirizzo email.',
+        en: 'The message contains an email address.',
+      },
+    },
+    {
+      id: 'iban',
+      label: { it: 'IBAN', en: 'IBAN' },
+      pattern: '\\b[A-Z]{2}\\d{2}(?:[ ]?[A-Z0-9]{4}){3,7}(?:[ ]?[A-Z0-9]{1,4})?\\b',
+      message: {
+        it: 'Il messaggio contiene un codice IBAN.',
+        en: 'The message contains an IBAN code.',
+      },
+    },
+  ],
+  errorMessage: {
+    it: 'Il messaggio contiene dati personali o sensibili.',
+    en: 'The message contains personal or sensitive data.',
+  },
+};
+
+/** Story: PII detection via integration config only. Send a message containing an email (e.g. test@example.com) or IBAN to see the red error bubble. */
+export const WithPiiDetection = Template.bind({});
+WithPiiDetection.args = {
+  memoriName: 'Layout Storybook',
+  ownerUserName: 'andrea.patini',
+  memoriID: 'ae20fc5a-cc15-4db9-b7dd-2cd4a621b85e',
+  ownerUserID: '91dbc9ba-b684-4fbe-9828-b5980af6cda9',
+  tenantID: 'aisuru-staging.aclambda.online',
+  engineURL: 'https://engine-staging.memori.ai/memori/v2',
+  apiURL: 'https://backend-staging.memori.ai/api/v2',
+  uiLang: 'IT',
+  spokenLang: 'IT',
+  integration: {
+    integrationID: 'pii-demo',
+    customData: JSON.stringify({
+      layout: {
+        name: 'DEFAULT',
+        piiDetection: piiDetectionConfig,
+      },
+      lang: 'it',
+    }),
+  },
 };

package/src/index.tsx

@@ -383,7 +383,7 @@ const Memori: React.FC<Props> = ({
         enableAudio,
         defaultSpeakerActive,
         useMathFormatting,
-        memoriLang: spokenLang ?? memori?.culture?.split('-')?.[0],
+        memoriLang: uiLang ?? spokenLang ?? memori?.culture?.split('-')?.[0],
       };
 
   const [pulseSent, setPulseSent] = useState(false);

package/src/types/layout.ts

@@ -0,0 +1,50 @@
+/**
+ * Layout types and PII (Personally Identifiable Information) detection config.
+ * The widget's `layout` prop is always a string (LayoutName). PII is only configured
+ * via integration: integration.customData (JSON) can have layout as an object (LayoutProp).
+ */
+
+/** Layout name (string union used for layout selection across the app). */
+export type LayoutName =
+  | 'DEFAULT'
+  | 'FULLPAGE'
+  | 'TOTEM'
+  | 'CHAT'
+  | 'WEBSITE_ASSISTANT'
+  | 'HIDDEN_CHAT'
+  | 'ZOOMED_FULL_BODY';
+
+/**
+ * Single PII detection rule: one regex pattern and its localized violation message.
+ * - id: unique key (used to deduplicate when multiple rules share the same id).
+ * - label: localized human-readable name (e.g. { it: "Email", en: "Email" }).
+ * - pattern: regex string (e.g. "\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}\\b").
+ * - message: { [lang]: string } for the chat-selected language when multilingual is on (e.g. { it: "...", en: "..." }).
+ */
+export interface PiiDetectionRule {
+  id: string;
+  label: Record<string, string>;
+  pattern: string;
+  message: Record<string, string>;
+}
+
+/**
+ * PII detection config attached to the layout when enabled.
+ * - enabled: when true, messages are checked before sending.
+ * - rules: list of regex rules; if any matches, the message is blocked and an error is shown.
+ * - errorMessage: localized main line shown in the error bubble (e.g. "The message contains personal or sensitive data.").
+ */
+export interface PiiDetectionConfig {
+  enabled: boolean;
+  rules: PiiDetectionRule[];
+  errorMessage: Record<string, string>;
+}
+
+/**
+ * Layout as object: only used inside integration customData (not as the layout prop).
+ * When customData.layout is this shape and piiDetection.enabled is true, the widget
+ * runs PII checks before sending and shows an error bubble if any rule matches.
+ */
+export type LayoutProp =
+  | LayoutName
+  | { name: LayoutName; piiDetection?: PiiDetectionConfig };

package/src/version.ts

@@ -1,2 +1,2 @@
 // This file is auto-generated. Do not edit manually.
-export const version = '8.19.3';
+export const version = '8.21.0';