@siemens/element-ng 47.1.0 → 47.3.0

package/select/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Copyright Siemens 2016 - 2025.
+ * SPDX-License-Identifier: MIT
+ */
+export * from './si-select.component';
+export * from './options/si-select-lazy-options.directive';
+export * from './options/si-select-simple-options.directive';
+export * from './options/si-select-complex-options.directive';
+export * from './options/si-select-option.source';
+export * from './selection/si-select-single-value.directive';
+export * from './selection/si-select-multi-value.directive';
+export * from './si-select-option-template.directive';
+export * from './si-select-group-template.directive';
+export * from './si-select.module';
+export * from './select-list/si-select-list-has-filter.component';
+export * from './si-select-action.directive';
+export * from './si-select-actions.directive';
+export * from './si-select.types';

package/select/options/si-select-complex-options.directive.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Copyright Siemens 2016 - 2025.
+ * SPDX-License-Identifier: MIT
+ */
+import { OnChanges } from '@angular/core';
+import { SelectGroup, SelectOption } from '../si-select.types';
+import { SiSelectOptionsStrategyBase } from './si-select-options-strategy.base';
+import * as i0 from "@angular/core";
+/**
+ * The directive allows passing custom options.
+ * Otherwise, use the {@link SiSelectSimpleOptionsDirective} directive.
+ *
+ * @deprecated Use {@link SiSelectSimpleOptionsDirective} instead.
+ *
+ * @example
+ * ```html
+ * <si-select [complexOptions]="['v1', 'v2', 'v3']"></si-select>
+ * <si-select [complexOptions]="{ g1: ['g1.i1', 'g1.i2'], g2: ['g2.i1']}"></si-select>
+ * ```
+ */
+export declare class SiSelectComplexOptionsDirective<T> extends SiSelectOptionsStrategyBase<T> implements OnChanges {
+    /** Options to be shown in select dropdown. */
+    readonly complexOptions: import("@angular/core").InputSignal<T[] | Record<string, T[]> | null | undefined>;
+    /**
+     * @deprecated Property has no effect and can be removed.
+     *
+     * @defaultValue
+     * ```
+     * buildTrackByIdentity<T>()
+     * ```
+     */
+    readonly trackBy: import("@angular/core").InputSignal<import("@angular/core").TrackByFunction<T>>;
+    /**
+     * By default, values are check on equality by reference. Override to customize the behavior.
+     *
+     * @defaultValue
+     * ```
+     * (a: T, b: T): boolean => a === b
+     * ```
+     */
+    readonly optionsEqual: import("@angular/core").InputSignal<(a: T, b: T) => boolean>;
+    /**
+     * The valueProvider is used to extract the display text of a value.
+     */
+    readonly valueProvider: import("@angular/core").InputSignal<((dropdownOption: T) => string | undefined) | undefined>;
+    /**
+     * Provides Value for the display text of the dropdown group
+     *
+     * @defaultValue
+     * ```
+     * () => undefined
+     * ```
+     */
+    readonly groupProvider: import("@angular/core").InputSignal<(groupKey: string) => string | undefined>;
+    /**
+     * The disabledProvider is used to display menu items as disabled.
+     *
+     * @defaultValue
+     * ```
+     * () => false
+     * ```
+     */
+    readonly disabledProvider: import("@angular/core").InputSignal<(dropdownOption: T) => boolean>;
+    readonly allRows: import("@angular/core").Signal<SelectOption<T>[] | SelectGroup<T>[]>;
+    ngOnChanges(): void;
+    private convertOptionsArray;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiSelectComplexOptionsDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SiSelectComplexOptionsDirective<any>, "si-select[complexOptions]", never, { "complexOptions": { "alias": "complexOptions"; "required": false; "isSignal": true; }; "trackBy": { "alias": "trackBy"; "required": false; "isSignal": true; }; "optionsEqual": { "alias": "optionEqualCheckFn"; "required": false; "isSignal": true; }; "valueProvider": { "alias": "valueProvider"; "required": false; "isSignal": true; }; "groupProvider": { "alias": "groupProvider"; "required": false; "isSignal": true; }; "disabledProvider": { "alias": "disabledProvider"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/select/options/si-select-lazy-options.directive.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Copyright Siemens 2016 - 2025.
+ * SPDX-License-Identifier: MIT
+ */
+import { OnDestroy } from '@angular/core';
+import { SelectItem, SelectOption } from '../si-select.types';
+import { SelectOptionSource } from './si-select-option.source';
+import { SiSelectOptionsStrategy } from './si-select-options-strategy';
+import * as i0 from "@angular/core";
+export declare class SiSelectLazyOptionsDirective<T> implements SiSelectOptionsStrategy<T>, OnDestroy {
+    /**
+     * {@inheritDoc SiSelectOptionsStrategy#loading}
+     * @defaultValue false
+     */
+    readonly loading: import("@angular/core").WritableSignal<boolean>;
+    /**
+     * {@inheritDoc SiSelectOptionsStrategy#rows}
+     * @defaultValue []
+     */
+    readonly rows: import("@angular/core").WritableSignal<SelectItem<T>[]>;
+    /**
+     * {@inheritDoc SiSelectOptionsStrategy#selectedRows}
+     * @defaultValue []
+     */
+    readonly selectedRows: import("@angular/core").WritableSignal<SelectOption<T>[]>;
+    readonly optionSource: import("@angular/core").InputSignal<SelectOptionSource<T>>;
+    private valueChange;
+    private filterChange;
+    constructor();
+    ngOnDestroy(): void;
+    /** {@inheritDoc SiSelectOptionsStrategy.onValueChange} */
+    onValueChange(value: T[]): void;
+    /** {@inheritDoc SiSelectOptionsStrategy.onFilter} */
+    onFilter(filterInput?: string): void;
+    private valueEqual;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiSelectLazyOptionsDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SiSelectLazyOptionsDirective<any>, "si-select[optionSource]", never, { "optionSource": { "alias": "optionSource"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/select/options/si-select-option.source.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Copyright Siemens 2016 - 2025.
+ * SPDX-License-Identifier: MIT
+ */
+import { Observable } from 'rxjs';
+import { SelectItem, SelectOption } from '../si-select.types';
+/**
+ * An interface to define a lazy option source for the {@link SiSelectComponent}.
+ *
+ * @typeParam TValue - is the type of the value in {@link SiSelectComponent}, so the value of the associated formControl, ngModel or value input.
+ */
+export interface SelectOptionSource<TValue> {
+    /**
+     * Get options for the provided values.
+     * This is basically a resolver function, that resolves values to options.
+     *
+     * @param values - values that should be resolved to an option.
+     */
+    getOptionsForValues(values: TValue[]): Observable<SelectOption<TValue>[]>;
+    /**
+     * Get all available options.
+     * If provided, this will be called when no filter value is provided.
+     * Otherwise, si-select will only show the selected values.
+  
+     * This function must be implemented if this source is used on a select without a filter.
+     */
+    getAllOptions?(): Observable<SelectItem<TValue>[]>;
+    /**
+     * Find options for a search value. It will never be called with an empty search value.
+     *
+     * This function must be implemented if this source is used on a si-select with a filter.
+     *
+     * @param search - value typed by the user in the search field.
+     */
+    getOptionsForSearch?(search: string): Observable<SelectItem<TValue>[]>;
+    /**
+     * This function is used to sort options.
+     *
+     * It is only called if the si-select was able to find all options without querying the option source.
+     */
+    compareOptions?(a: SelectOption<TValue>, b: SelectOption<TValue>): number;
+    /**
+     * Function to check if two values are equal.
+     *
+     * This function must be implemented if the check on reference equality is not enough.
+     * For instance, when using objects as value.
+     */
+    valuesEqual?(optionA: TValue, optionB: TValue): boolean;
+}

package/select/options/si-select-options-strategy.base.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Copyright Siemens 2016 - 2025.
+ * SPDX-License-Identifier: MIT
+ */
+import { InputSignal, Signal } from '@angular/core';
+import { SelectItem, SelectOption } from '../si-select.types';
+import { SiSelectOptionsStrategy } from './si-select-options-strategy';
+import * as i0 from "@angular/core";
+/**
+ * Input options strategy base class, for eagerly fetched options.
+ */
+export declare abstract class SiSelectOptionsStrategyBase<T> implements SiSelectOptionsStrategy<T> {
+    /**
+     * Function to compare two values on equality which is used to match/filter options.
+     */
+    abstract optionsEqual: InputSignal<(a: T, b: T) => boolean>;
+    /**
+     * Rows that should be shown.
+     *
+     * @defaultValue []
+     */
+    readonly rows: import("@angular/core").WritableSignal<SelectItem<T>[]>;
+    /**
+     * All group and option items in the dropdown.
+     *
+     * @defaultValue []
+     */
+    abstract readonly allRows: Signal<(SelectItem<T> | SelectOption<T>)[]>;
+    private readonly value;
+    readonly selectedRows: Signal<SelectOption<T>[]>;
+    onValueChange(value: T[]): void;
+    onFilter(filterValue?: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiSelectOptionsStrategyBase<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SiSelectOptionsStrategyBase<any>, never, never, {}, {}, never, never, true, never>;
+}

package/select/options/si-select-options-strategy.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Copyright Siemens 2016 - 2025.
+ * SPDX-License-Identifier: MIT
+ */
+import { InjectionToken, Signal } from '@angular/core';
+import { SelectItem, SelectOption } from '../si-select.types';
+export declare const SI_SELECT_OPTIONS_STRATEGY: InjectionToken<SiSelectOptionsStrategy<unknown>>;
+export interface SiSelectOptionsStrategy<T> {
+    /**
+     * List of all rows that should be rendered in a selection list.
+     */
+    readonly rows: Signal<readonly SelectItem<T>[]>;
+    /**
+     * List of all options that are currently selected.
+     * Must be updated when {@link onValueChange} is called.
+     */
+    readonly selectedRows: Signal<readonly SelectOption<T>[]>;
+    /**
+     * Indicate loading state of the options.
+     */
+    readonly loading?: Signal<boolean>;
+    /**
+     * Is always called when the value changes.
+     * The implementation must update {@link selectedRows} when called.
+     *
+     * @param value - currently selected value of the related si-select.
+     */
+    onValueChange(value: readonly T[]): void;
+    /**
+     * This function is called when a user enters a filter query.
+     * It is expected that an implementation will update the `rows`
+     * based on the query.
+     *
+     * @param filterInput - Unprocessed input by user in the filterInput field
+     */
+    onFilter?(filterInput?: string): void;
+}

package/select/options/si-select-simple-options.directive.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Copyright Siemens 2016 - 2025.
+ * SPDX-License-Identifier: MIT
+ */
+import { OnChanges } from '@angular/core';
+import { SelectItem, SelectOptionLegacy } from '../si-select.types';
+import { SiSelectOptionsStrategyBase } from './si-select-options-strategy.base';
+import * as i0 from "@angular/core";
+/**
+ * This directive allows passing {@link SelectItem} to the {@link SiSelectComponent}.
+ *
+ * @example
+ * ```html
+ * <si-select [options]="[{ type: 'option', value: 'one', label: 'One' }, { type: 'option', value: 'two', label: 'Two' }]"></si-select>
+ * <si-select [options]="[{ type: 'group', label: 'Group', options [{ type: 'option', value: 1, label: 'One' }, { type: 'option', value: 2, label: 'Two' }] }]"></si-select>
+ * ```
+ */
+export declare class SiSelectSimpleOptionsDirective<T = string> extends SiSelectOptionsStrategyBase<T> implements OnChanges {
+    /** Options to be shown in select dropdown */
+    readonly options: import("@angular/core").InputSignal<(SelectOptionLegacy | SelectItem<T>)[] | null | undefined>;
+    /**
+     * By default, values are check on referential equality. Provide a function to customize the behavior.
+     *
+     * @defaultValue
+     * ```
+     * (a: T, b: T): boolean => a === b
+     * ```
+     */
+    readonly optionsEqual: import("@angular/core").InputSignal<(a: T, b: T) => boolean>;
+    readonly allRows: import("@angular/core").Signal<SelectItem<T>[]>;
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiSelectSimpleOptionsDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SiSelectSimpleOptionsDirective<any>, "si-select[options]", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "optionsEqual": { "alias": "optionEqualCheckFn"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/select/package.json

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

package/select/select-input/si-select-input.component.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Copyright Siemens 2016 - 2025.
+ * SPDX-License-Identifier: MIT
+ */
+import { TemplateRef } from '@angular/core';
+import { TranslatableString } from '@siemens/element-translate-ng/translate';
+import { SiSelectSelectionStrategy } from '../selection/si-select-selection-strategy';
+import { SelectOption } from '../si-select.types';
+import * as i0 from "@angular/core";
+export declare class SiSelectInputComponent<T> {
+    readonly baseId: import("@angular/core").InputSignal<string>;
+    /**
+     * Aria labelledby of the select.
+     *
+     * @defaultValue null
+     */
+    readonly labelledby: import("@angular/core").InputSignal<string | null>;
+    /**
+     * Aria label of the select.
+     *
+     * @defaultValue null
+     */
+    readonly ariaLabel: import("@angular/core").InputSignal<string | null>;
+    /** @defaultValue false */
+    readonly open: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    readonly placeholder: import("@angular/core").InputSignal<TranslatableString | undefined>;
+    readonly controls: import("@angular/core").InputSignal<string>;
+    readonly optionTemplate: import("@angular/core").InputSignal<TemplateRef<{
+        $implicit: SelectOption<T>;
+    }> | undefined>;
+    /** @defaultValue false */
+    readonly readonly: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    readonly openListbox: import("@angular/core").OutputEmitterRef<void>;
+    protected readonly selectionStrategy: SiSelectSelectionStrategy<T, T | T[]>;
+    private readonly selectOptions;
+    protected readonly selectedRows: import("@angular/core").Signal<readonly SelectOption<T>[]>;
+    protected readonly labeledBy: import("@angular/core").Signal<string>;
+    protected readonly icons: Record<"elementDown2", string>;
+    protected blur(): void;
+    protected click(event?: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiSelectInputComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SiSelectInputComponent<any>, "si-select-input", never, { "baseId": { "alias": "baseId"; "required": true; "isSignal": true; }; "labelledby": { "alias": "labelledby"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "controls": { "alias": "controls"; "required": true; "isSignal": true; }; "optionTemplate": { "alias": "optionTemplate"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; }, { "openListbox": "openListbox"; }, never, never, true, never>;
+}

package/select/select-list/si-select-list-has-filter.component.d.ts

@@ -0,0 +1,20 @@
+import { ElementRef, OnInit, Signal } from '@angular/core';
+import { TranslatableString } from '@siemens/element-translate-ng/translate';
+import { SiSelectListBase } from './si-select-list.base';
+import * as i0 from "@angular/core";
+export declare class SiSelectListHasFilterComponent<T> extends SiSelectListBase<T> implements OnInit {
+    /** Placeholder for search input field. */
+    readonly filterPlaceholder: import("@angular/core").InputSignal<TranslatableString>;
+    /** Label if no item can be found. */
+    readonly noResultsFoundLabel: import("@angular/core").InputSignal<TranslatableString>;
+    protected readonly filterInput: Signal<ElementRef<HTMLInputElement>>;
+    protected readonly initIndex: Signal<number>;
+    protected readonly id: Signal<string>;
+    protected readonly icons: Record<"elementSearch", string>;
+    constructor();
+    ngOnInit(): void;
+    protected input(): void;
+    protected select(newValue: T): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiSelectListHasFilterComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SiSelectListHasFilterComponent<any>, "si-select-list-has-filter", never, { "filterPlaceholder": { "alias": "filterPlaceholder"; "required": true; "isSignal": true; }; "noResultsFoundLabel": { "alias": "noResultsFoundLabel"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/select/select-list/si-select-list.base.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Copyright Siemens 2016 - 2025.
+ * SPDX-License-Identifier: MIT
+ */
+import { ConfigurableFocusTrap, ConfigurableFocusTrapFactory } from '@angular/cdk/a11y';
+import { ElementRef, OnDestroy, OnInit, TemplateRef } from '@angular/core';
+import { SiSelectOptionsStrategy } from '../options/si-select-options-strategy';
+import { SiSelectSelectionStrategy } from '../selection/si-select-selection-strategy';
+import { SelectGroup, SelectOption } from '../si-select.types';
+import * as i0 from "@angular/core";
+export declare abstract class SiSelectListBase<T> implements OnInit, OnDestroy {
+    readonly baseId: import("@angular/core").InputSignal<string>;
+    readonly optionTemplate: import("@angular/core").InputSignal<TemplateRef<{
+        $implicit: SelectOption<T>;
+    }> | undefined>;
+    readonly groupTemplate: import("@angular/core").InputSignal<TemplateRef<{
+        $implicit: SelectGroup<T>;
+    }> | undefined>;
+    /** @defaultValue null */
+    readonly labelledby: import("@angular/core").InputSignal<string | null>;
+    readonly actionsTemplate: import("@angular/core").InputSignal<TemplateRef<any> | undefined>;
+    readonly closeOverlay: import("@angular/core").OutputEmitterRef<void>;
+    protected readonly selectionStrategy: SiSelectSelectionStrategy<T, T | T[]>;
+    protected readonly selectOptions: SiSelectOptionsStrategy<T>;
+    protected readonly focusTrapFactory: ConfigurableFocusTrapFactory;
+    protected readonly elementRef: ElementRef<any>;
+    protected rows: import("@angular/core").Signal<readonly import("../si-select.types").SelectItem<T>[]>;
+    protected focusTrap: ConfigurableFocusTrap;
+    protected multiSelect: boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    protected keydownTab(): void;
+    protected closeOverlayAlways(): void;
+    protected closeOverlayIfSingle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiSelectListBase<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SiSelectListBase<any>, never, never, { "baseId": { "alias": "baseId"; "required": true; "isSignal": true; }; "optionTemplate": { "alias": "optionTemplate"; "required": false; "isSignal": true; }; "groupTemplate": { "alias": "groupTemplate"; "required": false; "isSignal": true; }; "labelledby": { "alias": "labelledby"; "required": false; "isSignal": true; }; "actionsTemplate": { "alias": "actionsTemplate"; "required": false; "isSignal": true; }; }, { "closeOverlay": "closeOverlay"; }, never, never, true, never>;
+}

package/select/select-list/si-select-list.component.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright Siemens 2016 - 2025.
+ * SPDX-License-Identifier: MIT
+ */
+import { ListboxValueChangeEvent } from '@angular/cdk/listbox';
+import { OnInit } from '@angular/core';
+import { SiSelectListBase } from './si-select-list.base';
+import * as i0 from "@angular/core";
+export declare class SiSelectListComponent<T> extends SiSelectListBase<T> implements OnInit {
+    private readonly listbox;
+    ngOnInit(): void;
+    protected listBoxValueChange(changeEvent: ListboxValueChangeEvent<T>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiSelectListComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SiSelectListComponent<any>, "si-select-list", never, {}, {}, never, never, true, never>;
+}

package/select/select-option/si-select-option-row.component.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright Siemens 2016 - 2025.
+ * SPDX-License-Identifier: MIT
+ */
+import { TemplateRef } from '@angular/core';
+import { SelectOption } from '../si-select.types';
+import * as i0 from "@angular/core";
+export declare class SiSelectOptionRowComponent {
+    readonly option: import("@angular/core").InputSignal<SelectOption<unknown>>;
+    readonly optionTemplate: import("@angular/core").InputSignal<TemplateRef<unknown> | undefined>;
+    /** @defaultValue false */
+    readonly selected: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    protected readonly icons: Record<"elementOk", string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiSelectOptionRowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SiSelectOptionRowComponent, "si-select-option-row", never, { "option": { "alias": "option"; "required": true; "isSignal": true; }; "optionTemplate": { "alias": "optionTemplate"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/select/select-option/si-select-option.component.d.ts

@@ -0,0 +1,9 @@
+import { TemplateRef } from '@angular/core';
+import { SelectOption } from '../si-select.types';
+import * as i0 from "@angular/core";
+export declare class SiSelectOptionComponent {
+    readonly option: import("@angular/core").InputSignal<SelectOption<unknown>>;
+    readonly optionTemplate: import("@angular/core").InputSignal<TemplateRef<unknown> | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiSelectOptionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SiSelectOptionComponent, "si-select-option", never, { "option": { "alias": "option"; "required": true; "isSignal": true; }; "optionTemplate": { "alias": "optionTemplate"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/select/selection/si-select-multi-value.directive.d.ts

@@ -0,0 +1,26 @@
+import { SiSelectSelectionStrategy } from './si-select-selection-strategy';
+import * as i0 from "@angular/core";
+/**
+ * The directive enables the multi-select behavior.
+ * Otherwise, use the {@link SiSelectSingleValueDirective} directive.
+ *
+ * @example
+ * ```html
+ * <si-select multi [(value)]="multiValue" [options]="[
+ *  { id: 'good', title: 'Good' },
+ *  { id: 'average', title: 'Average' },
+ *  { id: 'poor', title: 'Poor' }
+ * ]"></si-select>
+ * ```
+ */
+export declare class SiSelectMultiValueDirective<T> extends SiSelectSelectionStrategy<T, T[]> {
+    /**
+     * {@inheritDoc SiSelectSelectionStrategy#allowMultiple}
+     * @defaultValue true
+     */
+    readonly allowMultiple = true;
+    protected fromArrayValue(value: T[]): T[];
+    protected toArrayValue(value: T[] | undefined): T[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiSelectMultiValueDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SiSelectMultiValueDirective<any>, "si-select[multi]", never, {}, {}, never, never, true, never>;
+}

package/select/selection/si-select-selection-strategy.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Copyright Siemens 2016 - 2025.
+ * SPDX-License-Identifier: MIT
+ */
+import { Signal } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i0 from "@angular/core";
+/**
+ * Selection strategy base class.
+ */
+export declare abstract class SiSelectSelectionStrategy<T, IV = T | T[]> implements ControlValueAccessor {
+    /**
+     * Whether the select input is disabled.
+     *
+     * @defaultValue false
+     */
+    readonly disabledInput: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /**
+     * The selected value(s).
+     */
+    set value(value: IV | undefined);
+    /** Emitted when the selection is changed */
+    readonly valueChange: import("@angular/core").OutputEmitterRef<IV>;
+    /**
+     * Whether the select control allows to select multiple values.
+     * @internal
+     */
+    abstract readonly allowMultiple: boolean;
+    /**
+     * Provides the internal value always as an array
+     * @internal
+     */
+    readonly arrayValue: Signal<readonly T[]>;
+    /**
+     * Registered form callback which shall be called on blur.
+     * @internal
+     */
+    onTouched: () => void;
+    /** @internal */
+    readonly disabled: Signal<boolean>;
+    protected onChange: (_: any) => void;
+    private readonly disabledNgControl;
+    private readonly selectOptions;
+    registerOnTouched(fn: any): void;
+    registerOnChange(fn: any): void;
+    /**
+     * CDK Listbox value changed handler.
+     * @internal
+     */
+    updateFromUser(values: T[]): void;
+    setDisabledState(isDisabled: boolean): void;
+    writeValue(obj: any): void;
+    protected abstract toArrayValue(value: IV | undefined): readonly T[];
+    protected abstract fromArrayValue(value: readonly T[]): IV;
+    private updateFromInput;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiSelectSelectionStrategy<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SiSelectSelectionStrategy<any, any>, never, never, { "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}

package/select/selection/si-select-single-value.directive.d.ts

@@ -0,0 +1,26 @@
+import { SiSelectSelectionStrategy } from './si-select-selection-strategy';
+import * as i0 from "@angular/core";
+/**
+ * The directive enables the single-select behavior.
+ * Otherwise, use the {@link SiSelectMultiValueDirective} directive.
+ *
+ * @example
+ * ```html
+ * <si-select [(value)]="selectedValue" [options]="[
+ *  { id: 'good', title: 'Good' },
+ *  { id: 'average', title: 'Average' },
+ *  { id: 'poor', title: 'Poor' }
+ * ]"></si-select>
+ * ```
+ */
+export declare class SiSelectSingleValueDirective<T> extends SiSelectSelectionStrategy<T, T> {
+    /**
+     * {@inheritDoc SiSelectSelectionStrategy#allowMultiple}
+     * @defaultValue false
+     */
+    allowMultiple: boolean;
+    protected toArrayValue(value: T | undefined): readonly T[];
+    protected fromArrayValue([value]: readonly T[]): T;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiSelectSingleValueDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SiSelectSingleValueDirective<any>, "si-select:not([multi])", never, {}, {}, never, never, true, never>;
+}

package/select/si-select-action.directive.d.ts

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+export declare class SiSelectActionDirective {
+    private readonly select;
+    /**
+     * Close the select drop down on click.
+     * @defaultValue false
+     */
+    readonly selectActionAutoClose: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    protected close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiSelectActionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SiSelectActionDirective, "[siSelectAction]", ["si-select-action"], { "selectActionAutoClose": { "alias": "selectActionAutoClose"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/select/si-select-actions.directive.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class SiSelectActionsDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiSelectActionsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SiSelectActionsDirective, "[siSelectActions]", ["si-select-actions"], {}, {}, never, never, true, never>;
+}

package/select/si-select-group-template.directive.d.ts

@@ -0,0 +1,20 @@
+import { SelectGroup } from './si-select.types';
+import * as i0 from "@angular/core";
+/**
+ * The directive allows to template/customize the group option rendering.
+ * This requires using the {@link SiSelectComplexOptionsDirective} to specify complex options as input.
+ *
+ * @example
+ * ```html
+ * <si-select [complexOptions]="{ g1: ['g1.i1', 'g1.i2'], g2: ['g2.i1'] }" >
+ *   <ng-template siSelectGroupTemplate let-group>{{ group.key | uppercase }}</ng-template>
+ * </si-select>
+ * ```
+ */
+export declare class SiSelectGroupTemplateDirective {
+    static ngTemplateContextGuard<T = any>(directive: SiSelectGroupTemplateDirective, context: unknown): context is {
+        $implicit: SelectGroup<T>;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiSelectGroupTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SiSelectGroupTemplateDirective, "[siSelectGroupTemplate]", never, {}, {}, never, never, true, never>;
+}

package/select/si-select-option-row-template.directive.d.ts

@@ -0,0 +1,9 @@
+import { SelectOption } from './si-select.types';
+import * as i0 from "@angular/core";
+export declare class SiSelectOptionRowTemplateDirective {
+    static ngTemplateContextGuard<T = any>(directive: SiSelectOptionRowTemplateDirective, context: unknown): context is {
+        $implicit: SelectOption<T>;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiSelectOptionRowTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SiSelectOptionRowTemplateDirective, "[siSelectOptionRowTemplate]", never, {}, {}, never, never, true, never>;
+}

package/select/si-select-option-template.directive.d.ts

@@ -0,0 +1,21 @@
+import { SelectOption } from './si-select.types';
+import * as i0 from "@angular/core";
+/**
+ * The directive allows to template/customize the value option rendering.
+ * This requires using the {@link SiSelectComplexOptionsDirective} to specify complex options as input.
+ *
+ * @example
+ * ```html
+ * <si-select [options]="[{ id: 'good', title: 'Good' }, { id: 'fair', title: 'Fair' }, { id: 'bad', title: 'Bad' }]" >
+ *   <ng-template siSelectOptionTemplate let-option>{{ option.value | uppercase }}</ng-template>
+ * </si-select>
+ * ```
+ */
+export declare class SiSelectOptionTemplateDirective {
+    /** @internal */
+    static ngTemplateContextGuard<T = any>(directive: SiSelectOptionTemplateDirective, context: unknown): context is {
+        $implicit: SelectOption<T>;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiSelectOptionTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SiSelectOptionTemplateDirective, "[siSelectOptionTemplate]", never, {}, {}, never, never, true, never>;
+}