@siemens/element-ng 47.1.0 → 47.3.0

package/tooltip/si-tooltip.service.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Copyright Siemens 2016 - 2025.
+ * SPDX-License-Identifier: MIT
+ */
+import { OverlayRef } from '@angular/cdk/overlay';
+import { ElementRef, Injector, TemplateRef, Type } from '@angular/core';
+import { positions } from '@siemens/element-ng/common';
+import { TranslatableString } from '@siemens/element-translate-ng/translate';
+import * as i0 from "@angular/core";
+/**
+ * TooltipRef is attached to a specific element.
+ * Use it to show or hide a tooltip for that element.
+ *
+ * @internal
+ */
+declare class TooltipRef {
+    private overlayRef;
+    private element;
+    private describedBy;
+    private injector?;
+    constructor(overlayRef: OverlayRef, element: ElementRef, describedBy: string, injector?: Injector | undefined);
+    show(content: TranslatableString | TemplateRef<any> | Type<any>): void;
+    hide(): void;
+    destroy(): void;
+}
+/**
+ * A service to create tooltips for specific elements.
+ * Use this if the tooltip directive is not suitable.
+ * Must not be used outside element-ng.
+ *
+ * @internal
+ */
+export declare class SiTooltipService {
+    private overlay;
+    createTooltip(config: {
+        describedBy: string;
+        element: ElementRef;
+        placement: keyof typeof positions;
+        injector?: Injector;
+    }): TooltipRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiTooltipService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SiTooltipService>;
+}
+export type { TooltipRef };

package/translate/si-translatable-keys.interface.d.ts

@@ -1,7 +1,35 @@
 export interface SiTranslatableKeys {
+    'SI_ALERT_DIALOG.OK'?: string;
     'SI_APPLICATION_HEADER.LAUNCHPAD'?: string;
     'SI_APPLICATION_HEADER.TOGGLE_ACTIONS'?: string;
     'SI_APPLICATION_HEADER.TOGGLE_NAVIGATION'?: string;
+    'SI_CONFIRMATION_DIALOG.NO'?: string;
+    'SI_CONFIRMATION_DIALOG.YES'?: string;
+    'SI_CONTENT_ACTION_BAR.TOGGLE'?: string;
+    'SI_DELETE_CONFIRMATION_DIALOG.CANCEL_BTN'?: string;
+    'SI_DELETE_CONFIRMATION_DIALOG.DELETE_BTN'?: string;
+    'SI_DELETE_CONFIRMATION_DIALOG.MESSAGE'?: string;
+    'SI_EDIT_DISCARD_DIALOG.CANCEL_BTN'?: string;
+    'SI_EDIT_DISCARD_DIALOG.DISABLE_SAVE_DISCARD_BTN'?: string;
+    'SI_EDIT_DISCARD_DIALOG.DISABLE_SAVE_MESSAGE'?: string;
+    'SI_EDIT_DISCARD_DIALOG.DISCARD_BTN'?: string;
+    'SI_EDIT_DISCARD_DIALOG.MESSAGE'?: string;
+    'SI_EDIT_DISCARD_DIALOG.SAVE_BTN'?: string;
+    'SI_FORM_CONTAINER.ERROR.DATE_FORMAT'?: string;
+    'SI_FORM_CONTAINER.ERROR.EMAIL'?: string;
+    'SI_FORM_CONTAINER.ERROR.IPV4'?: string;
+    'SI_FORM_CONTAINER.ERROR.IPV6'?: string;
+    'SI_FORM_CONTAINER.ERROR.MAX'?: string;
+    'SI_FORM_CONTAINER.ERROR.MAX_DATE'?: string;
+    'SI_FORM_CONTAINER.ERROR.MAX_LENGTH'?: string;
+    'SI_FORM_CONTAINER.ERROR.MIN'?: string;
+    'SI_FORM_CONTAINER.ERROR.MIN_DATE'?: string;
+    'SI_FORM_CONTAINER.ERROR.MIN_LENGTH'?: string;
+    'SI_FORM_CONTAINER.ERROR.NUMBER_FORMAT'?: string;
+    'SI_FORM_CONTAINER.ERROR.PATTERN'?: string;
+    'SI_FORM_CONTAINER.ERROR.REQUIRED'?: string;
+    'SI_FORM_CONTAINER.ERROR.REQUIRED_TRUE'?: string;
+    'SI_LANGUAGE_SWITCHER.LABEL'?: string;
     'SI_LAUNCHPAD.CLOSE'?: string;
     'SI_LAUNCHPAD.DEFAULT_CATEGORY_TITLE'?: string;
     'SI_LAUNCHPAD.FAVORITE_APPS'?: string;
@@ -10,6 +38,24 @@ export interface SiTranslatableKeys {
     'SI_LAUNCHPAD.SUBTITLE'?: string;
     'SI_LAUNCHPAD.SUB_TITLE'?: string;
     'SI_LAUNCHPAD.TITLE'?: string;
+    'SI_LOADING_SPINNER.LABEL'?: string;
     'SI_NAVBAR.OPEN_LAUNCHPAD'?: string;
     'SI_NAVBAR.TOGGLE_NAVIGATION'?: string;
+    'SI_PAGINATION.BACK'?: string;
+    'SI_PAGINATION.FORWARD'?: string;
+    'SI_PAGINATION.NAV_LABEL'?: string;
+    'SI_PASSWORD_TOGGLE.HIDE'?: string;
+    'SI_PASSWORD_TOGGLE.SHOW'?: string;
+    'SI_PILLS_INPUT.INPUT_ELEMENT_ARIA_LABEL'?: string;
+    'SI_PROGRESSBAR.LABEL'?: string;
+    'SI_SELECT.NO-RESULTS-FOUND'?: string;
+    'SI_SELECT.SEARCH-PLACEHOLDER'?: string;
+    'SI_SKIP_LINKS.JUMP_TO'?: string;
+    'SI_TOAST.CLOSE'?: string;
+    'SI_TYPEAHEAD.AUTOCOMPLETE_LIST_LABEL'?: string;
+    'SI_WIZARD.BACK'?: string;
+    'SI_WIZARD.CANCEL'?: string;
+    'SI_WIZARD.COMPLETED'?: string;
+    'SI_WIZARD.NEXT'?: string;
+    'SI_WIZARD.SAVE'?: string;
 }

package/typeahead/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright Siemens 2016 - 2025.
+ * SPDX-License-Identifier: MIT
+ */
+export * from './si-typeahead.directive';
+export * from './si-typeahead.model';
+export * from './si-typeahead.module';
+export * from './si-typeahead-item-template.directive';

package/typeahead/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/siemens-element-ng-typeahead.mjs"
+}

package/typeahead/si-typeahead-item-template.directive.d.ts

@@ -0,0 +1,7 @@
+import { TypeaheadOptionItemContext } from './si-typeahead.model';
+import * as i0 from "@angular/core";
+export declare class SiTypeaheadItemTemplateDirective {
+    static ngTemplateContextGuard(dir: SiTypeaheadItemTemplateDirective, ctx: any): ctx is TypeaheadOptionItemContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiTypeaheadItemTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SiTypeaheadItemTemplateDirective, "[siTypeaheadItemTemplate]", never, {}, {}, never, never, true, never>;
+}

package/typeahead/si-typeahead.component.d.ts

@@ -0,0 +1,22 @@
+import { AfterViewInit, ElementRef, OnDestroy, OnInit } from '@angular/core';
+import { SiAutocompleteDirective } from '@siemens/element-ng/autocomplete';
+import { SiTypeaheadDirective } from './si-typeahead.directive';
+import { TypeaheadMatch } from './si-typeahead.model';
+import * as i0 from "@angular/core";
+export declare class SiTypeaheadComponent implements OnDestroy, OnInit, AfterViewInit {
+    protected parent: SiTypeaheadDirective;
+    protected readonly matches: import("@angular/core").Signal<TypeaheadMatch[]>;
+    protected multiselect: boolean;
+    private renderedMatchesLength;
+    private subscription;
+    private readonly typeaheadElement;
+    protected autocompleteDirective: SiAutocompleteDirective<any>;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    protected onMouseDown(event: Event): void;
+    protected setHeight(element: ElementRef): void;
+    protected selectMatch(match: TypeaheadMatch): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiTypeaheadComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SiTypeaheadComponent, "si-typeahead", never, {}, {}, never, never, true, never>;
+}

package/typeahead/si-typeahead.directive.d.ts

@@ -0,0 +1,196 @@
+/**
+ * Copyright Siemens 2016 - 2025.
+ * SPDX-License-Identifier: MIT
+ */
+import { ConnectionPositionPair } from '@angular/cdk/overlay';
+import { OnChanges, OnDestroy, SimpleChanges, TemplateRef } from '@angular/core';
+import { Typeahead, TypeaheadMatch, TypeaheadOptionItemContext } from './si-typeahead.model';
+import * as i0 from "@angular/core";
+import * as i1 from "@siemens/element-ng/autocomplete";
+export declare class SiTypeaheadDirective implements OnChanges, OnDestroy {
+    protected static readonly overlayPositions: ConnectionPositionPair[];
+    /**
+     * Set the options of the typeahead.
+     * Has to be either an Array or an Observable of an Array
+     * of options (string or object)
+     */
+    readonly siTypeahead: import("@angular/core").InputSignal<Typeahead>;
+    /**
+     * Turns on/off the processing (searching and sorting) of the typeahead options.
+     * Is used when searching and sorting is done externally.
+     *
+     * @defaultValue true
+     */
+    readonly typeaheadProcess: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Makes the typeahead scrollable and sets its height.
+     * Uses {@link typeaheadOptionsInScrollableView} and {@link typeaheadScrollableAdditionalHeight}.
+     *
+     * @defaultValue false
+     */
+    readonly typeaheadScrollable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /**
+     * If {@link typeaheadScrollable} is `true`, defines the number of items visible at once.
+     *
+     * @defaultValue 10
+     */
+    readonly typeaheadOptionsInScrollableView: import("@angular/core").InputSignal<number>;
+    /**
+     * Defines the maximum number of items added into the DOM. Default is 20 and 0 means unlimited.
+     *
+     * @defaultValue 20
+     */
+    readonly typeaheadOptionsLimit: import("@angular/core").InputSignal<number>;
+    /**
+     * If {@link typeaheadScrollable} is `true`, defines the number of additional pixels
+     * to be added the the bottom of the typeahead to show users that it is scrollable.
+     *
+     * @defaultValue 13
+     */
+    readonly typeaheadScrollableAdditionalHeight: import("@angular/core").InputSignal<number>;
+    /**
+     * Defines the index of the item which should automatically be selected.
+     *
+     * @defaultValue 0
+     */
+    readonly typeaheadAutoSelectIndex: import("@angular/core").InputSignalWithTransform<number, unknown>;
+    /**
+     * Defines whether the typeahead can be closed using escape.
+     *
+     * @defaultValue true
+     */
+    readonly typeaheadCloseOnEsc: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Defines whether the host value should be cleared when a value is selected.
+     *
+     * @defaultValue false
+     */
+    readonly typeaheadClearValueOnSelect: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Defines the number of milliseconds to wait before displaying a typeahead after the host was
+     * focused or a value inputted.
+     *
+     * @defaultValue 0
+     */
+    readonly typeaheadWaitMs: import("@angular/core").InputSignal<number>;
+    /**
+     * Defines the number of characters the value of the host needs to be before a typeahead is displayed.
+     * Use `0` to have it display when focussing the host (clicking or tabbing into it).
+     *
+     * @defaultValue 1
+     */
+    readonly typeaheadMinLength: import("@angular/core").InputSignal<number>;
+    /**
+     * Defines the name of the field/property the option string is in when the typeahead options are objects.
+     *
+     * @defaultValue 'name'
+     */
+    readonly typeaheadOptionField: import("@angular/core").InputSignal<string>;
+    /**
+     * Defines whether multiselection of typeahead is possible with checkboxes.
+     *
+     * @defaultValue false
+     */
+    readonly typeaheadMultiSelect: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Defines whether to tokenize the search or match the whole search.
+     *
+     * @defaultValue true
+     */
+    readonly typeaheadTokenize: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Defines whether and how to require to match with all the tokens if {@link typeaheadTokenize} is enabled.
+     * - `no` does not require all of the tokens to match.
+     * - `once` requires all of the parts to be found in the search.
+     * - `separately` requires all of the parts to be found in the search where there is not an overlapping different result.
+     * - `independently` requires all of the parts to be found in the search where there is not an overlapping or adjacent different result.
+     *  ('independently' also slightly changes sorting behavior in the same way.)
+     *
+     * @defaultValue 'separately'
+     */
+    readonly typeaheadMatchAllTokens: import("@angular/core").InputSignal<"no" | "once" | "separately" | "independently">;
+    /**
+     * Defines an optional template to use as the typeahead match item instead of the one built in.
+     * Gets the {@link TypeaheadOptionItemContext} passed to it.
+     */
+    readonly typeaheadItemTemplate: import("@angular/core").InputSignal<TemplateRef<TypeaheadOptionItemContext> | undefined>;
+    /**
+     * Skip the sorting of matches.
+     * If the value is `true`, the matches are sorted according to {@link SiTypeaheadSorting}.
+     *
+     * @defaultValue false
+     */
+    readonly typeaheadSkipSortingMatches: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Screen reader only label for the autocomplete list.
+     *
+     * @defaultValue
+     * ```
+     * $localize`:@@SI_TYPEAHEAD.AUTOCOMPLETE_LIST_LABEL:Suggestions`
+     * ```
+     */
+    readonly typeaheadAutocompleteListLabel: import("@angular/core").InputSignal<import("@siemens/element-translate-ng/translate-types").TranslatableString>;
+    /**
+     * If set, the typeahead will at minium have the width of the connected input field.
+     *
+     * @defaultValue false
+     */
+    readonly typeaheadFullWidth: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Emits an Event when the input field is changed.
+     */
+    readonly typeaheadOnInput: import("@angular/core").OutputEmitterRef<string>;
+    /**
+     * Emits an Event when a typeahead match is selected.
+     * The event is a {@link TypeaheadMatch}
+     */
+    readonly typeaheadOnSelect: import("@angular/core").OutputEmitterRef<TypeaheadMatch>;
+    /** @deprecated Never emits. Use {@link typeaheadOpenChange} instead. */
+    readonly typeaheadOnMultiselectClose: import("@angular/core").OutputEmitterRef<void>;
+    /**
+     * Emits an Event when a typeahead full match exists. A full match occurs when the entered text
+     * is equal to one of the typeahead options.
+     * The event is a {@link TypeaheadMatch}
+     */
+    readonly typeaheadOnFullMatch: import("@angular/core").OutputEmitterRef<TypeaheadMatch>;
+    /** @deprecated Use {@link typeaheadOpenChange} instead. */
+    readonly typeaheadClosed: import("@angular/core").OutputEmitterRef<void>;
+    /** Emits whenever the typeahead overlay is opened or closed. */
+    readonly typeaheadOpenChange: import("@angular/core").OutputEmitterRef<boolean>;
+    /** @internal */
+    readonly foundMatches: import("@angular/core").WritableSignal<TypeaheadMatch[]>;
+    /** @internal */
+    readonly query: import("@angular/core").WritableSignal<string>;
+    /**
+     * Indicates whether the typeahead is shown.
+     */
+    get typeaheadOpen(): boolean;
+    private overlay;
+    private elementRef;
+    private injector;
+    private autoComplete;
+    private $typeahead;
+    private componentRef?;
+    private component?;
+    private inputTimer;
+    private sourceSubscription?;
+    private subscription?;
+    private matchSorter;
+    private overlayRef?;
+    ngOnChanges(changes: SimpleChanges): void;
+    protected onBlur(): void;
+    protected onInput(event: Event): void;
+    protected onKeydownEscape(): void;
+    protected onKeydownSpace(event: KeyboardEvent): void;
+    ngOnDestroy(): void;
+    private loadComponent;
+    private getOptionValue;
+    private getMatches;
+    /** @internal */
+    selectMatch(match: TypeaheadMatch): void;
+    private removeComponent;
+    private clearTimer;
+    private escapeRegex;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiTypeaheadDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SiTypeaheadDirective, "[siTypeahead]", ["si-typeahead"], { "siTypeahead": { "alias": "siTypeahead"; "required": true; "isSignal": true; }; "typeaheadProcess": { "alias": "typeaheadProcess"; "required": false; "isSignal": true; }; "typeaheadScrollable": { "alias": "typeaheadScrollable"; "required": false; "isSignal": true; }; "typeaheadOptionsInScrollableView": { "alias": "typeaheadOptionsInScrollableView"; "required": false; "isSignal": true; }; "typeaheadOptionsLimit": { "alias": "typeaheadOptionsLimit"; "required": false; "isSignal": true; }; "typeaheadScrollableAdditionalHeight": { "alias": "typeaheadScrollableAdditionalHeight"; "required": false; "isSignal": true; }; "typeaheadAutoSelectIndex": { "alias": "typeaheadAutoSelectIndex"; "required": false; "isSignal": true; }; "typeaheadCloseOnEsc": { "alias": "typeaheadCloseOnEsc"; "required": false; "isSignal": true; }; "typeaheadClearValueOnSelect": { "alias": "typeaheadClearValueOnSelect"; "required": false; "isSignal": true; }; "typeaheadWaitMs": { "alias": "typeaheadWaitMs"; "required": false; "isSignal": true; }; "typeaheadMinLength": { "alias": "typeaheadMinLength"; "required": false; "isSignal": true; }; "typeaheadOptionField": { "alias": "typeaheadOptionField"; "required": false; "isSignal": true; }; "typeaheadMultiSelect": { "alias": "typeaheadMultiSelect"; "required": false; "isSignal": true; }; "typeaheadTokenize": { "alias": "typeaheadTokenize"; "required": false; "isSignal": true; }; "typeaheadMatchAllTokens": { "alias": "typeaheadMatchAllTokens"; "required": false; "isSignal": true; }; "typeaheadItemTemplate": { "alias": "typeaheadItemTemplate"; "required": false; "isSignal": true; }; "typeaheadSkipSortingMatches": { "alias": "typeaheadSkipSortingMatches"; "required": false; "isSignal": true; }; "typeaheadAutocompleteListLabel": { "alias": "typeaheadAutocompleteListLabel"; "required": false; "isSignal": true; }; "typeaheadFullWidth": { "alias": "typeaheadFullWidth"; "required": false; "isSignal": true; }; }, { "typeaheadOnInput": "typeaheadOnInput"; "typeaheadOnSelect": "typeaheadOnSelect"; "typeaheadOnMultiselectClose": "typeaheadOnMultiselectClose"; "typeaheadOnFullMatch": "typeaheadOnFullMatch"; "typeaheadClosed": "typeaheadClosed"; "typeaheadOpenChange": "typeaheadOpenChange"; }, never, never, true, [{ directive: typeof i1.SiAutocompleteDirective; inputs: {}; outputs: {}; }]>;
+}

package/typeahead/si-typeahead.model.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Copyright Siemens 2016 - 2025.
+ * SPDX-License-Identifier: MIT
+ */
+import { Observable } from 'rxjs';
+/**
+ * A singular item to be used in the typeahead.
+ * Can be either a string or an object.
+ */
+export type TypeaheadOption = string | {
+    [key in string | number]: any;
+};
+/**
+ * An array of {@link TypeaheadOption}.
+ */
+export type TypeaheadArray = TypeaheadOption[];
+/**
+ * An observable of a {@link TypeaheadArray} (array of {@link TypeaheadOption}).
+ */
+export type TypeaheadObservable = Observable<TypeaheadArray>;
+/**
+ * Either a {@link TypeaheadObservable} (observable of a {@link TypeaheadArray}) or a {@link TypeaheadArray}.
+ */
+export type Typeahead = TypeaheadArray | TypeaheadObservable;
+/**
+ * A segment of a {@link TypeaheadMatch}, which is a matching or non-matching segment of a typeahead option.
+ */
+export interface MatchSegment {
+    text: string;
+    isMatching: boolean;
+    matches: number;
+    uniqueMatches: number;
+}
+/**
+ * A typeahead match, which is a processed typeahead option.
+ */
+export interface TypeaheadMatch {
+    option: TypeaheadOption;
+    text: string;
+    result: MatchSegment[];
+    stringMatch: boolean;
+    atBeginning: boolean;
+    matches: number;
+    uniqueMatches: number;
+    uniqueSeparateMatches: number;
+    matchesEntireQuery: boolean;
+    matchesAllParts: boolean;
+    matchesAllPartsSeparately: boolean;
+    itemSelected?: boolean;
+    iconClass?: string;
+}
+/**
+ * An interface to define the context of a typeahead item template
+ */
+export interface TypeaheadOptionItemContext {
+    item: TypeaheadOption;
+    index: number;
+    match: TypeaheadMatch;
+    query: string;
+}

package/typeahead/si-typeahead.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./si-typeahead.directive";
+import * as i2 from "./si-typeahead-item-template.directive";
+export declare class SiTypeaheadModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiTypeaheadModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SiTypeaheadModule, never, [typeof i1.SiTypeaheadDirective, typeof i2.SiTypeaheadItemTemplateDirective], [typeof i1.SiTypeaheadDirective, typeof i2.SiTypeaheadItemTemplateDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SiTypeaheadModule>;
+}

package/typeahead/si-typeahead.sorting.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright Siemens 2016 - 2025.
+ * SPDX-License-Identifier: MIT
+ */
+import { TypeaheadMatch } from './si-typeahead.model';
+export declare class SiTypeaheadSorting {
+    sortMatches(matches: TypeaheadMatch[]): TypeaheadMatch[];
+    private compareMatchesNumbers;
+    private compareMatches;
+}

package/wizard/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright Siemens 2016 - 2025.
+ * SPDX-License-Identifier: MIT
+ */
+export * from './si-wizard-step.component';
+export * from './si-wizard.component';
+export * from './si-wizard.module';

package/wizard/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/siemens-element-ng-wizard.mjs"
+}

package/wizard/si-wizard-step.component.d.ts

@@ -0,0 +1,21 @@
+import * as i0 from "@angular/core";
+export declare class SiWizardStepComponent {
+    /** @defaultValue '' */
+    readonly heading: import("@angular/core").InputSignal<string>;
+    /** @defaultValue true */
+    readonly isValid: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /** @defaultValue true */
+    readonly isNextNavigable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /** @defaultValue false */
+    readonly failed: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    readonly next: import("@angular/core").OutputEmitterRef<void>;
+    readonly back: import("@angular/core").OutputEmitterRef<void>;
+    readonly save: import("@angular/core").OutputEmitterRef<void>;
+    /**
+     * Whether this step is currently active or not.
+     * @defaultValue false
+     */
+    readonly isActive: import("@angular/core").WritableSignal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiWizardStepComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SiWizardStepComponent, "si-wizard-step", never, { "heading": { "alias": "heading"; "required": false; "isSignal": true; }; "isValid": { "alias": "isValid"; "required": false; "isSignal": true; }; "isNextNavigable": { "alias": "isNextNavigable"; "required": false; "isSignal": true; }; "failed": { "alias": "failed"; "required": false; "isSignal": true; }; }, { "next": "next"; "back": "back"; "save": "save"; }, never, ["*"], true, never>;
+}