@i-cell/ids-angular 0.0.0-watch

package/paginator/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/i-cell-ids-angular-paginator.mjs"
+}

package/radio/index.d.ts

@@ -0,0 +1,95 @@
+import * as _angular_core from '@angular/core';
+import { OnInit, InjectionToken, AfterContentChecked } from '@angular/core';
+import { ComponentBase, IdsSizeType, IdsOrientationType, IdsPositionType, ComponentBaseWithDefaults } from '@i-cell/ids-angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+
+declare const IdsRadioVariant: {
+    readonly SURFACE: "surface";
+    readonly LIGHT: "light";
+    readonly DARK: "dark";
+};
+type IdsRadioVariantType = (typeof IdsRadioVariant)[keyof typeof IdsRadioVariant];
+
+declare class IdsRadioComponent extends ComponentBase implements OnInit {
+    protected get _hostName(): string;
+    private _group;
+    selected: _angular_core.WritableSignal<boolean>;
+    inputId: _angular_core.InputSignal<string>;
+    value: _angular_core.InputSignal<unknown>;
+    ariaLabel: _angular_core.InputSignal<string>;
+    ariaLabelledBy: _angular_core.InputSignal<string>;
+    ariaDescribedBy: _angular_core.InputSignal<string>;
+    tabIndex: _angular_core.InputSignalWithTransform<number, unknown>;
+    disabled: _angular_core.InputSignal<boolean>;
+    protected _isDisabled: _angular_core.Signal<boolean | undefined>;
+    protected _name: _angular_core.Signal<string | undefined>;
+    protected _required: _angular_core.Signal<boolean | undefined>;
+    protected _ariaChecked: _angular_core.Signal<boolean>;
+    protected _hostClasses: _angular_core.Signal<string>;
+    private _inputElement;
+    readonly changes: _angular_core.OutputEmitterRef<IdsRadioChangeEvent>;
+    ngOnInit(): void;
+    onChange(): void;
+    protected _touchTargetClick(): void;
+    protected _innerCircleClick(): void;
+    focus(options?: FocusOptions): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsRadioComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IdsRadioComponent, "ids-radio", never, { "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledBy": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "ariaDescribedBy": { "alias": "aria-describedby"; "required": false; "isSignal": true; }; "tabIndex": { "alias": "tabIndex"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "changes": "changes"; }, never, ["*"], true, never>;
+}
+
+declare class IdsRadioChangeEvent {
+    source: IdsRadioComponent;
+    value: unknown;
+    constructor(source: IdsRadioComponent, value: unknown);
+}
+
+interface IdsRadioDefaultConfig {
+    size?: IdsSizeType;
+    variant?: IdsRadioVariantType;
+    orientation?: IdsOrientationType;
+    labelPosition?: IdsPositionType;
+}
+declare const IDS_RADIO_DEFAULT_CONFIG: InjectionToken<IdsRadioDefaultConfig>;
+declare function IDS_RADIO_DEFAULT_CONFIG_FACTORY(): Required<IdsRadioDefaultConfig>;
+
+declare class IdsRadioGroupDirective extends ComponentBaseWithDefaults<IdsRadioDefaultConfig> implements OnInit, AfterContentChecked, ControlValueAccessor {
+    protected get _hostName(): string;
+    protected readonly _defaultConfig: Required<IdsRadioDefaultConfig>;
+    private _selectionModel?;
+    private _rawValue;
+    private _items;
+    name: _angular_core.InputSignal<string>;
+    required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    size: _angular_core.InputSignal<IdsSizeType>;
+    variant: _angular_core.InputSignal<IdsRadioVariantType>;
+    orientation: _angular_core.InputSignal<IdsOrientationType>;
+    labelPosition: _angular_core.InputSignal<IdsPositionType>;
+    isDisabled: _angular_core.WritableSignal<boolean>;
+    protected _hostClasses: _angular_core.Signal<string>;
+    private _onChange;
+    private _onTouched;
+    valueCompareFn?: (o1: IdsRadioComponent, o2: IdsRadioComponent) => boolean;
+    set disabled(value: boolean);
+    readonly itemChanges: _angular_core.OutputEmitterRef<IdsRadioChangeEvent>;
+    private _handleKeyDown;
+    ngOnInit(): void;
+    ngAfterContentChecked(): void;
+    writeValue(value: unknown | unknown[]): void;
+    registerOnChange(fn: () => void): void;
+    registerOnTouched(fn: () => unknown): void;
+    setDisabledState?(isDisabled: boolean): void;
+    private _subscribeItemChanges;
+    private _handleItemChanges;
+    private _setSelectionByValue;
+    private _selectValue;
+    private _clearSelection;
+    private _handleChange;
+    isItemPreSelectedByValue(itemValue: unknown): boolean;
+    private _hasInvalidLabelPosition;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsRadioGroupDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IdsRadioGroupDirective, "ids-radio-group", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "labelPosition": { "alias": "labelPosition"; "required": false; "isSignal": true; }; "valueCompareFn": { "alias": "valueCompareFn"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "itemChanges": "itemChanges"; }, ["_items"], never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+export { IDS_RADIO_DEFAULT_CONFIG, IDS_RADIO_DEFAULT_CONFIG_FACTORY, IdsRadioChangeEvent, IdsRadioComponent, IdsRadioGroupDirective, IdsRadioVariant };
+export type { IdsRadioDefaultConfig, IdsRadioVariantType };

package/radio/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/i-cell-ids-angular-radio.mjs"
+}

package/segmented-control/index.d.ts

@@ -0,0 +1,98 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, AfterContentInit, OnInit } from '@angular/core';
+import { IdsSizeType, ComponentBaseWithDefaults, ComponentBase } from '@i-cell/ids-angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+
+declare const IdsSegmentedControlAppearance: {
+    readonly OUTLINED: "outlined";
+};
+type IdsSegmentedControlAppearanceType = (typeof IdsSegmentedControlAppearance)[keyof typeof IdsSegmentedControlAppearance];
+
+declare const IdsSegmentedControlVariant: {
+    readonly PRIMARY: "primary";
+    readonly SURFACE: "surface";
+    readonly LIGHT: "light";
+};
+type IdsSegmentedControlVariantType = (typeof IdsSegmentedControlVariant)[keyof typeof IdsSegmentedControlVariant];
+
+interface IdsSegmentedControlDefaultConfig {
+    appearance?: IdsSegmentedControlAppearanceType;
+    size?: IdsSizeType;
+    variant?: IdsSegmentedControlVariantType;
+}
+declare const IDS_SEGMENTED_CONTROL_DEFAULT_CONFIG: InjectionToken<IdsSegmentedControlDefaultConfig>;
+declare function IDS_SEGMENTED_CONTROL_DEFAULT_CONFIG_FACTORY(): Required<IdsSegmentedControlDefaultConfig>;
+
+declare class IdsSegmentedControlDirective extends ComponentBaseWithDefaults<IdsSegmentedControlDefaultConfig> implements AfterContentInit, OnInit, ControlValueAccessor {
+    protected get _hostName(): string;
+    protected readonly _defaultConfig: Required<IdsSegmentedControlDefaultConfig>;
+    private _selectionModel?;
+    private _rawValue;
+    private _items;
+    name: _angular_core.InputSignal<string | undefined>;
+    size: _angular_core.InputSignal<IdsSizeType>;
+    variant: _angular_core.InputSignal<IdsSegmentedControlVariantType>;
+    appearance: _angular_core.InputSignal<"outlined">;
+    multiSelect: _angular_core.InputSignal<boolean>;
+    disabled: _angular_core.WritableSignal<boolean>;
+    protected _hostClasses: _angular_core.Signal<string>;
+    private _onChange;
+    private _onTouched;
+    valueCompareFn?: (o1: IdsSegmentedControlItemComponent, o2: IdsSegmentedControlItemComponent) => boolean;
+    readonly itemChanges: _angular_core.OutputEmitterRef<IdsSegmentedControlItemChange>;
+    private _handleKeyDown;
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    writeValue(value: unknown | unknown[]): void;
+    registerOnChange(fn: () => void): void;
+    registerOnTouched(fn: () => unknown): void;
+    setDisabledState?(isDisabled: boolean): void;
+    private _subscribeItemChanges;
+    private _handleItemChanges;
+    private _setSelectionByValue;
+    private _selectValue;
+    private _clearSelection;
+    private _handleChange;
+    isItemPreSelectedByValue(itemValue: unknown): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsSegmentedControlDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IdsSegmentedControlDirective, "ids-segmented-control[ngModel]:not([formControl]):not([formControlName]),             ids-segmented-control[formControl]:not([ngModel]):not([formControlName]),             ids-segmented-control[formControlName]:not([ngModel]):not([formControl])", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "multiSelect": { "alias": "multiSelect"; "required": false; "isSignal": true; }; "valueCompareFn": { "alias": "valueCompareFn"; "required": false; }; }, { "itemChanges": "itemChanges"; }, ["_items"], never, true, never>;
+}
+
+declare class IdsSegmentedControlItemComponent extends ComponentBase implements OnInit {
+    protected get _hostName(): string;
+    protected readonly _group: IdsSegmentedControlDirective | null;
+    private _buttonElement;
+    selected: _angular_core.WritableSignal<boolean>;
+    name: _angular_core.InputSignal<string | undefined>;
+    value: _angular_core.InputSignal<unknown>;
+    label: _angular_core.InputSignal<string | undefined>;
+    ariaLabel: _angular_core.InputSignal<string>;
+    ariaLabelledBy: _angular_core.InputSignal<string>;
+    tabIndex: _angular_core.InputSignalWithTransform<number, unknown>;
+    disabled: _angular_core.InputSignal<boolean>;
+    protected _buttonId: _angular_core.Signal<string>;
+    protected _parentOrSelfDisabled: _angular_core.Signal<boolean | undefined>;
+    protected _multiSelect: _angular_core.Signal<boolean | undefined>;
+    protected _ariaPressed: _angular_core.Signal<boolean | null>;
+    protected _ariaChecked: _angular_core.Signal<boolean | null>;
+    protected _role: _angular_core.Signal<"button" | "radio">;
+    protected _buttonName: _angular_core.Signal<string | undefined>;
+    protected _buttonClasses: _angular_core.Signal<string | null>;
+    protected _hostClasses: _angular_core.Signal<string>;
+    readonly changes: _angular_core.OutputEmitterRef<IdsSegmentedControlItemChange>;
+    ngOnInit(): void;
+    onClick(): void;
+    focus(options?: FocusOptions): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsSegmentedControlItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IdsSegmentedControlItemComponent, "ids-segmented-control-item", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledBy": { "alias": "aria-labeledby"; "required": false; "isSignal": true; }; "tabIndex": { "alias": "tabIndex"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "changes": "changes"; }, never, ["ids-icon", "[suffixContent]"], true, never>;
+}
+
+declare class IdsSegmentedControlItemChange {
+    source: IdsSegmentedControlItemComponent;
+    selected: boolean;
+    value: unknown;
+    constructor(source: IdsSegmentedControlItemComponent, selected: boolean, value: unknown);
+}
+
+export { IDS_SEGMENTED_CONTROL_DEFAULT_CONFIG, IDS_SEGMENTED_CONTROL_DEFAULT_CONFIG_FACTORY, IdsSegmentedControlAppearance, IdsSegmentedControlDirective, IdsSegmentedControlItemChange, IdsSegmentedControlItemComponent, IdsSegmentedControlVariant };
+export type { IdsSegmentedControlAppearanceType, IdsSegmentedControlDefaultConfig, IdsSegmentedControlVariantType };

package/segmented-control/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/i-cell-ids-angular-segmented-control.mjs"
+}

package/segmented-control-toggle/index.d.ts

@@ -0,0 +1,103 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, AfterContentInit, OnInit } from '@angular/core';
+import { IdsSizeType, ComponentBaseWithDefaults, ComponentBase } from '@i-cell/ids-angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+
+declare const IdsSegmentedControlToggleAppearance: {
+    readonly FILLED: "filled";
+    readonly OUTLINED: "outlined";
+};
+type IdsSegmentedControlToggleAppearanceType = (typeof IdsSegmentedControlToggleAppearance)[keyof typeof IdsSegmentedControlToggleAppearance];
+
+declare const IdsSegmentedControlToggleVariant: {
+    readonly SURFACE: "surface";
+    readonly LIGHT: "light";
+};
+type IdsSegmentedControlToggleVariantType = (typeof IdsSegmentedControlToggleVariant)[keyof typeof IdsSegmentedControlToggleVariant];
+declare const IdsSegmentedControlToggleButtonVariant: {
+    readonly PRIMARY: "primary";
+    readonly SURFACE: "surface";
+    readonly LIGHT: "light";
+};
+type IdsSegmentedControlToggleButtonVariantType = (typeof IdsSegmentedControlToggleButtonVariant)[keyof typeof IdsSegmentedControlToggleButtonVariant];
+
+interface IdsSegmentedControlToggleDefaultConfig {
+    appearance?: IdsSegmentedControlToggleAppearanceType;
+    size?: IdsSizeType;
+    variant?: IdsSegmentedControlToggleVariantType;
+    buttonVariant?: IdsSegmentedControlToggleButtonVariantType;
+}
+declare const IDS_SEGMENTED_CONTROL_TOGGLE_DEFAULT_CONFIG: InjectionToken<IdsSegmentedControlToggleDefaultConfig>;
+declare function IDS_SEGMENTED_CONTROL_TOGGLE_DEFAULT_CONFIG_FACTORY(): Required<IdsSegmentedControlToggleDefaultConfig>;
+
+declare class IdsSegmentedControlToggleDirective extends ComponentBaseWithDefaults<IdsSegmentedControlToggleDefaultConfig> implements AfterContentInit, OnInit, ControlValueAccessor {
+    protected get _hostName(): string;
+    protected readonly _defaultConfig: Required<IdsSegmentedControlToggleDefaultConfig>;
+    private _selectionModel?;
+    private _rawValue;
+    private _items;
+    name: _angular_core.InputSignal<string | undefined>;
+    size: _angular_core.InputSignal<IdsSizeType>;
+    variant: _angular_core.InputSignal<IdsSegmentedControlToggleVariantType>;
+    buttonVariant: _angular_core.InputSignal<IdsSegmentedControlToggleButtonVariantType>;
+    appearance: _angular_core.InputSignal<IdsSegmentedControlToggleAppearanceType>;
+    disabled: _angular_core.WritableSignal<boolean>;
+    protected _hostClasses: _angular_core.Signal<string>;
+    private _onChange;
+    private _onTouched;
+    valueCompareFn?: (o1: IdsSegmentedControlToggleItemComponent, o2: IdsSegmentedControlToggleItemComponent) => boolean;
+    readonly itemChanges: _angular_core.OutputEmitterRef<IdsSegmentedControlToggleItemChange>;
+    private _handleKeyDown;
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    writeValue(value: unknown | unknown[]): void;
+    registerOnChange(fn: () => void): void;
+    registerOnTouched(fn: () => unknown): void;
+    setDisabledState?(isDisabled: boolean): void;
+    private _subscribeItemChanges;
+    private _handleItemChanges;
+    private _setSelectionByValue;
+    private _selectValue;
+    private _clearSelection;
+    private _handleChange;
+    isItemPreSelectedByValue(itemValue: unknown): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsSegmentedControlToggleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IdsSegmentedControlToggleDirective, "ids-segmented-control-toggle[ngModel]:not([formControl]):not([formControlName]),             ids-segmented-control-toggle[formControl]:not([ngModel]):not([formControlName]),             ids-segmented-control-toggle[formControlName]:not([ngModel]):not([formControl])", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "buttonVariant": { "alias": "buttonVariant"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "valueCompareFn": { "alias": "valueCompareFn"; "required": false; }; }, { "itemChanges": "itemChanges"; }, ["_items"], never, true, never>;
+}
+
+declare class IdsSegmentedControlToggleItemComponent extends ComponentBase implements OnInit {
+    protected get _hostName(): string;
+    protected readonly _group: IdsSegmentedControlToggleDirective | null;
+    private _buttonElement;
+    selected: _angular_core.WritableSignal<boolean>;
+    name: _angular_core.InputSignal<string | undefined>;
+    value: _angular_core.InputSignal<unknown>;
+    label: _angular_core.InputSignal<string | undefined>;
+    ariaLabel: _angular_core.InputSignal<string>;
+    ariaLabelledBy: _angular_core.InputSignal<string>;
+    tabIndex: _angular_core.InputSignalWithTransform<number, unknown>;
+    disabled: _angular_core.InputSignal<boolean>;
+    protected _buttonId: _angular_core.Signal<string>;
+    protected _parentOrSelfDisabled: _angular_core.Signal<boolean | undefined>;
+    protected _ariaPressed: _angular_core.WritableSignal<null>;
+    protected _ariaChecked: _angular_core.Signal<boolean>;
+    protected _role: _angular_core.WritableSignal<string>;
+    protected _buttonName: _angular_core.Signal<string | undefined>;
+    protected _buttonClasses: _angular_core.Signal<string | null>;
+    protected _hostClasses: _angular_core.Signal<string>;
+    readonly changes: _angular_core.OutputEmitterRef<IdsSegmentedControlToggleItemChange>;
+    ngOnInit(): void;
+    onClick(): void;
+    focus(options?: FocusOptions): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsSegmentedControlToggleItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IdsSegmentedControlToggleItemComponent, "ids-segmented-control-toggle-item", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledBy": { "alias": "aria-labeledby"; "required": false; "isSignal": true; }; "tabIndex": { "alias": "tabIndex"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "changes": "changes"; }, never, ["ids-icon", "[suffixContent]"], true, never>;
+}
+
+declare class IdsSegmentedControlToggleItemChange {
+    source: IdsSegmentedControlToggleItemComponent;
+    value: unknown;
+    constructor(source: IdsSegmentedControlToggleItemComponent, value: unknown);
+}
+
+export { IDS_SEGMENTED_CONTROL_TOGGLE_DEFAULT_CONFIG, IDS_SEGMENTED_CONTROL_TOGGLE_DEFAULT_CONFIG_FACTORY, IdsSegmentedControlToggleAppearance, IdsSegmentedControlToggleButtonVariant, IdsSegmentedControlToggleDirective, IdsSegmentedControlToggleItemChange, IdsSegmentedControlToggleItemComponent, IdsSegmentedControlToggleVariant };
+export type { IdsSegmentedControlToggleAppearanceType, IdsSegmentedControlToggleButtonVariantType, IdsSegmentedControlToggleDefaultConfig, IdsSegmentedControlToggleVariantType };

package/segmented-control-toggle/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/i-cell-ids-angular-segmented-control-toggle.mjs"
+}

package/select/index.d.ts

@@ -0,0 +1,103 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, OnInit, AfterContentInit, AfterViewInit, OnDestroy, ElementRef } from '@angular/core';
+import * as _i_cell_ids_angular_forms from '@i-cell/ids-angular/forms';
+import { AbstractErrorStateMatcher, AbstractSuccessStateMatcher, IdsFormFieldControl, IdsOptionComponent, IdsOptionGroupComponent } from '@i-cell/ids-angular/forms';
+import * as _i_cell_ids_angular_core from '@i-cell/ids-angular/core';
+import * as _angular_cdk_overlay from '@angular/cdk/overlay';
+import { CdkOverlayOrigin } from '@angular/cdk/overlay';
+import { ControlValueAccessor } from '@angular/forms';
+
+interface IdsSelectDefaultConfig {
+    errorStateMatcher?: typeof AbstractErrorStateMatcher;
+    successStateMatcher?: typeof AbstractSuccessStateMatcher;
+    typeaheadDebounceInterval: number;
+}
+declare const IDS_SELECT_DEFAULT_CONFIG: InjectionToken<IdsSelectDefaultConfig>;
+declare function IDS_SELECT_DEFAULT_CONFIG_FACTORY(): Required<IdsSelectDefaultConfig>;
+
+declare class IdsSelectTriggerDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsSelectTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IdsSelectTriggerDirective, "ids-select-trigger", never, {}, {}, never, never, true, never>;
+}
+
+declare class IdsSelectComponent extends IdsFormFieldControl<IdsSelectDefaultConfig> implements ControlValueAccessor, OnInit, AfterContentInit, AfterViewInit, OnDestroy {
+    protected get _hostName(): string;
+    protected readonly _defaultConfig: Required<IdsSelectDefaultConfig>;
+    protected readonly _elementRef: ElementRef<any>;
+    private readonly _changeDetectorRef;
+    private readonly _liveAnnouncer;
+    private readonly _parentFormField;
+    protected readonly _connectedPositions: _angular_cdk_overlay.ConnectedPosition[];
+    protected _preferredOverlayOrigin: CdkOverlayOrigin | ElementRef | undefined;
+    protected _overlayWidth: string | number;
+    multiSelect: _angular_core.InputSignal<boolean>;
+    readonly errorStateMatcher: _angular_core.InputSignal<AbstractErrorStateMatcher>;
+    readonly successStateMatcher: _angular_core.InputSignal<AbstractSuccessStateMatcher>;
+    ariaLabel: _angular_core.InputSignal<string>;
+    ariaLabelledby: _angular_core.InputSignal<string>;
+    valueCompareFn: _angular_core.InputSignal<(o1: unknown, o2: unknown) => boolean>;
+    sortCompareFn: _angular_core.InputSignal<((a: IdsOptionComponent, b: IdsOptionComponent, options: Readonly<IdsOptionComponent[]>) => number) | undefined>;
+    tabIndex: _angular_core.InputSignalWithTransform<number, unknown>;
+    typeaheadDebounceInterval: _angular_core.InputSignalWithTransform<number, unknown>;
+    isPanelOpen: _angular_core.WritableSignal<boolean>;
+    parentSize: _angular_core.Signal<_i_cell_ids_angular_core.IdsSizeType>;
+    parentVariant: _angular_core.Signal<_i_cell_ids_angular_forms.IdsFormFieldVariantType>;
+    private _focused;
+    private _canOpen;
+    protected _hostClasses: _angular_core.Signal<string>;
+    protected _panelClasses: _angular_core.Signal<string>;
+    private _panel;
+    private _overlayDir;
+    options: _angular_core.Signal<readonly IdsOptionComponent<unknown>[]>;
+    optionGroups: _angular_core.Signal<readonly IdsOptionGroupComponent[]>;
+    protected _customTrigger: _angular_core.Signal<IdsSelectTriggerDirective | undefined>;
+    private _keyManager?;
+    private _rawValue;
+    private _selectionModel?;
+    private _onChange;
+    private _onTouched;
+    protected get _empty(): boolean;
+    get selected(): IdsOptionComponent | IdsOptionComponent[] | undefined;
+    protected get _triggerValue(): string;
+    constructor();
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    updateErrorAndSuccessState(): void;
+    ngOnDestroy(): void;
+    private _initKeyManager;
+    private _subscribeOptionChanges;
+    private _handleOptionChange;
+    protected _handleKeydown(event: KeyboardEvent): void;
+    private _handleClosedPanelKeydown;
+    private _handleOpenedPanelKeydown;
+    private _positioningSettled;
+    private _scrollOptionIntoView;
+    private _sortValues;
+    private _getOverlayWidth;
+    protected _panelAttached(): void;
+    toggle(): void;
+    open(): void;
+    close(): void;
+    writeValue(value: unknown | unknown[]): void;
+    registerOnChange(fn: () => void): void;
+    registerOnTouched(fn: () => unknown): void;
+    setDisabledState(isDisabled: boolean): void;
+    private _setSelectionByValue;
+    private _selectValue;
+    private _clearSelection;
+    private _handleChange;
+    private _skipPredicate;
+    private _highlightCorrectOption;
+    isOptionPreSelectedByValue(optionValue: unknown): boolean;
+    private _onFocus;
+    private _onBlur;
+    private _getAriaActiveDescendant;
+    focus(options?: FocusOptions): void;
+    onContainerClick: () => void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IdsSelectComponent, "ids-select[ngModel]:not([formControl]):not([formControlName]),              ids-select[formControl]:not([ngModel]):not([formControlName]),              ids-select[formControlName]:not([ngModel]):not([formControl])", never, { "multiSelect": { "alias": "multiSelect"; "required": false; "isSignal": true; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; "isSignal": true; }; "successStateMatcher": { "alias": "successStateMatcher"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "valueCompareFn": { "alias": "valueCompareFn"; "required": false; "isSignal": true; }; "sortCompareFn": { "alias": "sortCompareFn"; "required": false; "isSignal": true; }; "tabIndex": { "alias": "tabIndex"; "required": false; "isSignal": true; }; "typeaheadDebounceInterval": { "alias": "typeaheadDebounceInterval"; "required": false; "isSignal": true; }; }, {}, ["options", "optionGroups", "_customTrigger"], ["ids-select-trigger", "*"], true, never>;
+}
+
+export { IDS_SELECT_DEFAULT_CONFIG, IDS_SELECT_DEFAULT_CONFIG_FACTORY, IdsSelectComponent, IdsSelectTriggerDirective };
+export type { IdsSelectDefaultConfig };

package/select/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/i-cell-ids-angular-select.mjs"
+}

package/side-nav/index.d.ts

@@ -0,0 +1,107 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, TemplateRef } from '@angular/core';
+import { IdsSizeType, ComponentBaseWithDefaults } from '@i-cell/ids-angular/core';
+import * as _i_cell_ids_angular_side_nav from '@i-cell/ids-angular/side-nav';
+import { IdsIconComponent } from '@i-cell/ids-angular/icon';
+import { IdsIconButtonParent, IdsIconButtonAppearanceType, IdsIconButtonVariantType } from '@i-cell/ids-angular/icon-button';
+
+declare const IdsSideNavVariant: {
+    readonly SURFACE: "surface";
+    readonly LIGHT: "light";
+};
+type IdsSideNavVariantType = (typeof IdsSideNavVariant)[keyof typeof IdsSideNavVariant];
+
+declare const IdsSideNavAppearance: {
+    readonly STANDARD: "standard";
+};
+type IdsSideNavAppearanceType = (typeof IdsSideNavAppearance)[keyof typeof IdsSideNavAppearance];
+
+interface IdsSideNavDefaultConfig {
+    appearance?: IdsSideNavAppearanceType;
+    size?: IdsSizeType;
+    variant?: IdsSideNavVariantType;
+    hasActiveIndicator?: boolean;
+    hasLabel?: boolean;
+}
+declare const IDS_SIDE_NAV_DEFAULT_CONFIG: InjectionToken<IdsSideNavDefaultConfig>;
+declare function IDS_SIDE_NAV_DEFAULT_CONFIG_FACTORY(): Required<IdsSideNavDefaultConfig>;
+
+/**
+ * Side navigation item
+ * - it can be a single list element or an expandable list element, containing another list of elements
+ * - it can be used with selectors like `ids-side-nav-item` or `li[idsSideNavItem]`
+ * - children can be provided with content projection:
+ *    - either project `ids-side-nav-item` elements
+ *    - or list elements as `<li>` elements in an ng-template, marked with `idsSideNavItemChildren` variable
+ */
+declare class IdsSideNavItemComponent {
+    disabled: _angular_core.InputSignalWithTransform<boolean, string | boolean>;
+    label: _angular_core.InputSignal<string>;
+    target: _angular_core.InputSignal<string>;
+    templateChildren: _angular_core.InputSignal<TemplateRef<HTMLElement> | undefined>;
+    protected _active: _angular_core.Signal<boolean>;
+    protected _expandable: _angular_core.Signal<true | TemplateRef<any> | undefined>;
+    protected _expanded: boolean;
+    protected _iconLeading: _angular_core.Signal<readonly IdsIconComponent[]>;
+    protected _iconTrailing: _angular_core.Signal<readonly IdsIconComponent[]>;
+    protected readonly _parent: _i_cell_ids_angular_side_nav.IdsSideNavComponent | null;
+    protected readonly _contentTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
+    private readonly _contentChildren;
+    private readonly _router;
+    protected _onClick(event: MouseEvent): void;
+    protected _onKeyDown(event: KeyboardEvent): void;
+    protected _toggle(): void;
+    protected _navigate(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsSideNavItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IdsSideNavItemComponent, "ids-side-nav-item, li[idsSideNavItem]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": true; "isSignal": true; }; "target": { "alias": "target"; "required": false; "isSignal": true; }; "templateChildren": { "alias": "templateChildren"; "required": false; "isSignal": true; }; }, {}, ["_iconLeading", "_iconTrailing", "_contentTemplate", "_contentChildren"], ["[icon-leading]", "[icon-trailing]", "ids-side-nav-item,[idsSideNavItem]", "ng-template"], true, never>;
+}
+
+/**
+ * Side navigation (section) title
+ * - title of the navigation section
+ * - it can be used with selectors like `ids-side-nav-title` or `li[idsSideNavTitle]`
+ * - leading and trailing icons should be projected, label is bound by input
+ */
+declare class IdsSideNavTitleComponent {
+    label: _angular_core.InputSignal<string>;
+    protected _iconLeading: _angular_core.Signal<readonly IdsIconComponent[]>;
+    protected _iconTrailing: _angular_core.Signal<readonly IdsIconComponent[]>;
+    protected readonly _parent: _i_cell_ids_angular_side_nav.IdsSideNavComponent | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsSideNavTitleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IdsSideNavTitleComponent, "ids-side-nav-title, li[idsSideNavTitle]", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; }, {}, ["_iconLeading", "_iconTrailing"], ["[icon-leading]", "[icon-trailing]"], true, never>;
+}
+
+/**
+ * Side navigation section
+ * - section wrapper inside the navigation
+ * - it can be used with selectors like `ids-side-nav-section` or `li[idsSideNavSection]`
+ * - content should be projected
+ */
+declare class IdsSideNavSectionComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsSideNavSectionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IdsSideNavSectionComponent, "ids-side-nav-section, ul[idsSideNavSection]", never, {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Side navigation
+ * - wrapper element for side navigation elements (sections, then title and items as part of section)
+ * - content should be projected
+ */
+declare class IdsSideNavComponent extends ComponentBaseWithDefaults<IdsSideNavDefaultConfig> implements IdsIconButtonParent {
+    protected get _hostName(): string;
+    protected readonly _defaultConfig: Required<IdsSideNavDefaultConfig>;
+    appearance: _angular_core.InputSignal<"standard">;
+    size: _angular_core.InputSignal<IdsSizeType>;
+    variant: _angular_core.InputSignal<IdsSideNavVariantType>;
+    hasLabel: _angular_core.InputSignal<boolean>;
+    hasActiveIndicator: _angular_core.InputSignal<boolean>;
+    embeddedIconButtonAppearance: _angular_core.Signal<IdsIconButtonAppearanceType>;
+    embeddedIconButtonVariant: _angular_core.Signal<IdsIconButtonVariantType>;
+    embeddedIconButtonSize: _angular_core.Signal<IdsSizeType>;
+    protected _hostClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsSideNavComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IdsSideNavComponent, "nav[idsSideNav]", never, { "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "hasLabel": { "alias": "hasLabel"; "required": false; "isSignal": true; }; "hasActiveIndicator": { "alias": "hasActiveIndicator"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { IDS_SIDE_NAV_DEFAULT_CONFIG, IDS_SIDE_NAV_DEFAULT_CONFIG_FACTORY, IdsSideNavAppearance, IdsSideNavComponent, IdsSideNavItemComponent, IdsSideNavSectionComponent, IdsSideNavTitleComponent, IdsSideNavVariant };
+export type { IdsSideNavAppearanceType, IdsSideNavDefaultConfig, IdsSideNavVariantType };

package/side-nav/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/i-cell-ids-angular-side-nav.mjs"
+}

package/side-sheet/index.d.ts

@@ -0,0 +1,84 @@
+import * as _i_cell_ids_angular_side_sheet from '@i-cell/ids-angular/side-sheet';
+import * as _angular_core from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { IdsSizeType, ComponentBaseWithDefaults } from '@i-cell/ids-angular/core';
+
+declare const IdsSideSheetType: {
+    readonly OVERLAY: "overlay";
+    readonly INLINE: "inline";
+};
+type IdsSideSheetTypeType = (typeof IdsSideSheetType)[keyof typeof IdsSideSheetType];
+declare const IdsSideSheetPosition: {
+    readonly LEFT: "left";
+    readonly RIGHT: "right";
+};
+type IdsSideSheetPositionType = (typeof IdsSideSheetPosition)[keyof typeof IdsSideSheetPosition];
+declare const IdsSideSheetHeader: {
+    readonly DEFAULT: "default";
+    readonly CUSTOM: "custom";
+};
+declare const IdsBackdropType: {
+    readonly DEFAULT: "default";
+    readonly TRANSPARENT: "transparent";
+};
+type IdsBackdropTypeType = (typeof IdsBackdropType)[keyof typeof IdsBackdropType];
+type IdsSideSheetHeaderType = (typeof IdsSideSheetHeader)[keyof typeof IdsSideSheetHeader];
+
+interface IdsSideSheetDefaultConfig {
+    type: IdsSideSheetTypeType;
+    position: IdsSideSheetPositionType;
+    header: IdsSideSheetHeaderType;
+    isScrollable: boolean;
+    isBackdrop: boolean;
+    backdropType: IdsBackdropTypeType;
+    backdropOpacity: IdsSizeType;
+    isClosable: boolean;
+    isShowFooter: boolean;
+    isShowHeader: boolean;
+    isStatic: boolean;
+    closeTooltipText: string;
+    size: IdsSizeType;
+}
+declare const IDS_SIDE_SHEET_DEFAULT_CONFIG: InjectionToken<IdsSideSheetDefaultConfig>;
+declare function IDS_SIDE_SHEET_DEFAULT_CONFIG_FACTORY(): Required<IdsSideSheetDefaultConfig>;
+
+declare class IdsSideSheetComponent extends ComponentBaseWithDefaults<IdsSideSheetDefaultConfig> {
+    protected get _hostName(): string;
+    protected _idsSideSheetType: {
+        readonly OVERLAY: "overlay";
+        readonly INLINE: "inline";
+    };
+    protected _idsSideSheetHeaderType: {
+        readonly DEFAULT: "default";
+        readonly CUSTOM: "custom";
+    };
+    protected _idsSideSheetPositionType: {
+        readonly LEFT: "left";
+        readonly RIGHT: "right";
+    };
+    open: _angular_core.InputSignal<boolean>;
+    closed: _angular_core.OutputEmitterRef<void>;
+    backClicked: _angular_core.OutputEmitterRef<void>;
+    protected readonly _defaultConfig: Required<IdsSideSheetDefaultConfig>;
+    title: _angular_core.InputSignal<string>;
+    type: _angular_core.InputSignal<string>;
+    position: _angular_core.InputSignal<string>;
+    header: _angular_core.InputSignal<_i_cell_ids_angular_side_sheet.IdsSideSheetHeaderType>;
+    backButton: _angular_core.InputSignal<boolean>;
+    isBackdrop: _angular_core.InputSignal<boolean>;
+    backdropType: _angular_core.InputSignal<string>;
+    backdropOpacity: _angular_core.InputSignal<string>;
+    isScrollable: _angular_core.InputSignal<boolean>;
+    isClosable: _angular_core.InputSignal<boolean>;
+    isShowHeader: _angular_core.InputSignal<boolean>;
+    closeTooltipText: _angular_core.InputSignal<string>;
+    size: _angular_core.InputSignal<string>;
+    protected _close(): void;
+    protected _onBack(): void;
+    protected _hostClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsSideSheetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IdsSideSheetComponent, "ids-side-sheet", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "header": { "alias": "header"; "required": false; "isSignal": true; }; "backButton": { "alias": "backButton"; "required": false; "isSignal": true; }; "isBackdrop": { "alias": "isBackdrop"; "required": false; "isSignal": true; }; "backdropType": { "alias": "backdropType"; "required": false; "isSignal": true; }; "backdropOpacity": { "alias": "backdropOpacity"; "required": false; "isSignal": true; }; "isScrollable": { "alias": "isScrollable"; "required": false; "isSignal": true; }; "isClosable": { "alias": "isClosable"; "required": false; "isSignal": true; }; "isShowHeader": { "alias": "isShowHeader"; "required": false; "isSignal": true; }; "closeTooltipText": { "alias": "closeTooltipText"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "closed": "closed"; "backClicked": "backClicked"; }, never, ["*", "[slot='customHeader']", "[slot='footer']"], true, never>;
+}
+
+export { IDS_SIDE_SHEET_DEFAULT_CONFIG, IDS_SIDE_SHEET_DEFAULT_CONFIG_FACTORY, IdsBackdropType, IdsSideSheetComponent, IdsSideSheetHeader, IdsSideSheetPosition, IdsSideSheetType };
+export type { IdsBackdropTypeType, IdsSideSheetDefaultConfig, IdsSideSheetHeaderType, IdsSideSheetPositionType, IdsSideSheetTypeType };

package/side-sheet/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/i-cell-ids-angular-side-sheet.mjs"
+}