@siemens/element-ng 49.16.0 → 51.0.0-rc.10

package/types/siemens-element-ng-maplibre.d.ts

@@ -0,0 +1,190 @@
+import { ExtendedStatusType } from '@siemens/element-ng/common';
+import * as _angular_core from '@angular/core';
+import { Signal } from '@angular/core';
+import { StyleSpecification } from 'maplibre-gl';
+import * as geojson from 'geojson';
+
+/**
+ * Copyright (c) Siemens 2016 - 2026
+ * SPDX-License-Identifier: MIT
+ */
+/** A point feature consumed by the clustered MapLibre source. */
+type ClusterPoint = GeoJSON.Feature<GeoJSON.Point, GeoJSON.GeoJsonProperties>;
+/**
+ * Built-in group palette or exact colors indexed by positive group ID. The `'status'` palette is
+ * the four-color palette used for numeric groups; it is separate from status-based bucketing.
+ */
+type ClusterColors = 'status' | 'element' | Record<number, string>;
+/** A rendered color segment and its generated cluster-property name. */
+interface ClusterSegment {
+    color: string;
+    property: string;
+}
+
+/**
+ * Copyright (c) Siemens 2016 - 2026
+ * SPDX-License-Identifier: MIT
+ */
+
+/** Status values supported by status markers and cluster status segments. */
+type MarkerStatus = ExtendedStatusType | 'default';
+
+/**
+ * Copyright (c) Siemens 2016 - 2026
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * Creates a signal that returns a {@link StyleSpecification} for MapLibre GL based on the current
+ * Element theme. The signal automatically updates when the theme switches between light and dark.
+ *
+ * @remarks
+ * **Must be called in an Angular injection context** (e.g. inside a constructor, field initializer,
+ * or a function called from one). Calling this function outside of an injection context will throw
+ * an `assertInInjectionContext` error.
+ *
+ * @experimental
+ *
+ * @param key - The MapTiler API key used to fetch tiles, glyphs, and sprites
+ * @returns A signal that provides the current {@link StyleSpecification} based on the active theme
+ * @throws When called outside of an Angular injection context
+ */
+declare const injectSiMapStyle: (key: string) => Signal<StyleSpecification>;
+
+/**
+ * Copyright (c) Siemens 2016 - 2026
+ * SPDX-License-Identifier: MIT
+ */
+
+type ClusterProperties = Record<string, ['+', unknown]>;
+/** @internal */
+interface ClusterConfiguration {
+    clusterProperties: ClusterProperties;
+    segments: readonly ClusterSegment[];
+}
+
+/**
+ * Adds a clustered GeoJSON source to a MapLibre map and renders interactive cluster markers.
+ *
+ * Cluster markers display the number of contained points and their distribution by group. Status
+ * segments can be enabled for ungrouped points by providing `statusProperty`. Render individual,
+ * unclustered points separately with `mgl-markers-for-clusters` using the same source ID.
+ * Positive numeric groups always take precedence over status segments. Status segments apply only
+ * when the normalized group value is zero; points without a matching group or status use the
+ * ungrouped color.
+ *
+ * @example Basic usage
+ * ```html
+ * <mgl-map [mapStyle]="mapStyle()">
+ *   <si-cluster-source
+ *     sourceId="locations"
+ *     statusProperty="status"
+ *     [data]="locations"
+ *     (clusterClick)="onClusterClick($event)"
+ *   />
+ *
+ *   <mgl-markers-for-clusters source="locations">
+ *     <ng-template let-feature mglPoint>
+ *       <si-status-marker
+ *         [status]="feature.properties?.status"
+ *       />
+ *     </ng-template>
+ *   </mgl-markers-for-clusters>
+ * </mgl-map>
+ * ```
+ *
+ * @experimental
+ */
+declare class SiClusterSourceComponent {
+    /** ID used to register the generated GeoJSON source in MapLibre. */
+    readonly sourceId: _angular_core.InputSignal<string>;
+    /**
+     * Point feature collection to cluster.
+     * @defaultValue EMPTY_DATA
+     */
+    readonly data: _angular_core.InputSignal<geojson.FeatureCollection<geojson.Point, geojson.GeoJsonProperties>>;
+    /**
+     * Feature property containing the positive numeric group ID.
+     * @defaultValue 'group'
+     */
+    readonly groupProperty: _angular_core.InputSignal<string>;
+    /**
+     * Built-in palette or exact colors indexed by group ID. The built-in `'status'` palette contains
+     * four colors for numeric groups and is separate from status-based bucketing.
+     * @defaultValue 'status'
+     */
+    readonly groupColors: _angular_core.InputSignal<ClusterColors>;
+    /**
+     * Top-level feature property containing a {@link MarkerStatus} value. Status bucketing is
+     * disabled by default and only applies when the normalized group value is zero. Missing or
+     * unsupported status values, and groups that do not match a configured bucket, use the ungrouped
+     * color. Built-in colors match `SiStatusMarkerComponent`, with `default` using accent and
+     * `unknown` using neutral.
+     * @defaultValue undefined
+     * @see https://maplibre.org/maplibre-style-spec/sources/#clusterproperties
+     */
+    readonly statusProperty: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Cluster radius in pixels.
+     * @defaultValue 50
+     */
+    readonly clusterRadius: _angular_core.InputSignal<number>;
+    /**
+     * Maximum zoom at which points are clustered.
+     * @defaultValue undefined
+     */
+    readonly clusterMaxZoom: _angular_core.InputSignal<number | undefined>;
+    /**
+     * Minimum number of points required to form a cluster.
+     * @defaultValue 2
+     */
+    readonly clusterMinPoints: _angular_core.InputSignal<number>;
+    /** Emits when a cluster marker is activated. */
+    readonly clusterClick: _angular_core.OutputEmitterRef<ClusterPoint>;
+    protected readonly clusterConfiguration: _angular_core.Signal<ClusterConfiguration>;
+    /** Stores selection for the projected cluster-popover integration. */
+    protected readonly selectedCluster: _angular_core.WritableSignal<ClusterPoint | undefined>;
+    protected selectCluster(feature: ClusterPoint): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiClusterSourceComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SiClusterSourceComponent, "si-cluster-source", never, { "sourceId": { "alias": "sourceId"; "required": true; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "groupProperty": { "alias": "groupProperty"; "required": false; "isSignal": true; }; "groupColors": { "alias": "groupColors"; "required": false; "isSignal": true; }; "statusProperty": { "alias": "statusProperty"; "required": false; "isSignal": true; }; "clusterRadius": { "alias": "clusterRadius"; "required": false; "isSignal": true; }; "clusterMaxZoom": { "alias": "clusterMaxZoom"; "required": false; "isSignal": true; }; "clusterMinPoints": { "alias": "clusterMinPoints"; "required": false; "isSignal": true; }; }, { "clusterClick": "clusterClick"; }, never, ["si-cluster-popover,[siClusterPopoverOutlet]"], true, never>;
+}
+
+/**
+ * Copyright (c) Siemens 2016 - 2026
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * Provides translated MapLibre locale strings as an Angular signal. The record uses MapLibre's
+ * original locale keys, such as `AttributionControl.ToggleAttribution`, and updates when the
+ * active Element language changes.
+ *
+ * @example
+ * ```ts
+ * @Component({ ... })
+ * export class MapComponent {
+ *   protected readonly mapTranslations = injectSiMapTranslations();
+ * }
+ * ```
+ *
+ * ```html
+ * <mgl-map [locale]="mapTranslations()" />
+ * ```
+ *
+ * @returns A signal containing a MapLibre locale record, for example
+ * `{ 'AttributionControl.ToggleAttribution': 'Toggle attribution' }`.
+ */
+declare const injectSiMapTranslations: () => Signal<Record<string, string>>;
+
+declare class SiStatusMarkerComponent {
+    /**
+     * The status of the marker.
+     * @defaultValue 'default'
+     */
+    readonly status: _angular_core.InputSignal<MarkerStatus>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiStatusMarkerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SiStatusMarkerComponent, "si-status-marker", never, { "status": { "alias": "status"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { SiClusterSourceComponent, SiStatusMarkerComponent, injectSiMapStyle, injectSiMapTranslations };
+export type { ClusterColors, ClusterPoint, ClusterSegment, MarkerStatus };

package/types/siemens-element-ng-markdown-directives-tabs.d.ts

@@ -0,0 +1,10 @@
+import { TypeHandler } from '@siemens/element-ng/markdown';
+
+/**
+ * Copyright (c) Siemens 2016 - 2026
+ * SPDX-License-Identifier: MIT
+ */
+
+declare const siMarkdownTabsetDirective: () => TypeHandler;
+
+export { siMarkdownTabsetDirective };

package/types/siemens-element-ng-markdown-extensions-citations.d.ts

@@ -0,0 +1,11 @@
+import { SiMarkdownExtension } from '@siemens/element-ng/markdown';
+
+/**
+ * Copyright (c) Siemens 2016 - 2026
+ * SPDX-License-Identifier: MIT
+ */
+
+/** Extension to parse and render source citations. */
+declare const siMarkdownCitations: () => SiMarkdownExtension;
+
+export { siMarkdownCitations };

package/types/siemens-element-ng-markdown-extensions-katex.d.ts

@@ -0,0 +1,19 @@
+import { SiMarkdownExtension } from '@siemens/element-ng/markdown';
+import { KatexOptions } from 'katex';
+import { Options } from 'remark-math';
+
+/**
+ * Copyright (c) Siemens 2016 - 2026
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * An extension to render LaTeX math expressions using KaTeX. Uses `remark-math` to parse
+ * the expressions inside the markdown document.
+ * @param parseOptions - options passed to `remark-math`
+ * @param katexOptions - options passed to `katex`
+ * @returns extension for `SiMarkdownOption.installExtension()`
+ */
+declare const siMarkdownMathKaTeX: (parseOptions?: Options, katexOptions?: KatexOptions) => SiMarkdownExtension;
+
+export { siMarkdownMathKaTeX };

package/types/siemens-element-ng-markdown-extensions-mermaid.d.ts

@@ -0,0 +1,11 @@
+import { SiMarkdownExtension } from '@siemens/element-ng/markdown';
+import { MermaidConfig } from 'mermaid';
+
+/**
+ * Copyright (c) Siemens 2016 - 2026
+ * SPDX-License-Identifier: MIT
+ */
+
+declare const siMarkdownMermaid: (options?: MermaidConfig) => SiMarkdownExtension;
+
+export { siMarkdownMermaid };

package/types/siemens-element-ng-markdown-hightlighter-highlightjs.d.ts

@@ -0,0 +1,48 @@
+import * as highlight_js_lib_languages__ from 'highlight.js/lib/languages/*';
+import { HighlightOptions } from 'highlight.js';
+import { SiMarkdownHighlighter } from '@siemens/element-ng/markdown';
+
+/** type of a language import */
+type HighlightJSLanguageImport = Promise<typeof highlight_js_lib_languages__ | undefined>;
+/** Language loader */
+type HighlightJSLanguageLoader = (lang: string) => HighlightJSLanguageImport;
+/** Configuration for the Highlight.js highlighter */
+interface SiMarkdownHighlightJsOptions {
+    /** Should language be auto-detected? This only works with already loaded languages */
+    autoDetectLanguage?: boolean;
+    /**
+     * Language loader to load languages lazily.
+     * @example
+     * ```ts
+     * const hljsLanguageLoader = async (lang: string): HighlightJSLanguageImport => {
+     *   switch (lang) {
+     *     case 'c':
+     *       return import('highlight.js/lib/languages/c');
+     *     case 'cmake':
+     *       return import('highlight.js/lib/languages/cmake');
+     *     case 'cpp':
+     *       return import('highlight.js/lib/languages/cpp');
+     *   }
+     *   return undefined;
+     * };
+     * ```
+     */
+    languageLoader?: HighlightJSLanguageLoader;
+    /** options passed to highlight.js */
+    highlightJs?: Partial<HighlightOptions>;
+}
+
+/**
+ * Copyright (c) Siemens 2016 - 2026
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * Code highlighter using Highlight.js
+ * @param options - Options passed to highlight.js
+ * @returns highlighter configuration for `SiMarkdownOptions.setCodeHighlighter()`
+ */
+declare const siMarkdownHighlightJs: (options?: SiMarkdownHighlightJsOptions) => SiMarkdownHighlighter;
+
+export { siMarkdownHighlightJs };
+export type { HighlightJSLanguageImport, HighlightJSLanguageLoader, SiMarkdownHighlightJsOptions };

package/types/siemens-element-ng-markdown.d.ts

@@ -0,0 +1,367 @@
+import * as _angular_core from '@angular/core';
+import { Type, InputSignal, TemplateRef, InjectionToken, Signal, OutputEmitterRef } from '@angular/core';
+import { SourceReference } from '@siemens/element-ng/source-chip';
+import * as mdast from 'mdast';
+import { Node, Parent, RootContent, FootnoteDefinition, Root, Definition } from 'mdast';
+import { Plugin, Transformer, Preset, PluggableList, Processor } from 'unified';
+import * as _siemens_element_ng_markdown from '@siemens/element-ng/markdown';
+import { StatusType } from '@siemens/element-ng/common';
+import { TranslatableString } from '@siemens/element-translate-ng/translate-types';
+import * as _angular_platform_browser from '@angular/platform-browser';
+
+/**
+ * Copyright (c) Siemens 2016 - 2026
+ * SPDX-License-Identifier: MIT
+ */
+
+/** Interface an extension component must implement */
+interface SiMarkdownExtensionComponent {
+    /** Node to be rendered */
+    node: InputSignal<Node>;
+    /** The parent node */
+    parent: InputSignal<Parent>;
+    /** Options passed to the component */
+    options: InputSignal<any>;
+}
+/** Interface a code highlighter component must implement */
+interface SiMarkdownHighlighterComponent {
+    /** The code to be highlighted */
+    code: InputSignal<string>;
+    /** The language */
+    language: InputSignal<string>;
+    /** Function the highlighter can call to updated the displayed language */
+    updateLanguage: InputSignal<(lang?: string) => void>;
+    /** Options passed to the component */
+    options: InputSignal<any>;
+}
+/** A combination of a component and options passed to it during run-time */
+interface ComponentWithOptions<T> {
+    /** The component used to render the node */
+    component: Type<T>;
+    /** Options passed to the component */
+    options?: any;
+}
+/** Type handler for a named type. This can be an AST node type, a code type, a directive name */
+interface TypeHandler extends ComponentWithOptions<SiMarkdownExtensionComponent> {
+    /** Type name */
+    type: string;
+}
+/** AST node created by `remark-directive`. */
+interface DirectiveNode extends Parent {
+    type: 'containerDirective' | 'leafDirective' | 'textDirective';
+    /** The directive name without its leading colons. */
+    name: string;
+    /** Attributes declared on the directive. */
+    attributes: Record<string, string | undefined>;
+}
+type SiMarkdownHighlighter = ComponentWithOptions<SiMarkdownHighlighterComponent>;
+type UnifiedPlugin = Plugin<any> | Transformer<any> | Preset | PluggableList;
+type UnifiedPluginOptions = ((meta: SiMarkdownMetadata) => any) | any;
+/** Combination of unified plugin with options */
+interface PluginWithOptions {
+    /** The plugin */
+    plugin: UnifiedPlugin;
+    /** Options passed during plugin registration */
+    options?: UnifiedPluginOptions;
+}
+/** An extension to the si-markdown component */
+interface SiMarkdownExtension {
+    /** `unified` plugins to install */
+    plugins?: PluginWithOptions[];
+    /** Type handlers to install */
+    types?: TypeHandler[];
+    /** Special code type handlers to install */
+    codeTypes?: TypeHandler[];
+    /** Directives */
+    directives?: TypeHandler[];
+}
+/** Citation metadata associated with a markdown response. */
+interface SiMarkdownCitation extends SourceReference {
+    /** Identifier referenced by bracket notation, such as `[source-1]`. */
+    identifier?: string;
+    /** Zero-based, end-exclusive source range of the citation reference in the markdown source. */
+    position?: {
+        startIndex: number;
+        endIndex: number;
+    };
+}
+/** Options passed to makeProcessor() */
+interface SiMarkdownMetadata {
+    citations?: SiMarkdownCitation[];
+}
+/** Inline node that references an item in the source citation array. */
+interface Citation extends Node {
+    type: 'citation';
+    citationIndex: number;
+    /** Text replaced by a position-based citation. */
+    text?: string;
+}
+/** Container for one or more adjacent citation nodes. */
+interface Citations extends Node {
+    type: 'citations';
+    children: Citation[];
+}
+/** Extra node for collecting all footnotes */
+interface Footnotes extends Parent {
+    type: 'footnotes';
+    children: FootnoteDefinition[];
+}
+type ExtendedRootContent = RootContent | Footnotes | Citations | DirectiveNode;
+/** Extended root with references */
+type SiMarkdownRoot = Omit<Root, 'children'> & {
+    children: ExtendedRootContent[];
+    references?: {
+        footnoteDefinitions?: Map<string, FootnoteDefinition>;
+        definitions?: Map<string, Definition>;
+    };
+};
+
+/**
+ * Copyright (c) Siemens 2016 - 2026
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * Options for the markdown renderer. This holds all configuration and allows installing
+ * extensions. A number of extensions are already ready to use and shipped with Element.
+ *
+ * @example
+ * ```ts
+ * import { siMarkdownMathKaTeX } from '@siemens/element-ng/markdown/extensions/math';
+ * import remarkGemoji from 'remark-gemoji';
+ *
+ * protected markdownOptions = new SiMarkdownOptions()
+ *   .installExtension(siMarkdownMathKaTeX())
+ *   .installUnifiedPlugin(remarkGemoji);
+ * ```
+ *
+ * ```html
+ * <si-markdown [markdown]="markdownText()" [options]="markdownOptions" />
+ * ```
+ */
+declare class SiMarkdownOptions {
+    private readonly plugins;
+    private types;
+    private codeTypes;
+    private directives;
+    private highlighter?;
+    constructor();
+    /**
+     * Installs a plugin into the `unified` chain
+     * @param plugin - The `unified` plugin
+     * @param options - Options for the plugin
+     * @returns self for chaining
+     */
+    installUnifiedPlugin(plugin: UnifiedPlugin, options?: UnifiedPluginOptions): SiMarkdownOptions;
+    /**
+     * Registers a component used to render a named Markdown directive.
+     * @param directive - The directive with name and handling component
+     * @returns self for chaining
+     */
+    registerDirective(directives: TypeHandler | TypeHandler[]): SiMarkdownOptions;
+    /**
+     * Installs a extension which can contain plugins, type handlers
+     * @param extension - The extension definition
+     * @returns self for chaining
+     */
+    installExtension(extension: SiMarkdownExtension): SiMarkdownOptions;
+    /**
+     * Sets the code highlighter
+     * @param highlighter - The highlighter
+     */
+    setCodeHighlighter(highlighter?: SiMarkdownHighlighter): SiMarkdownOptions;
+    /**
+     * Creates the `unified` processor with all plugins and options
+     * @returns `unified` processor
+     */
+    makeProcessor(meta: SiMarkdownMetadata): Processor<Root, Root, SiMarkdownRoot, undefined, undefined>;
+    /**
+     * @returns All type handlers
+     */
+    getTypeHandlers(): TypeHandler[];
+    /**
+     * @returns All code type handlers
+     */
+    getCodeTypeHandlers(): Map<string, TypeHandler>;
+    /**
+     * @returns The highlighter
+     */
+    getHighlighter(): SiMarkdownHighlighter | undefined;
+}
+declare const makeSiMarkdownOptions: () => SiMarkdownOptions;
+
+/** Directive used to mark a template as a node type for rendering. */
+declare class SiMarkdownTemplateDirective {
+    readonly template: TemplateRef<any>;
+    /** @defaultValue '#dummy' */
+    readonly nodeType: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiMarkdownTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SiMarkdownTemplateDirective, "[siMarkdownTemplate]", never, { "nodeType": { "alias": "siMarkdownTemplate"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Copyright (c) Siemens 2016 - 2026
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * Token to pass the si-markdown component w/o circular dependencies.
+ */
+declare const SI_MARKDOWN_CONTROL: InjectionToken<SiMarkdownControl>;
+/**
+ * Interface of si-markdown exposed to children.
+ */
+interface SiMarkdownControl {
+    templates: Signal<Map<string, TemplateRef<any>>>;
+    meta: Signal<SiMarkdownMetadata>;
+    debug: Signal<boolean>;
+    extensionEvent: OutputEmitterRef<{
+        name: string;
+        data: any;
+    }>;
+}
+
+/**
+ * Component to display markdown text
+ *
+ * This component is built using concepts from [ngx-remark](https://github.com/ericleib/ngx-remark),
+ * namely using Angular templates to render the AST produced by `remark`.
+ *
+ * Unlike `ngx-remark`, it features a configuration based approach of extensibility so that multiple
+ * instances of the component can be used with the same configuration, e.g. inside a chat component
+ * w/o repeating templates.
+ *
+ * @experimental
+ */
+declare class SiMarkdownComponent implements SiMarkdownControl {
+    private static idCounter;
+    /**
+     * The markdown text to transform and display
+     * @defaultValue ''
+     */
+    readonly markdown: _angular_core.InputSignal<string>;
+    /**
+     * Options to control rendering. Can be shared across multiple instances.
+     */
+    readonly options: _angular_core.InputSignal<SiMarkdownOptions | undefined>;
+    /** Citation metadata used to create citations. */
+    readonly citations: _angular_core.InputSignal<SiMarkdownCitation[] | undefined>;
+    /**
+     * Debug mode. When true, unknown node types will be displayed along with the node
+     * as JSON.
+     * @defaultValue false
+     */
+    readonly debug: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Emitted by extension components. */
+    readonly extensionEvent: _angular_core.OutputEmitterRef<{
+        name: string;
+        data: any;
+    }>;
+    protected baseId: string;
+    protected readonly parsed: _angular_core.Signal<SiMarkdownRoot | undefined>;
+    protected readonly templateQuery: _angular_core.Signal<readonly SiMarkdownTemplateDirective[]>;
+    protected readonly customTemplateQuery: _angular_core.Signal<readonly SiMarkdownTemplateDirective[]>;
+    /** @internal */
+    readonly templates: _angular_core.Signal<Map<string, TemplateRef<any>>>;
+    /** Gives access to metadata in extension components */
+    readonly meta: _angular_core.Signal<SiMarkdownMetadata>;
+    private readonly actualOptions;
+    protected readonly config: _angular_core.Signal<{
+        processor: Processor<Root, Root, SiMarkdownRoot, undefined, undefined>;
+        typeHandlers: _siemens_element_ng_markdown.TypeHandler[];
+        codeTypeHandlers: Map<string, _siemens_element_ng_markdown.TypeHandler>;
+    }>;
+    private parseMarkdown;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiMarkdownComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SiMarkdownComponent, "si-markdown", never, { "markdown": { "alias": "markdown"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "citations": { "alias": "citations"; "required": false; "isSignal": true; }; "debug": { "alias": "debug"; "required": false; "isSignal": true; }; }, { "extensionEvent": "extensionEvent"; }, ["customTemplateQuery"], never, true, never>;
+}
+
+/**
+ * Renders a fragment of markdown based on the children of a single node in the AST.
+ */
+declare class SiMarkdownFragmentComponent {
+    protected readonly control: _siemens_element_ng_markdown.SiMarkdownControl;
+    /** The node for which to render all children */
+    readonly node: _angular_core.InputSignal<Node>;
+    /** all the children of the node */
+    readonly children: _angular_core.Signal<mdast.RootContent[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiMarkdownFragmentComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SiMarkdownFragmentComponent, "si-markdown-fragment, [siMarkdownFragment]", never, { "node": { "alias": "siMarkdownFragment"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type CalloutType = 'success' | 'info' | 'warning' | 'danger' | 'caution' | 'critical' | 'note' | 'tip';
+interface Callout {
+    label?: TranslatableString;
+    severity: StatusType;
+    icon?: string;
+    color?: string;
+}
+declare class SiMarkdownCalloutComponent implements SiMarkdownExtensionComponent {
+    private readonly statusIcons;
+    readonly node: _angular_core.InputSignal<Node>;
+    readonly parent: _angular_core.InputSignal<Parent>;
+    readonly options: _angular_core.InputSignal<unknown>;
+    readonly icons: Record<"elementLightOn", string>;
+    readonly callouts: Record<CalloutType, Callout>;
+    protected readonly config: _angular_core.Signal<{
+        callout: Callout;
+        heading: string | undefined;
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiMarkdownCalloutComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SiMarkdownCalloutComponent, "si-markdown-callout", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; "parent": { "alias": "parent"; "required": true; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Copyright (c) Siemens 2016 - 2026
+ * SPDX-License-Identifier: MIT
+ */
+
+/** Installs component rendering for directives parsed by `remark-directive`. */
+declare const siMarkdownDirective: (directives: ReadonlyMap<string, TypeHandler>) => SiMarkdownExtension;
+
+declare class SiMarkdownInlineHtmlComponent implements SiMarkdownExtensionComponent {
+    private readonly sanitizer;
+    readonly node: _angular_core.InputSignal<Node>;
+    readonly parent: _angular_core.InputSignal<Parent>;
+    readonly options: _angular_core.InputSignal<any>;
+    private readonly html;
+    protected readonly sanitized: _angular_core.Signal<_angular_platform_browser.SafeHtml | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiMarkdownInlineHtmlComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SiMarkdownInlineHtmlComponent, "si-markdown-inline-html", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; "parent": { "alias": "parent"; "required": true; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Copyright (c) Siemens 2016 - 2026
+ * SPDX-License-Identifier: MIT
+ */
+
+/** Options for `computedAsync()` */
+interface ComputedAsyncOptions<T, R> {
+    /** Params function, params will be passed to the `computation` function. This is tracked. */
+    params: () => R;
+    /** Computation function. This is `untracked()`, params from the `params` function are passed */
+    computation: (params: R) => Promise<T>;
+    /** Initial value of the `computedAsync` signal. */
+    initial: T;
+}
+/**
+ * Computed value, but async. This exists because the `resource()` API is not suitable. During
+ * loading, the value changes to `undefined`. The proposed solution of resource snapshots and
+ * a `withPreviousValue()` function that uses `resourceFromSnapshots()` isn't suitable either
+ * because it's experimental.
+ *
+ * @param options - the options
+ * @returns readonly signal
+ */
+declare const computedAsync: <T, R>(options: ComputedAsyncOptions<T, R>) => Signal<T>;
+/**
+ * A readonly throttled version of a signal. Emits at most every `interval` milliseconds
+ * @param source - the source signal
+ * @param interval - the interval
+ * @param immediatelyEmitFirstChange - immediately emit the first change
+ * @returns A readonly signal
+ */
+declare const throttledSignal: <T>(source: Signal<T>, interval: number, immediatelyEmitFirstChange?: boolean) => Signal<T>;
+
+export { SI_MARKDOWN_CONTROL, SiMarkdownCalloutComponent, SiMarkdownComponent, SiMarkdownFragmentComponent, SiMarkdownInlineHtmlComponent, SiMarkdownOptions, SiMarkdownTemplateDirective, computedAsync, makeSiMarkdownOptions, siMarkdownDirective, throttledSignal };
+export type { Citation, Citations, ComponentWithOptions, ComputedAsyncOptions, DirectiveNode, ExtendedRootContent, Footnotes, PluginWithOptions, SiMarkdownCitation, SiMarkdownControl, SiMarkdownExtension, SiMarkdownExtensionComponent, SiMarkdownHighlighter, SiMarkdownHighlighterComponent, SiMarkdownMetadata, SiMarkdownRoot, TypeHandler, UnifiedPlugin, UnifiedPluginOptions };

package/types/siemens-element-ng-menu.d.ts

@@ -160,6 +160,7 @@ declare abstract class SiMenuItemBase {
      * @defaultValue false
      */
     readonly disabled: i0.InputSignalWithTransform<boolean, unknown>;
+    protected readonly isInBar: boolean;
     protected readonly badgeDotHasContent: i0.Signal<boolean>;
     static ɵfac: i0.ɵɵFactoryDeclaration<SiMenuItemBase, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<SiMenuItemBase, never, never, { "badge": { "alias": "badge"; "required": false; "isSignal": true; }; "badgeColor": { "alias": "badgeColor"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconBadgeDot": { "alias": "iconBadgeDot"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
@@ -178,6 +179,7 @@ declare class SiMenuItemComponent extends SiMenuItemBase {
     private menuTrigger;
     protected readonly icons: Record<"elementRight2", string>;
     protected get hasSubmenu(): boolean;
+    protected get isExpanded(): boolean | undefined;
     static ɵfac: i0.ɵɵFactoryDeclaration<SiMenuItemComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<SiMenuItemComponent, "si-menu-item, a[si-menu-item], button[si-menu-item]", never, {}, {}, never, ["*", ".end"], true, [{ directive: typeof i1.CdkMenuItem; inputs: { "cdkMenuItemDisabled": "disabled"; }; outputs: { "cdkMenuItemTriggered": "triggered"; }; }]>;
 }