@siemens/element-ng 48.2.0 → 48.4.0

package/schematics/migrations/data/symbol-removals.js

@@ -0,0 +1,49 @@
+export const SYMBOL_REMOVALS_MIGRATION = [
+    {
+        module: /@(siemens|simpl)\/element-ng(\/accordion)?/,
+        elementSelector: 'si-accordion',
+        names: ['colorVariant']
+    },
+    {
+        module: /@(siemens|simpl)\/element-ng(\/datepicker)?/,
+        elementSelector: 'input',
+        attributeSelector: 'siDateInput',
+        names: ['dateInputDebounceTime']
+    },
+    {
+        module: /@(siemens|simpl)\/element-ng(\/datepicker)?/,
+        elementSelector: 'input',
+        attributeSelector: 'siDatepicker',
+        names: ['triggeringInput']
+    },
+    {
+        module: /@(siemens|simpl)\/element-ng(\/datepicker)?/,
+        elementSelector: 'si-date-range',
+        names: ['debounceTime']
+    },
+    {
+        module: /@(siemens|simpl)\/element-ng(\/filtered-search)?/,
+        elementSelector: 'si-filtered-search',
+        names: ['showIcon', 'noMatchingCriteriaText']
+    },
+    {
+        module: /@(siemens|simpl)\/element-ng(\/form)?/,
+        elementSelector: 'si-form-item',
+        names: ['inputId', 'readonly']
+    },
+    {
+        module: /@(siemens|simpl)\/element-ng(\/navbar-vertical)?/,
+        elementSelector: 'si-navbar-vertical',
+        names: ['autoCollapseDelay']
+    },
+    {
+        module: /@(siemens|simpl)\/element-ng(\/split)?/,
+        elementSelector: 'si-split-part',
+        names: ['headerStatusColor', 'headerStatusIconClass']
+    },
+    {
+        module: /@(siemens|simpl)\/element-ng(\/navbar-vertical)?/,
+        elementSelector: 'si-tree-view',
+        names: ['disableFilledIcons', 'trackByFunction']
+    }
+];

package/schematics/migrations/element-migration/element-migration.js

@@ -0,0 +1,93 @@
+/**
+ * Copyright (c) Siemens 2016 - 2025
+ * SPDX-License-Identifier: MIT
+ */
+import * as ts from 'typescript';
+import { EmitHint } from 'typescript';
+import { discoverSourceFiles, renameApi, renameAttribute, renameElementTag, renameIdentifier, removeSymbol } from '../../utils/index.js';
+import { getElementMigrationData } from '../data/index.js';
+export const elementMigrationRule = (options) => {
+    return async (tree, context) => {
+        const tsSourceFiles = await discoverSourceFiles(tree, context, options.path);
+        const migrationData = getElementMigrationData();
+        for (const filePath of tsSourceFiles) {
+            const content = tree.read(filePath);
+            if (!content) {
+                continue;
+            }
+            const sourceFile = ts.createSourceFile(filePath, content.toString(), ts.ScriptTarget.Latest, true);
+            let recorder = undefined;
+            let printer = undefined;
+            // Remove the ifs when it grows a bit more and split into multiple functions
+            if (migrationData.componentNameChanges) {
+                const changeInstructions = renameIdentifier({
+                    sourceFile,
+                    renamingInstructions: migrationData.componentNameChanges
+                });
+                for (const changeInstruction of changeInstructions) {
+                    recorder ??= tree.beginUpdate(filePath);
+                    printer ??= ts.createPrinter();
+                    recorder.remove(changeInstruction.start, changeInstruction.width);
+                    recorder.insertLeft(changeInstruction.start, printer.printNode(EmitHint.Unspecified, changeInstruction.newNode, sourceFile));
+                }
+            }
+            if (migrationData.attributeSelectorChanges) {
+                recorder ??= tree.beginUpdate(filePath);
+                for (const change of migrationData.attributeSelectorChanges) {
+                    renameAttribute({
+                        tree,
+                        recorder,
+                        sourceFile,
+                        filePath,
+                        fromName: change.replace,
+                        toName: change.replaceWith
+                    });
+                }
+            }
+            if (migrationData.elementSelectorChanges) {
+                recorder ??= tree.beginUpdate(filePath);
+                for (const change of migrationData.elementSelectorChanges) {
+                    renameElementTag({
+                        tree,
+                        recorder,
+                        sourceFile,
+                        filePath,
+                        fromName: change.replace,
+                        toName: change.replaceWith
+                    });
+                }
+            }
+            if (migrationData.outputNameChanges) {
+                recorder ??= tree.beginUpdate(filePath);
+                for (const change of migrationData.outputNameChanges) {
+                    renameApi({
+                        tree,
+                        recorder,
+                        sourceFile,
+                        filePath,
+                        elementName: change.elementSelector,
+                        apis: change.apiMappings
+                    });
+                }
+            }
+            if (migrationData.symbolRemovalChanges) {
+                recorder ??= tree.beginUpdate(filePath);
+                for (const change of migrationData.symbolRemovalChanges) {
+                    removeSymbol({
+                        tree,
+                        recorder,
+                        sourceFile,
+                        filePath,
+                        elementName: change.elementSelector,
+                        attributeSelector: change.attributeSelector,
+                        names: change.names
+                    });
+                }
+            }
+            if (recorder) {
+                tree.commitUpdate(recorder);
+            }
+        }
+        return tree;
+    };
+};

package/schematics/migrations/element-migration/index.js

@@ -0,0 +1,5 @@
+/**
+ * Copyright (c) Siemens 2016 - 2025
+ * SPDX-License-Identifier: MIT
+ */
+export * from './element-migration.js';

package/schematics/migrations/index.js

@@ -4,10 +4,15 @@
  */
 import { chain } from '@angular-devkit/schematics';
 import { actionModalMigrationRule } from './action-modal-migration/index.js';
-import { toLegacyMigrationRule } from './to-legacy-migration/to-legacy-migration';
+import { elementMigrationRule } from './element-migration/index.js';
+import { wizardMigrationRule } from './wizard-migration/index.js';
 export const v47to48Migration = (options) => {
     return (tree, context) => {
         context.logger.info('🚀 Starting migration from v47 to v48...');
-        return chain([actionModalMigrationRule(options), toLegacyMigrationRule(options)])(tree, context);
+        return chain([
+            actionModalMigrationRule(options),
+            elementMigrationRule(options),
+            wizardMigrationRule(options)
+        ])(tree, context);
     };
 };

package/schematics/migrations/wizard-migration/index.js

@@ -0,0 +1,80 @@
+/**
+ * Copyright (c) Siemens 2016 - 2025
+ * SPDX-License-Identifier: MIT
+ */
+import { join, dirname } from 'path';
+import * as ts from 'typescript';
+import { discoverSourceFiles, findElement, getInlineTemplates, getTemplateUrl } from '../../utils/index.js';
+export const wizardMigrationRule = (options) => {
+    return async (tree, context) => {
+        context.logger.info('🔄 Migrating wizard api...');
+        const tsSourceFiles = await discoverSourceFiles(tree, context, options.path);
+        for (const filePath of tsSourceFiles) {
+            const content = tree.read(filePath);
+            if (!content) {
+                continue;
+            }
+            const sourceFile = ts.createSourceFile(filePath, content.toString(), ts.ScriptTarget.Latest, true);
+            const recorder = tree.beginUpdate(filePath);
+            renameApi({
+                tree,
+                filePath,
+                sourceFile,
+                recorder,
+                elementName: 'si-wizard'
+            });
+            if (recorder) {
+                tree.commitUpdate(recorder);
+            }
+        }
+    };
+};
+const renameApi = ({ tree, filePath, sourceFile, recorder, elementName }) => {
+    getInlineTemplates(sourceFile).forEach(template => addOrRemoveInlineNavigationAttribute({
+        template: template.text,
+        offset: template.getStart() + 1,
+        elementName,
+        recorder
+    }));
+    getTemplateUrl(sourceFile).forEach(templateUrl => {
+        const templatePath = join(dirname(filePath), templateUrl);
+        const templateContent = tree.read(templatePath).toString('utf-8');
+        const templateRecorder = tree.beginUpdate(templatePath);
+        addOrRemoveInlineNavigationAttribute({
+            template: templateContent,
+            offset: 0,
+            elementName,
+            recorder: templateRecorder
+        });
+        tree.commitUpdate(templateRecorder);
+    });
+};
+/**
+ * Migrates the inlineNavigation attribute on wizard elements.
+ * - Adds `inlineNavigation` when not present (new default: true)
+ * - Removes `[inlineNavigation]="false"` (false is now the default)
+ * - Keeps `[inlineNavigation]="true"` and dynamic bindings unchanged
+ */
+const addOrRemoveInlineNavigationAttribute = ({ template, offset, recorder, elementName }) => {
+    const elements = findElement(template, element => element.name === elementName);
+    for (const element of elements) {
+        const inlineNavigationAttr = element.attrs.find(attr => attr.name === '[inlineNavigation]' || attr.name === 'inlineNavigation');
+        if (!inlineNavigationAttr) {
+            // No attribute exists → Add default inlineNavigation
+            const insertPosition = element.startSourceSpan.end.offset + offset - 1;
+            recorder.insertLeft(insertPosition, ' inlineNavigation');
+        }
+        else if ((inlineNavigationAttr.name === '[inlineNavigation]' ||
+            inlineNavigationAttr.name === 'inlineNavigation') &&
+            inlineNavigationAttr.value === 'false') {
+            const { start, end } = inlineNavigationAttr.sourceSpan;
+            const length = end.offset - start.offset;
+            recorder.remove(start.offset + offset, length);
+            // Also remove extra whitespace if present
+            const nextChar = template.charAt(end.offset);
+            if (nextChar === ' ') {
+                recorder.remove(end.offset + offset, 1);
+            }
+        }
+    }
+};

package/schematics/scss-import-to-siemens-migration/index.js

@@ -26,10 +26,10 @@ export const scssImportMigration = (_options) => {
  * ```
  */
 export const scssMigrationRule = (_options) => {
-    return (tree, context) => {
+    return async (tree, context) => {
         const rules = [];
         context.logger.info('🎨 Migrating SCSS styles...');
-        const globalStyles = getGlobalStyles(tree);
+        const globalStyles = await getGlobalStyles(tree);
         for (const style of globalStyles) {
             if (style.endsWith('.scss') || style.endsWith('.sass')) {
                 const content = tree.readText(style);
@@ -51,7 +51,7 @@ export const scssMigrationRule = (_options) => {
                 }
             }
         }
-        const scssFiles = discoverSourceFiles(tree, context, _options.path, '.scss');
+        const scssFiles = await discoverSourceFiles(tree, context, _options.path, '.scss');
         for (const filePath of scssFiles) {
             const content = tree.readText(filePath);
             if (content.includes(STYLE_REPLACEMENTS[0].replace) ||

package/schematics/ts-import-to-siemens-migration/index.js

@@ -27,10 +27,10 @@ export const tsImportMigration = (_options) => {
  * ```
  */
 export const tsImportMigrationRule = (_options) => {
-    return (tree, context) => {
+    return async (tree, context) => {
         const rules = [];
         context.logger.info('📦 Migrating TypeScript imports...');
-        const sourceFiles = discoverSourceFiles(tree, context, _options.path);
+        const sourceFiles = await discoverSourceFiles(tree, context, _options.path);
         for (const filePath of sourceFiles) {
             const migrations = collectMigrationImports(filePath, tree, context);
             const { imports, toRemoveImports } = migrations;

package/schematics/utils/index.js

@@ -2,9 +2,9 @@
  * Copyright (c) Siemens 2016 - 2025
  * SPDX-License-Identifier: MIT
  */
+export * from './html-utils.js';
 export * from './project-utils.js';
-export * from './ts-utils.js';
-export * from './testing.js';
 export * from './schematics-file-system.js';
-export * from './html-utils.js';
 export * from './template-utils.js';
+export * from './testing.js';
+export * from './ts-utils.js';

package/schematics/utils/project-utils.js

@@ -4,44 +4,46 @@
  */
 import { normalize } from '@angular-devkit/core';
 import { SchematicsException } from '@angular-devkit/schematics';
+import { allTargetOptions, allWorkspaceTargets, getWorkspace } from '@schematics/angular/utility/workspace';
 import { dirname, isAbsolute, resolve } from 'path';
 import { parseTsconfigFile } from './ts-utils.js';
-export const getGlobalStyles = (tree) => {
+export const getGlobalStyles = async (tree) => {
     const globalStyles = new Set();
-    for (const target of getTargets(getWorkspace(tree))) {
-        if (target.options?.styles && Array.isArray(target.options.styles)) {
-            target.options.styles.forEach((style) => {
-                if (typeof style === 'string') {
-                    globalStyles.add(normalize(style));
+    for (const [name, target] of allWorkspaceTargets(await getWorkspace(tree))) {
+        if (['build', 'test'].includes(name)) {
+            for (const [, opt] of allTargetOptions(target)) {
+                if (opt.styles && Array.isArray(opt.styles)) {
+                    opt.styles.forEach((style) => {
+                        if (typeof style === 'string') {
+                            globalStyles.add(normalize(style));
+                        }
+                    });
                 }
-            });
+            }
         }
     }
     return [...globalStyles];
 };
-export const getWorkspace = (tree) => {
-    const workspace = tree.read('/angular.json');
-    if (!workspace) {
-        throw new SchematicsException('Could not find angular.json');
-    }
-    return JSON.parse(workspace.toString());
-};
-export const getTsConfigPaths = (tree) => {
+export const getTsConfigPaths = async (tree) => {
     const buildPaths = new Set();
-    for (const target of getTargets(getWorkspace(tree))) {
-        if (target.options?.tsConfig && typeof target.options.tsConfig === 'string') {
-            const tsConfig = target.options.tsConfig;
-            if (tree.exists(tsConfig)) {
-                buildPaths.add(normalize(tsConfig));
+    for (const [name, target] of allWorkspaceTargets(await getWorkspace(tree))) {
+        if (['build', 'test'].includes(name)) {
+            for (const [, opt] of allTargetOptions(target)) {
+                if (typeof opt?.tsConfig === 'string') {
+                    const tsConfig = opt.tsConfig;
+                    if (tree.exists(tsConfig)) {
+                        buildPaths.add(normalize(tsConfig));
+                    }
+                }
             }
         }
     }
     return [...buildPaths];
 };
-export const discoverSourceFiles = (tree, context, projectPath, extension = '.ts') => {
+export const discoverSourceFiles = async (tree, context, projectPath, extension = '.ts') => {
     const basePath = normalize(process.cwd());
     // Wrap the tree to force full paths since parsing the typescript config requires full paths.
-    const tsConfigs = getTsConfigPaths(tree);
+    const tsConfigs = await getTsConfigPaths(tree);
     if (!tsConfigs.length) {
         throw new SchematicsException('Could not find any tsconfig file. Cannot run the migration.');
     }
@@ -60,16 +62,3 @@ export const discoverSourceFiles = (tree, context, projectPath, extension = '.ts
     }
     return Array.from(new Set(sourceFiles)).map(p => p.substring(basePath.length + 1));
 };
-function* getTargets(workspace, targetNames = ['build', 'test']) {
-    for (const [, projectRaw] of Object.entries(workspace.projects)) {
-        const project = projectRaw;
-        if (!project.architect) {
-            continue;
-        }
-        for (const [name, target] of Object.entries(project.architect)) {
-            if (targetNames.includes(name) && target) {
-                yield target;
-            }
-        }
-    }
-}

package/schematics/utils/template-utils.js

@@ -1,7 +1,7 @@
 import { join, dirname } from 'path';
 import ts from 'typescript';
 import { findAttribute, findElement } from './html-utils.js';
-const getInlineTemplates = (source) => {
+export const getInlineTemplates = (source) => {
     const templateNodes = [];
     const componentDecoratorVisitor = (node) => {
         if (ts.isDecorator(node) &&
@@ -27,7 +27,7 @@ const getInlineTemplates = (source) => {
     source.forEachChild(componentDecoratorVisitor);
     return templateNodes;
 };
-const getTemplateUrl = (source) => {
+export const getTemplateUrl = (source) => {
     const templateUrls = [];
     const componentDecoratorVisitor = (node) => {
         if (ts.isDecorator(node) &&
@@ -68,6 +68,36 @@ const renameAttributeInTemplate = ({ template, offset, recorder, fromName, toNam
         recorder.insertLeft(el.sourceSpan.start.offset + offset, toName);
     });
 };
+const renameApiInTemplate = ({ template, offset, recorder, elementName, apis }) => {
+    findElement(template, element => element.name === elementName).forEach(el => {
+        for (const api of apis) {
+            el.attrs
+                .filter(attr => attr.name === api.replace)
+                .forEach(attr => {
+                recorder.remove(attr.sourceSpan.start.offset + offset, api.replace.length);
+                recorder.insertLeft(attr.sourceSpan.start.offset + offset, api.replaceWith);
+            });
+        }
+    });
+};
+const removeSymbols = ({ template, offset, recorder, elementName, attributeSelector, names }) => {
+    findElement(template, element => element.name === elementName).forEach(el => {
+        if (attributeSelector) {
+            const hasAttributeSelector = el.attrs.some(attr => attr.name === attributeSelector);
+            if (!hasAttributeSelector) {
+                return;
+            }
+        }
+        for (const name of names) {
+            el.attrs
+                .filter(attr => attr.name === name || attr.name === `[${name}]` || attr.name === `(${name})`)
+                .forEach(attr => {
+                const apiLength = attr.sourceSpan.toString().length;
+                recorder.remove(attr.sourceSpan.start.offset + offset, apiLength);
+            });
+        }
+    });
+};
 export const renameElementTag = ({ tree, filePath, sourceFile, recorder, fromName, toName }) => {
     getInlineTemplates(sourceFile).forEach(template => renameElementTagInTemplate({
         template: template.text,
@@ -112,3 +142,49 @@ export const renameAttribute = ({ tree, filePath, sourceFile, recorder, fromName
         tree.commitUpdate(templateRecorder);
     });
 };
+export const renameApi = ({ tree, filePath, sourceFile, recorder, elementName, apis }) => {
+    getInlineTemplates(sourceFile).forEach(template => renameApiInTemplate({
+        template: template.text,
+        offset: template.getStart() + 1,
+        elementName,
+        recorder,
+        apis
+    }));
+    getTemplateUrl(sourceFile).forEach(templateUrl => {
+        const templatePath = join(dirname(filePath), templateUrl);
+        const templateContent = tree.read(templatePath).toString('utf-8');
+        const templateRecorder = tree.beginUpdate(templatePath);
+        renameApiInTemplate({
+            template: templateContent,
+            offset: 0,
+            elementName,
+            recorder: templateRecorder,
+            apis
+        });
+        tree.commitUpdate(templateRecorder);
+    });
+};
+export const removeSymbol = ({ tree, filePath, sourceFile, recorder, elementName, attributeSelector, names }) => {
+    getInlineTemplates(sourceFile).forEach(template => removeSymbols({
+        template: template.text,
+        offset: template.getStart() + 1,
+        elementName,
+        attributeSelector,
+        recorder,
+        names
+    }));
+    getTemplateUrl(sourceFile).forEach(templateUrl => {
+        const templatePath = join(dirname(filePath), templateUrl);
+        const templateContent = tree.read(templatePath).toString('utf-8');
+        const templateRecorder = tree.beginUpdate(templatePath);
+        removeSymbols({
+            template: templateContent,
+            offset: 0,
+            elementName,
+            attributeSelector,
+            recorder: templateRecorder,
+            names
+        });
+        tree.commitUpdate(templateRecorder);
+    });
+};

package/schematics/utils/ts-utils.js

@@ -150,15 +150,15 @@ export function* renameIdentifier({ sourceFile, renamingInstructions }) {
             if (!(node.importClause?.namedBindings && ts.isNamedImports(node.importClause.namedBindings))) {
                 continue;
             }
-            for (const [index, [fromName, toName]] of renamingInstruction.symbolRenamings.entries()) {
-                const importSpecifiers = findImportSpecifier(node.importClause.namedBindings.elements, fromName);
+            for (const [index, { replace, replaceWith }] of renamingInstruction.symbolRenamings.entries()) {
+                const importSpecifiers = findImportSpecifier(node.importClause.namedBindings.elements, replace);
                 if (!importSpecifiers) {
                     continue;
                 }
                 yield {
                     start: importSpecifiers.name.getStart(),
                     width: importSpecifiers.name.getWidth(),
-                    newNode: ts.factory.createIdentifier(toName)
+                    newNode: ts.factory.createIdentifier(replaceWith)
                 };
                 if (renamingInstruction.toModule &&
                     !node.moduleSpecifier.text.endsWith('@simpl/element-ng') &&
@@ -171,11 +171,11 @@ export function* renameIdentifier({ sourceFile, renamingInstructions }) {
                     };
                 }
                 const visitor = function* (visitedNode) {
-                    if (ts.isIdentifier(visitedNode) && visitedNode.text === fromName) {
+                    if (ts.isIdentifier(visitedNode) && visitedNode.text === replace) {
                         yield {
                             start: visitedNode.getStart(),
                             width: visitedNode.getWidth(),
-                            newNode: ts.factory.createIdentifier(toName)
+                            newNode: ts.factory.createIdentifier(replaceWith)
                         };
                     }
                     else {

package/select/index.d.ts

@@ -561,6 +561,11 @@ declare class SiSelectActionDirective {
 }
 
 declare class SiSelectActionsDirective {
+    /** @internal */
+    static ngTemplateContextGuard(directive: SiSelectActionsDirective, context: unknown): context is {
+        searchText?: string;
+        visibleOptionsCount?: number;
+    };
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiSelectActionsDirective, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SiSelectActionsDirective, "[siSelectActions]", ["si-select-actions"], {}, {}, never, never, true, never>;
 }

package/status-bar/index.d.ts

@@ -137,7 +137,6 @@ declare class SiStatusBarComponent implements DoCheck, OnDestroy, OnChanges {
     private readonly translateService;
     private readonly resizeObserver;
     private readonly measureService;
-    private readonly destroyRef;
     constructor();
     ngOnChanges(changes: SimpleChanges): void;
     ngDoCheck(): void;

package/template-i18n.json

@@ -1,8 +1,10 @@
 {
+  "SI_AI_MESSAGE.SECONDARY_ACTIONS": "More actions",
   "SI_ALERT_DIALOG.OK": "OK",
   "SI_APPLICATION_HEADER.LAUNCHPAD": "Launchpad",
   "SI_APPLICATION_HEADER.TOGGLE_ACTIONS": "Toggle actions",
   "SI_APPLICATION_HEADER.TOGGLE_NAVIGATION": "Toggle navigation",
+  "SI_ATTACHMENT_LIST.REMOVE_ATTACHMENT": "Remove attachment",
   "SI_BREADCRUMB": "Breadcrumbs",
   "SI_CHANGE_PASSWORD.BACK": "Back",
   "SI_CHANGE_PASSWORD.CHANGE": "Change",
@@ -11,6 +13,12 @@
   "SI_CHANGE_PASSWORD.CONFIRM_PASSWORD": "Confirm password",
   "SI_CHANGE_PASSWORD.NEW_PASSWORD": "New password",
   "SI_CHANGE_PASSWORD.PASSWORD_POLICY": "Password policy",
+  "SI_CHAT_INPUT.ATTACH_FILE": "Attach file",
+  "SI_CHAT_INPUT.INTERRUPT": "Interrupt",
+  "SI_CHAT_INPUT.LABEL": "Chat message input",
+  "SI_CHAT_INPUT.PLACEHOLDER": "Enter a message…",
+  "SI_CHAT_INPUT.SECONDARY_ACTIONS": "More actions",
+  "SI_CHAT_INPUT.SEND": "Send",
   "SI_COLUMN_SELECTION_DIALOG.CANCEL": "Cancel",
   "SI_COLUMN_SELECTION_DIALOG.HIDDEN": "Hidden",
   "SI_COLUMN_SELECTION_DIALOG.ITEM_MOVED": "Item is now at position {{targetPosition}}",
@@ -41,6 +49,7 @@
   "SI_DATEPICKER.SECONDS": "Seconds",
   "SI_DATEPICKER.START_DATE_PLACEHOLDER": "Start date",
   "SI_DATEPICKER.START_TIME_LABEL": "from",
+  "SI_DATEPICKER.TODAY": "Today",
   "SI_DATE_RANGE_FILTER.ADVANCED": "Advanced",
   "SI_DATE_RANGE_FILTER.AFTER": "After",
   "SI_DATE_RANGE_FILTER.APPLY": "Apply",
@@ -207,6 +216,7 @@
   "SI_TREE_VIEW.COLLAPSE_ALL": "Collapse all",
   "SI_TREE_VIEW.EXPAND_ALL": "Expand all",
   "SI_TYPEAHEAD.AUTOCOMPLETE_LIST_LABEL": "Suggestions",
+  "SI_USER_MESSAGE.SECONDARY_ACTIONS": "More actions",
   "SI_WIZARD.BACK": "Back",
   "SI_WIZARD.CANCEL": "Cancel",
   "SI_WIZARD.COMPLETED": "Wizard completed!",

package/tour/index.d.ts

@@ -104,10 +104,12 @@ declare class SiTourService {
     private makeStep;
     private scrollIntoView;
     private handleBeforeNextPromise;
-    private makeOverlay;
+    private centerOverlay;
+    private attachOverlay;
+    private createFlexiblePositionStrategy;
+    private createOrUpdateOverlays;
     private handleResizeSubscription;
     private isElementVisible;
-    private handlePositionChangeSubscription;
     private getElement;
     private hide;
     static ɵfac: i0.ɵɵFactoryDeclaration<SiTourService, never>;

package/translate/index.d.ts

@@ -2,10 +2,12 @@ import { Provider } from '@angular/core';
 export * from '@siemens/element-translate-ng/translate';
 
 interface SiTranslatableKeys {
+    'SI_AI_MESSAGE.SECONDARY_ACTIONS'?: string;
     'SI_ALERT_DIALOG.OK'?: string;
     'SI_APPLICATION_HEADER.LAUNCHPAD'?: string;
     'SI_APPLICATION_HEADER.TOGGLE_ACTIONS'?: string;
     'SI_APPLICATION_HEADER.TOGGLE_NAVIGATION'?: string;
+    'SI_ATTACHMENT_LIST.REMOVE_ATTACHMENT'?: string;
     'SI_BREADCRUMB'?: string;
     'SI_CHANGE_PASSWORD.BACK'?: string;
     'SI_CHANGE_PASSWORD.CHANGE'?: string;
@@ -14,6 +16,12 @@ interface SiTranslatableKeys {
     'SI_CHANGE_PASSWORD.CONFIRM_PASSWORD'?: string;
     'SI_CHANGE_PASSWORD.NEW_PASSWORD'?: string;
     'SI_CHANGE_PASSWORD.PASSWORD_POLICY'?: string;
+    'SI_CHAT_INPUT.ATTACH_FILE'?: string;
+    'SI_CHAT_INPUT.INTERRUPT'?: string;
+    'SI_CHAT_INPUT.LABEL'?: string;
+    'SI_CHAT_INPUT.PLACEHOLDER'?: string;
+    'SI_CHAT_INPUT.SECONDARY_ACTIONS'?: string;
+    'SI_CHAT_INPUT.SEND'?: string;
     'SI_COLUMN_SELECTION_DIALOG.CANCEL'?: string;
     'SI_COLUMN_SELECTION_DIALOG.HIDDEN'?: string;
     'SI_COLUMN_SELECTION_DIALOG.ITEM_MOVED'?: string;
@@ -44,6 +52,7 @@ interface SiTranslatableKeys {
     'SI_DATEPICKER.SECONDS'?: string;
     'SI_DATEPICKER.START_DATE_PLACEHOLDER'?: string;
     'SI_DATEPICKER.START_TIME_LABEL'?: string;
+    'SI_DATEPICKER.TODAY'?: string;
     'SI_DATE_RANGE_FILTER.ADVANCED'?: string;
     'SI_DATE_RANGE_FILTER.AFTER'?: string;
     'SI_DATE_RANGE_FILTER.APPLY'?: string;
@@ -210,6 +219,7 @@ interface SiTranslatableKeys {
     'SI_TREE_VIEW.COLLAPSE_ALL'?: string;
     'SI_TREE_VIEW.EXPAND_ALL'?: string;
     'SI_TYPEAHEAD.AUTOCOMPLETE_LIST_LABEL'?: string;
+    'SI_USER_MESSAGE.SECONDARY_ACTIONS'?: string;
     'SI_WIZARD.BACK'?: string;
     'SI_WIZARD.CANCEL'?: string;
     'SI_WIZARD.COMPLETED'?: string;