@i-cell/ids-angular 0.1.13 → 0.2.1

package/forms/index.d.ts

@@ -1,5 +1,470 @@
+import * as _angular_forms from '@angular/forms';
+import { AbstractControl, FormGroupDirective, NgForm, NgControl, ControlEvent, ValidationErrors } from '@angular/forms';
+import { Subject } from 'rxjs';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Injector, ElementRef, Signal, AfterViewInit, OnInit } from '@angular/core';
+import * as _i_cell_ids_angular_core from '@i-cell/ids-angular/core';
+import { ComponentBase, IdsSizeType, ComponentBaseWithDefaults } from '@i-cell/ids-angular/core';
+import { FocusOrigin } from '@angular/cdk/a11y';
+
+declare abstract class AbstractErrorStateMatcher {
+    abstract isErrorState(control: AbstractControl | null, form: FormGroupDirective | NgForm | null): boolean;
+}
+declare class ErrorStateMatcher extends AbstractErrorStateMatcher {
+    isErrorState(control: AbstractControl | null, form: FormGroupDirective | NgForm | null): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ErrorStateMatcher, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ErrorStateMatcher>;
+}
+declare class ErrorStateTracker {
+    private _matcher;
+    private _ngControl;
+    private _parentFormGroup;
+    private _parentForm;
+    private _stateChanges?;
+    /** Whether the tracker is currently in an error state. */
+    hasErrorState: boolean;
+    constructor(_matcher: ErrorStateMatcher | null, _ngControl: NgControl | null, _parentFormGroup: FormGroupDirective | null, _parentForm: NgForm | null, _stateChanges?: Subject<void> | undefined);
+    /** Updates the error state based on the provided error state matcher. */
+    updateErrorState(): void;
+}
+
+declare abstract class AbstractSuccessStateMatcher {
+    abstract isSuccessState(control: AbstractControl | null, form: FormGroupDirective | NgForm | null): boolean;
+}
+declare class SuccessStateMatcher extends AbstractSuccessStateMatcher {
+    isSuccessState(control: AbstractControl | null, form: FormGroupDirective | NgForm | null): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SuccessStateMatcher, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SuccessStateMatcher>;
+}
+declare class SuccessStateTracker {
+    private _matcher;
+    private _ngControl;
+    private _parentFormGroup;
+    private _parentForm;
+    private _stateChanges?;
+    /** Whether the tracker is currently in an success state. */
+    hasSuccessState: boolean;
+    constructor(_matcher: SuccessStateMatcher | null, _ngControl: NgControl | null, _parentFormGroup: FormGroupDirective | null, _parentForm: NgForm | null, _stateChanges?: Subject<void> | undefined);
+    /** Updates the success state based on the provided success state matcher. */
+    updateSuccessState(): void;
+}
+
+declare class IdsFieldsetRowComponent extends ComponentBase {
+    protected get _hostName(): string;
+    protected _hostClasses: _angular_core.WritableSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsFieldsetRowComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IdsFieldsetRowComponent, "ids-fieldset-row", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare const IdsFormFieldVariant: {
+    readonly SURFACE: "surface";
+    readonly LIGHT: "light";
+};
+type IdsFormFieldVariantType = (typeof IdsFormFieldVariant)[keyof typeof IdsFormFieldVariant];
+
+interface IdsFieldsetDefaultConfig {
+    size?: IdsSizeType;
+    variant?: IdsFormFieldVariantType;
+}
+declare const IDS_FIELDSET_DEFAULT_CONFIG: InjectionToken<IdsFieldsetDefaultConfig>;
+declare function IDS_FIELDSET_DEFAULT_CONFIG_FACTORY(): Required<IdsFieldsetDefaultConfig>;
+
+declare class IdsFieldsetMessageDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsFieldsetMessageDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IdsFieldsetMessageDirective, "[idsFieldsetMessage]", never, {}, {}, never, never, true, never>;
+}
+
+declare class IdsFieldsetComponent extends ComponentBaseWithDefaults<IdsFieldsetDefaultConfig> {
+    protected get _hostName(): string;
+    protected readonly _defaultConfig: Required<IdsFieldsetDefaultConfig>;
+    size: _angular_core.InputSignal<IdsSizeType>;
+    variant: _angular_core.InputSignal<IdsFormFieldVariantType>;
+    legend: _angular_core.InputSignal<string>;
+    private _fieldsetMessage;
+    protected _hasMessage: _angular_core.Signal<boolean>;
+    protected _hostClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsFieldsetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IdsFieldsetComponent, "fieldset[idsFieldset]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "legend": { "alias": "legend"; "required": false; "isSignal": true; }; }, {}, ["_fieldsetMessage"], ["[idsFieldsetMessage]", "ids-fieldset-row"], true, never>;
+}
+
+declare const formFieldControlClass = "ids-form-field-control";
+declare abstract class IdsFormFieldControl<D = unknown> extends ComponentBaseWithDefaults<D> {
+    protected readonly _injector: Injector;
+    protected readonly _parentForm: NgForm | null;
+    protected readonly _parentFormGroup: FormGroupDirective | null;
+    readonly ngControl: _angular_core.WritableSignal<NgControl | null>;
+    readonly errorStateChanges: Subject<void>;
+    readonly successStateChanges: Subject<void>;
+    readonly canHandleSuccessState: _angular_core.InputSignal<boolean>;
+    readonly hasErrorState: _angular_core.WritableSignal<boolean>;
+    readonly hasSuccessState: _angular_core.WritableSignal<boolean>;
+    protected abstract readonly _elementRef: ElementRef;
+    abstract readonly errorStateMatcher: Signal<AbstractErrorStateMatcher>;
+    abstract readonly successStateMatcher: Signal<AbstractSuccessStateMatcher>;
+    private _canHandleSuccessStateEffect;
+    /** Handles the `disabled` input binding */
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Stores the `disabled` state internally */
+    protected readonly _disabled: _angular_core.WritableSignal<boolean>;
+    /** The input's `disabled` state as a read-only signal (to enable/disable the contol programmatically, use the FormControl's related API) */
+    readonly disabled: Signal<boolean>;
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** This effect is triggered if the `disabled` attribute binding changes and delegates the change to the underlying FormControl */
+    private _disabledInputEffect;
+    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    abstract onContainerClick(event: MouseEvent): void;
+    protected _errorStateTracker?: ErrorStateTracker;
+    protected _successStateTracker?: SuccessStateTracker;
+    private _successStateSubscription?;
+    constructor();
+    setDescribedByIds(ids: string[]): void;
+    protected _initErrorStateTracker(): void;
+    protected _setSuccessStateTracker(canHandleSuccessState: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsFormFieldControl<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IdsFormFieldControl<any>, never, never, { "canHandleSuccessState": { "alias": "canHandleSuccessState"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const IDS_FORM_FIELD_CONTROL: InjectionToken<IdsFormFieldControl<unknown>>;
+
+interface IdsFormFieldDefaultConfig {
+    size?: IdsSizeType;
+    variant?: IdsFormFieldVariantType;
+}
+declare const IDS_FORM_FIELD_DEFAULT_CONFIG: InjectionToken<IdsFormFieldDefaultConfig>;
+declare function IDS_FORM_FIELD_DEFAULT_CONFIG_FACTORY(): Required<IdsFormFieldDefaultConfig>;
+
+declare class IdsFormFieldComponent extends ComponentBaseWithDefaults<IdsFormFieldDefaultConfig> {
+    protected get _hostName(): string;
+    private readonly _changeDetectorRef;
+    private readonly _parentFieldset;
+    protected readonly _defaultConfig: Required<IdsFormFieldDefaultConfig>;
+    private _fieldWrapper;
+    private _child;
+    private _hintMessages;
+    private _successMessages;
+    private _errorMessages;
+    private _actions;
+    private _prefixes;
+    private _suffixes;
+    protected _hasActions: _angular_core.Signal<boolean>;
+    protected _hasLeadingIcon: _angular_core.Signal<boolean>;
+    protected _hasPrefix: _angular_core.Signal<boolean>;
+    protected _hasSuffix: _angular_core.Signal<boolean>;
+    protected _hasTrailingIcon: _angular_core.Signal<boolean>;
+    protected _inputId: _angular_core.Signal<string>;
+    size: _angular_core.InputSignal<IdsSizeType>;
+    variant: _angular_core.InputSignal<IdsFormFieldVariantType>;
+    parentOrSelfSize: _angular_core.Signal<IdsSizeType>;
+    parentOrSelfVariant: _angular_core.Signal<IdsFormFieldVariantType>;
+    controlDir: _angular_core.Signal<_angular_forms.NgControl | null>;
+    disabled: _angular_core.Signal<boolean>;
+    readonly: _angular_core.Signal<boolean>;
+    private _hasErrorState;
+    private _hasSuccessState;
+    protected _hostClasses: _angular_core.Signal<string>;
+    protected _displayedMessages: _angular_core.Signal<"error" | "success" | "hint" | undefined>;
+    hasRequiredValidator: _angular_core.Signal<boolean | undefined>;
+    getConnectedOverlayOrigin(): ElementRef;
+    containerClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsFormFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IdsFormFieldComponent, "ids-form-field", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, ["_child", "_hintMessages", "_successMessages", "_errorMessages", "_actions", "_prefixes", "_suffixes"], ["ids-label", "ids-icon[idsLeadingIcon]", "[idsPrefix]", "*", "[idsSuffix]", "ids-icon[idsTrailingIcon]", "[idsFormFieldAction]", "ids-error-message", "ids-success-message", "ids-hint-message"], true, never>;
+}
+
+interface IdsInputDefaultConfig {
+    errorStateMatcher?: typeof AbstractErrorStateMatcher;
+    successStateMatcher?: typeof AbstractSuccessStateMatcher;
+}
+declare const IDS_INPUT_DEFAULT_CONFIG: InjectionToken<IdsInputDefaultConfig>;
+declare function IDS_INPUT_DEFAULT_CONFIG_FACTORY(): Required<IdsInputDefaultConfig>;
+
+type IdsInputType = 'button' | 'checkbox' | 'color' | 'date' | 'datetime-local' | 'email' | 'file' | 'hidden' | 'image' | 'month' | 'number' | 'password' | 'radio' | 'range' | 'reset' | 'search' | 'submit' | 'tel' | 'text' | 'time' | 'url' | 'week';
+
+declare class IdsInputDirective extends IdsFormFieldControl<IdsInputDefaultConfig> implements AfterViewInit {
+    protected get _hostName(): string;
+    protected readonly _elementRef: ElementRef<HTMLInputElement> | ElementRef<HTMLTextAreaElement>;
+    protected readonly _defaultConfig: Required<IdsInputDefaultConfig>;
+    private _focused;
+    name: _angular_core.InputSignal<string | undefined>;
+    type: _angular_core.InputSignal<IdsInputType>;
+    readonly errorStateMatcher: _angular_core.InputSignal<AbstractErrorStateMatcher>;
+    readonly successStateMatcher: _angular_core.InputSignal<AbstractSuccessStateMatcher>;
+    protected _hostClasses: _angular_core.Signal<string>;
+    private _validateTypeEffect;
+    ngAfterViewInit(): void;
+    private _validateType;
+    focus(options?: FocusOptions): void;
+    private _focusChanged;
+    updateControlState(event: ControlEvent): void;
+    /**
+     * Should be an arrow function in order to handle `this` outside of this class
+     */
+    onContainerClick: () => void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsInputDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IdsInputDirective, "input[idsInput][ngModel]:not([formControl]):not([formControlName]),             input[idsInput][formControl]:not([ngModel]):not([formControlName]),             input[idsInput][formControlName]:not([ngModel]):not([formControl]),             textarea[idsInput][ngModel]:not([formControl]):not([formControlName]),             textarea[idsInput][formControl]:not([ngModel]):not([formControlName]),             textarea[idsInput][formControlName]:not([ngModel]):not([formControl])", ["idsInput"], { "name": { "alias": "name"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; "isSignal": true; }; "successStateMatcher": { "alias": "successStateMatcher"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
 /**
- * Generated bundle index. Do not edit.
+ * A validation error's representation that maps an error message (or a function returning a message) to an error code.
  */
-/// <amd-module name="@i-cell/ids-angular/forms" />
-export * from './public-api';
+interface IdsErrorMessageMapping {
+    /** The code of the error (usually the error key returned by a {@link ValidatorFn}) */
+    code: string;
+    /** The error's message (either a string literal or a function that returns a literal) */
+    message: string | (() => string);
+}
+
+/**
+ * Directive to map an error message to an error code for a form field.
+ * Mappings must be defined between the directive element's tags ordered by priority (descending from top to bottom).
+ * The error code is provided as an attribute, while the error message will be this directive's text content.
+ * The latter can be a plain string literal or even an interpolated string value.
+ *
+ * @example
+ * ```html
+ * <ids-form-field>
+ *   <ids-label>Input field</ids-label>
+ *   <input
+ *     idsInput
+ *     ngModel
+ *     customValidator
+ *     required
+ *     [minlength]="3"
+ *     [maxlength]="10"
+ *     [pattern]="validPattern"
+ *   >
+ *   <ids-error-message>
+ *     <ids-error-def code="required">{{ 'ERROR.REQUIRED.CUSTOM' | translate }}</ids-error-def>
+ *     <ids-error-def code="minlength">'minLength' error message</ids-error-def>
+ *     <ids-error-def code="maxlength">'maxLength' error message</ids-error-def>
+ *     <ids-error-def code="pattern">'pattern' error message with interpolation: {{ model.value }}</ids-error-def>
+ *     <ids-error-def code="custom">Custom validator error message</ids-error-def>
+ *   </ids-error-message>
+ * </ids-form-field>
+ * ```
+ */
+declare class IdsErrorDefinitionDirective {
+    /**
+     * The validation error's identifier code
+     */
+    code: _angular_core.InputSignal<string>;
+    private _elementRef;
+    /**
+     * The validation error's message that will be presented to the user
+     */
+    get errorMessage(): string;
+    /**
+     * Creates a IdsErrorMessageMapping instance based on this directive's state (code, errorMessage)
+     * @returns A IdsErrorMessageMapping instance
+     */
+    toErrorMessageMapping(): IdsErrorMessageMapping;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsErrorDefinitionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IdsErrorDefinitionDirective, "ids-error-def", never, { "code": { "alias": "code"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class IdsMessageSuffixDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsMessageSuffixDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IdsMessageSuffixDirective, "[idsMessageSuffix]", never, {}, {}, never, never, true, never>;
+}
+
+declare const IdsMessageVariant: {
+    readonly SURFACE: "surface";
+    readonly LIGHT: "light";
+    readonly DARK: "dark";
+};
+type IdsMessageVariantType = (typeof IdsMessageVariant)[keyof typeof IdsMessageVariant];
+
+interface IdsMessageDefaultConfig {
+    size?: IdsSizeType;
+    variant?: IdsMessageVariantType;
+}
+declare const IDS_MESSAGE_DEFAULT_CONFIG: InjectionToken<IdsMessageDefaultConfig>;
+declare function IDS_MESSAGE_DEFAULT_CONFIG_FACTORY(): Required<IdsMessageDefaultConfig>;
+
+declare class IdsMessageDirective extends ComponentBaseWithDefaults<IdsMessageDefaultConfig> {
+    protected get _hostName(): string;
+    private readonly _parent;
+    protected readonly _defaultConfig: Required<IdsMessageDefaultConfig>;
+    size: _angular_core.InputSignal<IdsSizeType>;
+    variant: _angular_core.InputSignal<IdsMessageVariantType>;
+    private _parentOrSelfSize;
+    private _parentOrSelfVariant;
+    private _parentDisabled;
+    protected _hostClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsMessageDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IdsMessageDirective, "[idsMessage]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class IdsErrorMessageComponent extends ComponentBase {
+    protected get _hostName(): string;
+    private _parent;
+    private _control;
+    private _errorDefDirs;
+    private _errorDefs;
+    protected _validationError: _angular_core.WritableSignal<IdsErrorMessageMapping | null>;
+    protected _hostClasses: _angular_core.Signal<string>;
+    suffixes: _angular_core.Signal<readonly IdsMessageSuffixDirective[]>;
+    constructor();
+    private _selectMostImportantValidationError;
+    protected _getValidationErrorMessage(messageOrFn: IdsErrorMessageMapping['message']): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsErrorMessageComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IdsErrorMessageComponent, "ids-error-message", never, {}, {}, ["_errorDefDirs", "suffixes"], ["[idsMessagePrefix]", "[idsMessageSuffix]"], true, [{ directive: typeof IdsMessageDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class IdsMessagePrefixDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsMessagePrefixDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IdsMessagePrefixDirective, "[idsMessagePrefix]", never, {}, {}, never, never, true, never>;
+}
+
+declare class IdsHintMessageComponent {
+    prefixes: _angular_core.Signal<readonly IdsMessagePrefixDirective[]>;
+    suffixes: _angular_core.Signal<readonly IdsMessageSuffixDirective[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsHintMessageComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IdsHintMessageComponent, "ids-hint-message", never, {}, {}, ["prefixes", "suffixes"], ["[idsMessagePrefix]", "*", "[idsMessageSuffix]"], true, [{ directive: typeof IdsMessageDirective; inputs: { "size": "size"; "variant": "variant"; }; outputs: {}; }]>;
+}
+
+declare class IdsSuccessMessageComponent extends ComponentBase {
+    protected get _hostName(): string;
+    protected _hostClasses: _angular_core.Signal<string>;
+    suffixes: _angular_core.Signal<readonly IdsMessageSuffixDirective[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsSuccessMessageComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IdsSuccessMessageComponent, "ids-success-message", never, {}, {}, ["suffixes"], ["[idsMessagePrefix]", "*", "[idsMessageSuffix]"], true, [{ directive: typeof IdsMessageDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare const Message: {
+    readonly HINT: "hint";
+    readonly ERROR: "error";
+    readonly SUCCESS: "success";
+};
+type MessageType = (typeof Message)[keyof typeof Message];
+
+declare class IdsOptionGroupComponent extends ComponentBase {
+    protected get _hostName(): string;
+    private readonly _parent;
+    protected readonly _inert: boolean;
+    label: _angular_core.InputSignal<string | undefined>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly _labelId: _angular_core.Signal<string>;
+    protected readonly _hostClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsOptionGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IdsOptionGroupComponent, "ids-option-group", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["ids-option, ng-container"], true, never>;
+}
+
+declare const IDS_OPTION_GROUP: InjectionToken<IdsOptionGroupComponent>;
+
+interface IdsOptionParentComponent {
+    multiSelect: Signal<boolean>;
+    inertGroups?: boolean;
+    parentSize: Signal<IdsSizeType>;
+    parentVariant: Signal<IdsFormFieldVariantType>;
+    isOptionPreSelectedByValue(optionValue: unknown): boolean;
+}
+declare const IDS_OPTION_PARENT_COMPONENT: InjectionToken<IdsOptionParentComponent>;
+
+interface IdsPseudoCheckboxParent<T extends string> {
+    embeddedPseudoCheckboxSize: Signal<IdsSizeType>;
+    embeddedPseudoCheckboxVariant: Signal<T>;
+}
+declare const IDS_PSEUDO_CHECKBOX_PARENT: InjectionToken<IdsPseudoCheckboxParent<string>>;
+
+declare class IdsOptionComponent<T = unknown> extends ComponentBase implements OnInit, IdsPseudoCheckboxParent<IdsFormFieldVariantType> {
+    protected get _hostName(): string;
+    private readonly _parent;
+    private readonly _element;
+    readonly group: IdsOptionGroupComponent | null;
+    private _textElement;
+    selected: _angular_core.WritableSignal<boolean>;
+    private _active;
+    size: _angular_core.Signal<_i_cell_ids_angular_core.IdsSizeType>;
+    variant: _angular_core.Signal<IdsFormFieldVariantType>;
+    value: _angular_core.InputSignal<T | undefined>;
+    explicitViewValue: _angular_core.InputSignal<string | null>;
+    disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    disabled: boolean;
+    protected _groupOrOptionIsDisabled: _angular_core.Signal<boolean>;
+    protected readonly _multiSelect: boolean;
+    onSelectionChange: _angular_core.OutputEmitterRef<IdsOptionSelectionChange<T>>;
+    viewValue: _angular_core.Signal<string>;
+    protected readonly _hostClasses: _angular_core.Signal<string>;
+    protected _pseudoCheckboxState: _angular_core.Signal<"unchecked" | "checked">;
+    embeddedPseudoCheckboxSize: _angular_core.Signal<_i_cell_ids_angular_core.IdsSizeType>;
+    embeddedPseudoCheckboxVariant: _angular_core.WritableSignal<"surface">;
+    constructor();
+    ngOnInit(): void;
+    private _handleKeydown;
+    selectViaInteraction(): void;
+    getHostElement(): HTMLElement;
+    select(emitEvent?: boolean): void;
+    deselect(emitEvent?: boolean): void;
+    focus(_origin?: FocusOrigin, options?: FocusOptions): void;
+    setActiveStyles(): void;
+    setInactiveStyles(): void;
+    getLabel(): string;
+    private _emitSelectionChangeEvent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsOptionComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IdsOptionComponent<any>, "ids-option", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "explicitViewValue": { "alias": "viewValue"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "onSelectionChange": "onSelectionChange"; }, never, ["*"], true, never>;
+}
+declare function _countGroupLabelsBeforeOption(optionIndex: number, options: Readonly<IdsOptionComponent[]>, optionGroups: Readonly<IdsOptionGroupComponent[]>): number;
+declare function _getOptionScrollPosition(optionOffset: number, optionHeight: number, currentScrollPosition: number, panelHeight: number): number;
+
+declare class IdsOptionSelectionChange<T = unknown> {
+    source: IdsOptionComponent<T>;
+    selected: boolean;
+    isUserInput: boolean;
+    constructor(source: IdsOptionComponent<T>, selected: boolean, isUserInput?: boolean);
+}
+
+declare const IdsPseudoCheckboxState: {
+    readonly UNCHECKED: "unchecked";
+    readonly CHECKED: "checked";
+    readonly INDETERMINATE: "indeterminate";
+};
+type IdsPseudoCheckboxStateType = (typeof IdsPseudoCheckboxState)[keyof typeof IdsPseudoCheckboxState];
+
+declare class PseudoCheckboxComponent extends ComponentBase {
+    protected get _hostName(): string;
+    private readonly _parent;
+    checkboxState: _angular_core.InputSignal<IdsPseudoCheckboxStateType>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected _isChecked: _angular_core.Signal<boolean>;
+    protected _isIndeterminate: _angular_core.Signal<boolean>;
+    protected _hostClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PseudoCheckboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PseudoCheckboxComponent, "ids-pseudo-checkbox", never, { "checkboxState": { "alias": "checkboxState"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class IdsFormFieldActionDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsFormFieldActionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IdsFormFieldActionDirective, "[idsFormFieldAction]", never, {}, {}, never, never, true, never>;
+}
+
+declare class IdsLabelDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsLabelDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IdsLabelDirective, "ids-label", never, {}, {}, never, never, true, never>;
+}
+
+declare class IdsPrefixDirective {
+    set idsLeadingIcon(value: '');
+    isLeadingIcon: boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsPrefixDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IdsPrefixDirective, "[idsPrefix], [idsLeadingIcon]", never, { "idsLeadingIcon": { "alias": "idsLeadingIcon"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class IdsSuffixDirective {
+    set idsTrailingIcon(value: '');
+    isTrailingIcon: boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsSuffixDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IdsSuffixDirective, "[idsSuffix], [idsTrailingIcon]", never, { "idsTrailingIcon": { "alias": "idsTrailingIcon"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class IdsValidators {
+    static required(control: AbstractControl): ValidationErrors | null;
+    static requiredTrue(control: AbstractControl): ValidationErrors | null;
+    static requiredFalse(control: AbstractControl): ValidationErrors | null;
+}
+declare function requiredValidator(control: AbstractControl): ValidationErrors | null;
+declare function requiredTrueValidator(control: AbstractControl): ValidationErrors | null;
+declare function requiredFalseValidator(control: AbstractControl): ValidationErrors | null;
+
+export { AbstractErrorStateMatcher, AbstractSuccessStateMatcher, ErrorStateMatcher, ErrorStateTracker, IDS_FIELDSET_DEFAULT_CONFIG, IDS_FIELDSET_DEFAULT_CONFIG_FACTORY, IDS_FORM_FIELD_CONTROL, IDS_FORM_FIELD_DEFAULT_CONFIG, IDS_FORM_FIELD_DEFAULT_CONFIG_FACTORY, IDS_INPUT_DEFAULT_CONFIG, IDS_INPUT_DEFAULT_CONFIG_FACTORY, IDS_MESSAGE_DEFAULT_CONFIG, IDS_MESSAGE_DEFAULT_CONFIG_FACTORY, IDS_OPTION_GROUP, IDS_OPTION_PARENT_COMPONENT, IDS_PSEUDO_CHECKBOX_PARENT, IdsErrorDefinitionDirective, IdsErrorMessageComponent, IdsFieldsetComponent, IdsFieldsetMessageDirective, IdsFieldsetRowComponent, IdsFormFieldActionDirective, IdsFormFieldComponent, IdsFormFieldControl, IdsFormFieldVariant, IdsHintMessageComponent, IdsInputDirective, IdsLabelDirective, IdsMessageDirective, IdsMessagePrefixDirective, IdsMessageSuffixDirective, IdsMessageVariant, IdsOptionComponent, IdsOptionGroupComponent, IdsOptionSelectionChange, IdsPrefixDirective, IdsPseudoCheckboxState, IdsSuccessMessageComponent, IdsSuffixDirective, IdsValidators, Message, PseudoCheckboxComponent, SuccessStateMatcher, SuccessStateTracker, _countGroupLabelsBeforeOption, _getOptionScrollPosition, formFieldControlClass, requiredFalseValidator, requiredTrueValidator, requiredValidator };
+export type { IdsErrorMessageMapping, IdsFieldsetDefaultConfig, IdsFormFieldDefaultConfig, IdsFormFieldVariantType, IdsInputDefaultConfig, IdsMessageDefaultConfig, IdsMessageVariantType, IdsOptionParentComponent, IdsPseudoCheckboxParent, IdsPseudoCheckboxStateType, MessageType };

package/icon/index.d.ts

@@ -1,5 +1,69 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@i-cell/ids-angular/icon" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { Signal, InjectionToken, OnInit } from '@angular/core';
+import { IdsSizeType, IdsSizeCollectionType, ComponentBaseWithDefaults } from '@i-cell/ids-angular/core';
+
+declare const IdsIconVariant: {
+    readonly PRIMARY: "primary";
+    readonly SECONDARY: "secondary";
+    readonly SURFACE: "surface";
+    readonly BRAND: "brand";
+    readonly LIGHT: "light";
+    readonly DARK: "dark";
+    readonly SUCCESS: "success";
+    readonly WARNING: "warning";
+    readonly ERROR: "error";
+};
+type IdsIconVariantType = (typeof IdsIconVariant)[keyof typeof IdsIconVariant];
+
+declare abstract class IdsIconParent {
+    readonly embeddedIconVariant: Signal<IdsIconVariantType>;
+}
+declare const IDS_ICON_PARENT: InjectionToken<IdsIconParent>;
+
+declare const IdsIconSource: {
+    readonly SVG: "svg";
+    readonly FONT: "font";
+};
+type IdsIconSourceType = (typeof IdsIconSource)[keyof typeof IdsIconSource];
+
+interface IdsIconDefaultConfig {
+    size?: IdsSizeType;
+    sizeCollection?: IdsSizeCollectionType;
+    variant?: IdsIconVariantType;
+    iconAssetsPath: string;
+    fontNameMappings?: Record<string, string>;
+}
+declare const IDS_ICON_DEFAULT_CONFIG: InjectionToken<IdsIconDefaultConfig>;
+declare function IDS_ICON_DEFAULT_CONFIG_FACTORY(): Required<IdsIconDefaultConfig>;
+
+declare class IdsIconComponent extends ComponentBaseWithDefaults<IdsIconDefaultConfig> implements OnInit {
+    protected get _hostName(): string;
+    private readonly _parent;
+    protected readonly _defaultConfig: Required<IdsIconDefaultConfig>;
+    private readonly _elementRef;
+    private readonly _document;
+    private readonly _httpClient;
+    private readonly _sanitizer;
+    size: _angular_core.InputSignal<IdsSizeType>;
+    sizeCollection: _angular_core.InputSignal<IdsSizeCollectionType>;
+    variant: _angular_core.InputSignal<IdsIconVariantType>;
+    fontIcon: _angular_core.InputSignalWithTransform<string | null, string>;
+    svgIconName: _angular_core.InputSignalWithTransform<string | null, string>;
+    ariaHidden: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected _svgIcon: SVGElement | null;
+    protected _safeFontIcon: _angular_core.Signal<string | null>;
+    protected _iconSourceType: _angular_core.Signal<"svg" | "font">;
+    private _parentOrSelfVariant;
+    protected _hostClasses: _angular_core.Signal<string>;
+    private _sanitizeSvgIconEffect;
+    ngOnInit(): void;
+    private _getSvgElementSource;
+    private _setSvgElement;
+    private _clearSvgElement;
+    private _getSvgElement;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsIconComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IdsIconComponent, "ids-icon", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "sizeCollection": { "alias": "sizeCollection"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "fontIcon": { "alias": "fontIcon"; "required": false; "isSignal": true; }; "svgIconName": { "alias": "svgIcon"; "required": false; "isSignal": true; }; "ariaHidden": { "alias": "aria-hidden"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { IDS_ICON_DEFAULT_CONFIG, IDS_ICON_DEFAULT_CONFIG_FACTORY, IDS_ICON_PARENT, IdsIconComponent, IdsIconParent, IdsIconSource, IdsIconVariant };
+export type { IdsIconDefaultConfig, IdsIconSourceType, IdsIconVariantType };

package/icon-button/index.d.ts

@@ -1,5 +1,66 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@i-cell/ids-angular/icon-button" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { Signal, InjectionToken } from '@angular/core';
+import { IdsSizeType, ComponentBaseWithDefaults } from '@i-cell/ids-angular/core';
+import { IdsIconComponent } from '@i-cell/ids-angular/icon';
+
+declare const IdsIconButtonAppearance: {
+    readonly FILLED: "filled";
+    readonly OUTLINED: "outlined";
+    readonly STANDARD: "standard";
+};
+type IdsIconButtonAppearanceType = (typeof IdsIconButtonAppearance)[keyof typeof IdsIconButtonAppearance];
+
+declare const IdsIconButtonVariant: {
+    readonly PRIMARY: "primary";
+    readonly SECONDARY: "secondary";
+    readonly SURFACE: "surface";
+    readonly BRAND: "brand";
+    readonly LIGHT: "light";
+    readonly DARK: "dark";
+    readonly INFO: "info";
+    readonly SUCCESS: "success";
+    readonly WARNING: "warning";
+    readonly ERROR: "error";
+};
+type IdsIconButtonVariantType = (typeof IdsIconButtonVariant)[keyof typeof IdsIconButtonVariant];
+
+declare abstract class IdsIconButtonParent {
+    readonly embeddedIconButtonVariant: Signal<IdsIconButtonVariantType>;
+    readonly embeddedIconButtonAppearance: Signal<IdsIconButtonAppearanceType>;
+    readonly disabled: Signal<boolean>;
+}
+declare const IDS_ICON_BUTTON_PARENT: InjectionToken<IdsIconButtonParent>;
+
+interface IdsIconButtonDefaultConfig {
+    appearance?: IdsIconButtonAppearanceType;
+    size?: IdsSizeType;
+    variant?: IdsIconButtonVariantType;
+}
+declare const IDS_ICON_BUTTON_DEFAULT_CONFIG: InjectionToken<IdsIconButtonDefaultConfig>;
+declare function IDS_ICON_BUTTON_DEFAULT_CONFIG_FACTORY(): Required<IdsIconButtonDefaultConfig>;
+
+declare class IdsIconButtonComponent extends ComponentBaseWithDefaults<IdsIconButtonDefaultConfig> {
+    protected get _hostName(): string;
+    private readonly _parent;
+    private _hostElement;
+    private _routerLink;
+    protected readonly _defaultConfig: Required<IdsIconButtonDefaultConfig>;
+    appearance: _angular_core.InputSignal<IdsIconButtonAppearanceType>;
+    size: _angular_core.InputSignal<IdsSizeType>;
+    variant: _angular_core.InputSignal<IdsIconButtonVariantType>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected _icons: _angular_core.Signal<readonly IdsIconComponent[]>;
+    private _parentOrSelfAppearance;
+    private _parentOrSelfVariant;
+    private _parentOrSelfDisabled;
+    protected _hostClasses: _angular_core.Signal<string>;
+    private get _buttonType();
+    constructor();
+    private _disableLink;
+    private _enableLink;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsIconButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IdsIconButtonComponent, "button[idsIconButton], a[idsIconButton]", never, { "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, ["_icons"], ["ids-icon"], true, never>;
+}
+
+export { IDS_ICON_BUTTON_DEFAULT_CONFIG, IDS_ICON_BUTTON_DEFAULT_CONFIG_FACTORY, IDS_ICON_BUTTON_PARENT, IdsIconButtonAppearance, IdsIconButtonComponent, IdsIconButtonParent, IdsIconButtonVariant };
+export type { IdsIconButtonAppearanceType, IdsIconButtonDefaultConfig, IdsIconButtonVariantType };

package/index.d.ts

@@ -1,5 +1,2 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@i-cell/ids-angular" />
-export * from './public-api';
+
+export { };