@i-cell/ids-angular 0.1.13 → 0.2.0

package/tab/index.d.ts

@@ -1,5 +1,78 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@i-cell/ids-angular/tab" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, TemplateRef, AfterContentInit } from '@angular/core';
+import { IdsSizeType, IdsOrientationType, ComponentBase, ComponentBaseWithDefaults } from '@i-cell/ids-angular/core';
+
+declare const IdsTabGroupPosition: {
+    readonly START: "start";
+    readonly CENTER: "center";
+    readonly END: "end";
+};
+type IdsTabGroupPositionType = (typeof IdsTabGroupPosition)[keyof typeof IdsTabGroupPosition];
+
+declare const IdsTabGroupVariant: {
+    readonly PRIMARY: "primary";
+    readonly SURFACE: "surface";
+    readonly LIGHT: "light";
+};
+type IdsTabGroupVariantType = (typeof IdsTabGroupVariant)[keyof typeof IdsTabGroupVariant];
+
+declare const IdsTabIndicatorPosition: {
+    readonly TOP: "top";
+    readonly BOTTOM: "bottom";
+    readonly LEFT: "left";
+    readonly RIGHT: "right";
+};
+type IdsTabIndicatorPositionType = (typeof IdsTabIndicatorPosition)[keyof typeof IdsTabIndicatorPosition];
+
+interface IdsTabGroupDefaultConfig {
+    size?: IdsSizeType;
+    variant?: IdsTabGroupVariantType;
+    orientation?: IdsOrientationType;
+    stretchTabs?: boolean;
+    tabPosition?: IdsTabGroupPositionType;
+    indicatorPosition?: IdsTabIndicatorPositionType;
+}
+declare const IDS_TAB_GROUP_DEFAULT_CONFIG: InjectionToken<IdsTabGroupDefaultConfig>;
+declare function IDS_TAB_GROUP_DEFAULT_CONFIG_FACTORY(): Required<IdsTabGroupDefaultConfig>;
+
+declare class IdsTabComponent extends ComponentBase {
+    protected get _hostName(): string;
+    private _tabGroup;
+    label: _angular_core.InputSignal<string | undefined>;
+    disabled: _angular_core.InputSignal<boolean>;
+    leadingIcon: _angular_core.InputSignalWithTransform<string, unknown>;
+    trailingIcon: _angular_core.InputSignalWithTransform<string, unknown>;
+    content: _angular_core.Signal<TemplateRef<unknown>>;
+    panelId: _angular_core.Signal<string>;
+    parentOrSelfDisabled: _angular_core.Signal<boolean>;
+    protected _hostClasses: _angular_core.WritableSignal<string>;
+    hostTabClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsTabComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IdsTabComponent, "ids-tab", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "leadingIcon": { "alias": "leadingIcon"; "required": false; "isSignal": true; }; "trailingIcon": { "alias": "trailingIcon"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class IdsTabGroupComponent extends ComponentBaseWithDefaults<IdsTabGroupDefaultConfig> implements AfterContentInit {
+    protected get _hostName(): string;
+    protected readonly _defaultConfig: Required<IdsTabGroupDefaultConfig>;
+    protected _items: _angular_core.Signal<readonly IdsTabComponent[]>;
+    private _portalOutlet;
+    private _viewContainerRef;
+    size: _angular_core.InputSignal<IdsSizeType>;
+    variant: _angular_core.InputSignal<IdsTabGroupVariantType>;
+    orientation: _angular_core.InputSignal<IdsOrientationType>;
+    stretchTabs: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    tabPosition: _angular_core.InputSignal<IdsTabGroupPositionType>;
+    indicatorPosition: _angular_core.InputSignal<IdsTabIndicatorPositionType | undefined>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected _selectedTabIndex: _angular_core.WritableSignal<number>;
+    selectedTabIndex: _angular_core.Signal<number>;
+    protected _hostClasses: _angular_core.Signal<string>;
+    private _calculatedIndicatorPosition;
+    ngAfterContentInit(): void;
+    selectTab(index: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsTabGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IdsTabGroupComponent, "ids-tab-group", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "stretchTabs": { "alias": "stretchTabs"; "required": false; "isSignal": true; }; "tabPosition": { "alias": "tabPosition"; "required": false; "isSignal": true; }; "indicatorPosition": { "alias": "indicatorPosition"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, ["_items"], never, true, never>;
+}
+
+export { IDS_TAB_GROUP_DEFAULT_CONFIG, IDS_TAB_GROUP_DEFAULT_CONFIG_FACTORY, IdsTabComponent, IdsTabGroupComponent, IdsTabGroupPosition, IdsTabGroupVariant, IdsTabIndicatorPosition };
+export type { IdsTabGroupDefaultConfig, IdsTabGroupPositionType, IdsTabGroupVariantType, IdsTabIndicatorPositionType };

package/table/index.d.ts

@@ -1,5 +1,392 @@
+import { Observable, Subject } from 'rxjs';
+import { DataSource, SelectionModel } from '@angular/cdk/collections';
+import { IdsPaginatorPageChangeEvent } from '@i-cell/ids-angular/paginator';
+import * as _angular_core from '@angular/core';
+import { Type, TemplateRef, InjectionToken, Optional, OnInit } from '@angular/core';
+import { IdsSizeType, ComponentBaseWithDefaults } from '@i-cell/ids-angular/core';
+import * as _i_cell_ids_angular_table from '@i-cell/ids-angular/table';
+import { CdkTableDataSourceInput } from '@angular/cdk/table';
+import { IdsIconButtonParent, IdsIconButtonVariantType, IdsIconButtonAppearanceType } from '@i-cell/ids-angular/icon-button';
+
+interface IdsTablePaginationParams {
+    /** The total number of items in the result list */
+    totalRows: number;
+    /** The highest page index number */
+    /** The number of items per page */
+    rows: number;
+    /** The index number of the current page */
+    page: number;
+}
+
+interface IdsTableRequestPaginationData {
+    /** The number of requested items per page */
+    rows: number;
+    /** The requested page index (1 based) */
+    page: number;
+}
+
+interface IdsTableResponseData<D> {
+    resultList: D[];
+    paginationParams: IdsTablePaginationParams;
+}
+
+declare const IdsTableSortDirection: {
+    readonly NONE: "";
+    readonly ASC: "asc";
+    readonly DESC: "desc";
+};
+type IdsTableSortDirectionType = (typeof IdsTableSortDirection)[keyof typeof IdsTableSortDirection];
+
+declare class IdsTableSortInfo {
+    sortBy: string;
+    direction: IdsTableSortDirectionType;
+    constructor(sortBy: string, direction: IdsTableSortDirectionType);
+}
+
+type IdsTableRequestFactory<D> = (paginationData: IdsTableRequestPaginationData | null, sortInfo: IdsTableSortInfo | null) => Observable<IdsTableResponseData<D>>;
+
+declare const DEFAULT_DATA_LOAD_DEBOUNCE_TIME = 100;
+declare class ServerSideDataSource<D> implements DataSource<D> {
+    private _requestFactory;
+    private _resetDataAndPagingOnError;
+    private _dataSubject;
+    private _sortSubject;
+    private _pageSubject;
+    private _pageInfoSubject;
+    private _loadDataTriggerSubject;
+    private _loadingSubject;
+    private _loadDataSubscription?;
+    data$: Observable<D[]>;
+    isLoading$: Observable<boolean>;
+    pageInfo$: Observable<IdsTablePaginationParams | null>;
+    pageIndex$: Observable<number>;
+    get data(): D[];
+    set data(value: D[]);
+    get pageInfo(): IdsTablePaginationParams | null;
+    set pageInfo(value: IdsTablePaginationParams | null);
+    get length(): number;
+    constructor(_requestFactory: IdsTableRequestFactory<D>, _resetDataAndPagingOnError?: boolean);
+    connect(): Observable<readonly D[]>;
+    disconnect(): void;
+    sort(sortInfo?: IdsTableSortInfo | null): void;
+    page(pageEvent: IdsPaginatorPageChangeEvent): void;
+    /**
+     * Loads data from specified endpoint.
+     */
+    refreshData(): void;
+    private _initDataLoading;
+}
+
 /**
- * Generated bundle index. Do not edit.
+ * Column definition type for the i-DS table component.
  */
-/// <amd-module name="@i-cell/ids-angular/table" />
-export * from './public-api';
+type IdsTableColumnDef<D> = {
+    /**
+     * Unique column identifier literal (mandatory).
+     */
+    id: string;
+    /**
+     * Column label displayed in the header cell. If no label is provided a custom cell renderer is needed to display a proper column header.
+     */
+    label?: string;
+    /**
+     * Name of the data model object property to display in the column's cell.
+     */
+    field?: string;
+    /**
+     * Value getter function called by a cell renderer, provides the value to be displayed in the cell.
+     */
+    value?: ((rowData: D) => unknown);
+    /**
+     * The header cell's renderer either built-in or external template or component.
+     * Currently the following built-in renderers are available:
+     * - 'strong': the label is displayed in a <strong> tag,
+     * - 'numeric': the label is displayed in a localized number format,
+     * - 'icon': IDS Font ligature displayes as an icon
+     * If no renderer is provided or the given literal does not match any of the built-in or external cell renderer names, the cell's value is displayed as a plain string.
+     *
+     * Both renderer types get references to the row data, the column definition and a calculated cell value.
+     * A component renderer gets these through its inputs (see {@link IdsTableCellRenderer}), while a template renderer through its context:
+     * row data is implicit, `colData` provides the column metadata, `cellValue` provides the cell's value, eg.:
+     * ```html
+     * <span *idsCellTemplate="'myTemplate'; let row">{{ row.myProp }}</span>
+     *
+     * <!-- or -->
+     *
+     * <ng-template let-colData="colData" let-value="cellValue" idsCellTemplate="myTemplate2">
+     *   <span>Value of {{ colData.field }} is: {{ value }}</span>
+     * </ng-template>
+     * ```
+     */
+    headerCellRenderer?: string | Type<IdsTableCellRenderer<D>>;
+    /**
+     * The data cells' renderer, either built-in or external template or component.
+     * Currently the following built-in renderers are available:
+     * - 'strong': the label is displayed in a <strong> tag,
+     * - 'numeric': the label is displayed in a localized number format,
+     * - 'icon': IDS Font ligature displayes as an icon
+     * If no renderer is provided or the given literal does not match any of the built-in or external cell renderer names, the cell's value is displayed as a plain string.
+     *
+     * Both renderer types get references to the row data, the column definition and a calculated cell value.
+     * A component renderer gets these through its inputs (see {@link IdsTableCellRenderer}), while a template renderer through its context:
+     * row data is implicit, `colData` provides the column metadata, `cellValue` provides the cell's value, eg.:
+     * ```html
+     * <span *idsCellTemplate="'myTemplate'; let row">{{ row.myProp }}</span>
+     *
+     * <!-- or -->
+     *
+     * <ng-template let-colData="colData" let-value="cellValue" idsCellTemplate="myTemplate2">
+     *   <span>Value of {{ colData.field }} is: {{ value }}</span>
+     * </ng-template>
+     * ```
+     */
+    cellRenderer?: string | Type<IdsTableCellRenderer<D>>;
+    /**
+     * Defines if the column is hideable (column visibility feature coming soon...).
+     */
+    hideable?: boolean;
+    /**
+     * Defines if the column is visible. If used with hideable, the column will be in the column menu unchecked.
+     */
+    visible?: boolean;
+    sortable?: boolean;
+    orderName?: string;
+    /**
+     * Defines if the column should be sticky at the begining of the table.
+     */
+    sticky?: boolean;
+    /**
+     * Defines if the column should be sticky at the end of the table.
+     */
+    stickyEnd?: boolean;
+    /**
+     * Defines if the cell should render as header for a11y reasons.
+     */
+    identifier?: boolean;
+    /**
+     * Defines custom `CSS` class for the column it self.
+     */
+    columnClasses?: string;
+    /**
+     * Defines custom `CSS` class for the column cells.
+     */
+    cellClasses?: string;
+};
+
+declare abstract class IdsTableCellRenderer<D> {
+    private readonly _entities;
+    cellValue: _angular_core.InputSignalWithTransform<string, unknown>;
+    colDef: _angular_core.InputSignal<IdsTableColumnDef<D>>;
+    rowData: _angular_core.InputSignal<D | undefined>;
+    protected _isComponentCellRenderer<C>(cellRendererDef: string | Type<C> | undefined): cellRendererDef is Type<C>;
+    protected _preSanitize(input: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsTableCellRenderer<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IdsTableCellRenderer<any>, never, never, { "cellValue": { "alias": "cellValue"; "required": false; "isSignal": true; }; "colDef": { "alias": "colDef"; "required": true; "isSignal": true; }; "rowData": { "alias": "rowData"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class IdsTableCellTemplateDirective {
+    templateName: _angular_core.InputSignal<string>;
+    templateRef: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsTableCellTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IdsTableCellTemplateDirective, "[idsCellTemplate]", never, { "templateName": { "alias": "idsCellTemplate"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const IdsTableAppearance: {
+    readonly PLAIN: "plain";
+    readonly LINE_DIVISION: "line-division";
+    readonly ZEBRA: "zebra";
+};
+type IdsTableAppearanceType = (typeof IdsTableAppearance)[keyof typeof IdsTableAppearance];
+
+interface IdsTableCellClickEvent<D> {
+    event: MouseEvent;
+    colDef: IdsTableColumnDef<D>;
+    rowData: D;
+}
+
+interface IdsTableRowClickEvent<D> {
+    event: MouseEvent;
+    rowData: D;
+}
+
+interface IdsTableRowKeydownEvent<D> {
+    event: KeyboardEvent;
+    rowData: D;
+}
+
+declare const IdsTableVariant: {
+    readonly PRIMARY: "primary";
+    readonly SECONDARY: "secondary";
+    readonly SURFACE: "surface";
+};
+type IdsTableVariantType = (typeof IdsTableVariant)[keyof typeof IdsTableVariant];
+
+declare const DEFAULT_MASTER_DETAIL_TEMPLATE_NAME = "detail";
+interface IdsTableDefaultConfig {
+    appearance?: IdsTableAppearanceType;
+    size?: IdsSizeType;
+    variant?: IdsTableVariantType;
+    fixedHeader?: boolean;
+    enableSorting?: boolean;
+    masterDetail?: boolean;
+    detailTemplateName?: string;
+    detailStickyColumns?: boolean;
+    showDetailHeader?: boolean;
+    enableRowSelection?: boolean;
+    clearSelectionOnChange?: boolean;
+    noRowsToShowOverlayBelow?: boolean;
+    withBorder?: boolean;
+}
+declare const IDS_TABLE_DEFAULT_CONFIG: InjectionToken<IdsTableDefaultConfig>;
+declare function IDS_TABLE_DEFAULT_CONFIG_FACTORY(): Required<IdsTableDefaultConfig>;
+
+declare class IdsTableIntl<D> {
+    readonly changes: Subject<void>;
+    numberFormat: Intl.NumberFormat;
+    headerSelectorAriaLabel: string;
+    rowSelectorAriaLabel: string;
+    detailHeaderLabel: string;
+    getDetailExpandButtonAriaLabel(rowData: D): string;
+    getSortButtonAriaLabel(colDef: IdsTableColumnDef<D>, nextSortDirection: IdsTableSortDirectionType): string;
+    getColLabel(colDef: IdsTableColumnDef<D>): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsTableIntl<any>, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<IdsTableIntl<any>>;
+}
+/** @docs-private */
+declare function IDS_TABLE_INTL_PROVIDER_FACTORY<D>(parentIntl?: IdsTableIntl<D>): IdsTableIntl<D>;
+/** @docs-private */
+declare const IDS_TABLE_INTL_PROVIDER: {
+    provide: typeof IdsTableIntl;
+    deps: Optional[][];
+    useFactory: typeof IDS_TABLE_INTL_PROVIDER_FACTORY;
+};
+
+declare class IdsTableComponent<D> extends ComponentBaseWithDefaults<IdsTableDefaultConfig> implements IdsIconButtonParent, OnInit {
+    private readonly _sortDirections;
+    protected readonly _appearanceZebra: "zebra";
+    protected readonly _defaultMasterDetailTemplateName = "detail";
+    protected readonly _defaultConfig: Required<IdsTableDefaultConfig>;
+    private _cdRef;
+    protected _intl: IdsTableIntl<any>;
+    private _viewCellTemplates;
+    private _rowDataHolders;
+    private _selectorCheckboxes;
+    private _cellContentRenderers;
+    private _contentCellTemplates;
+    columnDefs: _angular_core.InputSignal<IdsTableColumnDef<D>[]>;
+    dataSource: _angular_core.InputSignal<CdkTableDataSourceInput<D>>;
+    /** Flag to have sticky header. */
+    fixedHeader: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Enable sorting feature */
+    enableSorting: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Enable master-detail rows */
+    masterDetail: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Name of the detail row renderer template */
+    detailTemplateName: _angular_core.InputSignal<string>;
+    /** If true the detail cell will not span sticky and stickyEnd columns. If false the detail cell will span the table's full width */
+    detailStickyColumns: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether to show the master-detail column label or not. */
+    showDetailHeader: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Predicate function to decide whether a data row has details or not */
+    hasDetailRow: _angular_core.InputSignal<(index: number, data: D) => boolean>;
+    /** Enable row selection feature */
+    enableRowSelection: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Clear row selection if the table's content changes */
+    clearSelectionOnChange: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Predicate function to decide whether a row can be selected or not */
+    isRowSelectable: _angular_core.InputSignal<(index: number, data: D) => boolean>;
+    /** Render "no rows to show" overlay below the table instead of as a row */
+    noRowsToShowOverlayBelow: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether to show a border around the table or not. */
+    withBorder: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * The table's appearance type. Availabla options:
+     * - "line-division": row backgrounds are uniformly colored and divided by thin border lines
+     * - "zebra": the backgrounds of even and odd rows are different colors
+     * - "plain": row backgrounds are uniformly colored without border lines
+     */
+    appearance: _angular_core.InputSignal<IdsTableAppearanceType>;
+    /** The size type of the table. Affects paddings, margins, gaps, typography, etc. */
+    size: _angular_core.InputSignal<IdsSizeType>;
+    /** The color variant of the table. Availabla options: "primary", "secondary", "surface" */
+    variant: _angular_core.InputSignal<IdsTableVariantType>;
+    /** Emits if the column sorting has changed */
+    sortChange: _angular_core.OutputEmitterRef<IdsTableSortInfo | null>;
+    /** Emits if the user clicked a cell */
+    cellClick: _angular_core.OutputEmitterRef<IdsTableCellClickEvent<D>>;
+    /** Emits if the user clicked a row */
+    rowClick: _angular_core.OutputEmitterRef<IdsTableRowClickEvent<D>>;
+    /** Emits if the user hits a key while a row is in focus */
+    rowKeydown: _angular_core.OutputEmitterRef<IdsTableRowKeydownEvent<D>>;
+    /** Emits if the table's contents have changed */
+    contentChanged: _angular_core.OutputEmitterRef<void>;
+    embeddedIconButtonVariant: _angular_core.Signal<IdsIconButtonVariantType>;
+    embeddedIconButtonAppearance: _angular_core.WritableSignal<IdsIconButtonAppearanceType>;
+    disabled: _angular_core.WritableSignal<boolean>;
+    /** Signal that holds the current table contents as an array of objects */
+    rowData: _angular_core.Signal<D[]>;
+    /** The row selection model for the table */
+    rowSelection: SelectionModel<D>;
+    protected _expandedRows: Set<D>;
+    protected _allRowsExpanded: _angular_core.WritableSignal<boolean>;
+    protected _sortState: _angular_core.WritableSignal<IdsTableSortInfo | null>;
+    protected get _hostName(): string;
+    protected _hostClasses: _angular_core.Signal<string>;
+    protected _actualColumns: _angular_core.Signal<string[]>;
+    protected _hiddenColumns: _angular_core.Signal<{
+        visible: boolean;
+        id: string;
+        label?: string;
+        field?: string;
+        value?: ((rowData: D) => unknown) | undefined;
+        headerCellRenderer?: string | _angular_core.Type<_i_cell_ids_angular_table.IdsTableCellRenderer<D>> | undefined;
+        cellRenderer?: string | _angular_core.Type<_i_cell_ids_angular_table.IdsTableCellRenderer<D>> | undefined;
+        hideable?: boolean;
+        sortable?: boolean;
+        orderName?: string;
+        sticky?: boolean;
+        stickyEnd?: boolean;
+        identifier?: boolean;
+        columnClasses?: string;
+        cellClasses?: string;
+    }[]>;
+    protected _detailRowTemplates: _angular_core.Signal<string[]>;
+    protected _detailColSpan: _angular_core.Signal<number>;
+    protected _cellTemplatesByName: _angular_core.Signal<Map<string, TemplateRef<unknown>>>;
+    protected _defaulDetailTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
+    protected _detailTemplate: _angular_core.Signal<TemplateRef<unknown> | undefined>;
+    protected _hasNoRows: _angular_core.Signal<boolean>;
+    protected _masterDetailEnabled: _angular_core.Signal<boolean>;
+    protected _unselectableRows: _angular_core.Signal<Set<D>>;
+    private _rowSelectorCheckboxes;
+    private _selectableRowData;
+    private _rowSelectionChange;
+    protected _isAllSelected: _angular_core.Signal<boolean>;
+    protected _isSelectAllDisabled: _angular_core.Signal<boolean>;
+    ngOnInit(): void;
+    /**
+     * Open up all row details.
+     */
+    expandAll(): void;
+    /**
+     * Closes all opened row details.
+     */
+    collapseAll(): void;
+    /**
+     * Refresh rendered cell values. Useful if for eg. the `value` getter function is not pure and the values need to be refreshed manually.
+     */
+    updateCellContents(): void;
+    protected _tableContentChanged(): void;
+    protected _getNextSortDirectionFor(colId: string): IdsTableSortDirectionType;
+    protected _handleSortClick(colId: string): void;
+    protected _handleCellClick(event: MouseEvent, rowData: D, colDef: IdsTableColumnDef<D>): void;
+    protected _handleRowClick(event: MouseEvent, rowData: D): void;
+    protected _handleRowKeyDown(event: KeyboardEvent, rowData: D): void;
+    protected _handleMasterDetailClick(rowData: D): void;
+    protected _masterToggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsTableComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IdsTableComponent<any>, "ids-table", ["idsTable"], { "columnDefs": { "alias": "columnDefs"; "required": true; "isSignal": true; }; "dataSource": { "alias": "dataSource"; "required": true; "isSignal": true; }; "fixedHeader": { "alias": "fixedHeader"; "required": false; "isSignal": true; }; "enableSorting": { "alias": "enableSorting"; "required": false; "isSignal": true; }; "masterDetail": { "alias": "masterDetail"; "required": false; "isSignal": true; }; "detailTemplateName": { "alias": "detailTemplateName"; "required": false; "isSignal": true; }; "detailStickyColumns": { "alias": "detailStickyColumns"; "required": false; "isSignal": true; }; "showDetailHeader": { "alias": "showDetailHeader"; "required": false; "isSignal": true; }; "hasDetailRow": { "alias": "hasDetailRow"; "required": false; "isSignal": true; }; "enableRowSelection": { "alias": "enableRowSelection"; "required": false; "isSignal": true; }; "clearSelectionOnChange": { "alias": "clearSelectionOnChange"; "required": false; "isSignal": true; }; "isRowSelectable": { "alias": "isRowSelectable"; "required": false; "isSignal": true; }; "noRowsToShowOverlayBelow": { "alias": "noRowsToShowOverlayBelow"; "required": false; "isSignal": true; }; "withBorder": { "alias": "withBorder"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, { "sortChange": "sortChange"; "cellClick": "cellClick"; "rowClick": "rowClick"; "rowKeydown": "rowKeydown"; "contentChanged": "contentChanged"; }, ["_contentCellTemplates"], ["[idsNoRowsToShow]", "[idsTableCaption]"], true, never>;
+}
+
+export { DEFAULT_DATA_LOAD_DEBOUNCE_TIME, DEFAULT_MASTER_DETAIL_TEMPLATE_NAME, IDS_TABLE_DEFAULT_CONFIG, IDS_TABLE_DEFAULT_CONFIG_FACTORY, IDS_TABLE_INTL_PROVIDER, IDS_TABLE_INTL_PROVIDER_FACTORY, IdsTableAppearance, IdsTableCellRenderer, IdsTableCellTemplateDirective, IdsTableComponent, IdsTableIntl, IdsTableSortDirection, IdsTableSortInfo, IdsTableVariant, ServerSideDataSource };
+export type { IdsTableAppearanceType, IdsTableCellClickEvent, IdsTableColumnDef, IdsTableDefaultConfig, IdsTablePaginationParams, IdsTableRequestFactory, IdsTableRequestPaginationData, IdsTableResponseData, IdsTableRowClickEvent, IdsTableRowKeydownEvent, IdsTableSortDirectionType, IdsTableVariantType };

package/tag/index.d.ts

@@ -1,5 +1,70 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@i-cell/ids-angular/tag" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { IdsSizeType, ComponentBaseWithDefaults } from '@i-cell/ids-angular/core';
+import { IdsIconComponent } from '@i-cell/ids-angular/icon';
+
+declare const IdsTagAppearance: {
+    readonly FILLED: "filled";
+    readonly OUTLINED: "outlined";
+};
+type IdsTagAppearanceType = (typeof IdsTagAppearance)[keyof typeof IdsTagAppearance];
+
+declare const IdsTagVariant: {
+    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 IdsTagVariantType = (typeof IdsTagVariant)[keyof typeof IdsTagVariant];
+
+interface IdsTagDefaultConfig {
+    appearance?: IdsTagAppearanceType;
+    size?: IdsSizeType;
+    variant?: IdsTagVariantType;
+}
+declare const IDS_TAG_DEFAULT_CONFIG: InjectionToken<IdsTagDefaultConfig>;
+declare function IDS_TAG_DEFAULT_CONFIG_FACTORY(): Required<IdsTagDefaultConfig>;
+
+interface IdsTagGroupDefaultConfig {
+    appearance?: IdsTagAppearanceType;
+    size?: IdsSizeType;
+}
+declare const IDS_TAG_GROUP_DEFAULT_CONFIG: InjectionToken<IdsTagGroupDefaultConfig>;
+declare function IDS_TAG_GROUP_DEFAULT_CONFIG_FACTORY(): Required<IdsTagGroupDefaultConfig>;
+
+declare class IdsTagGroupComponent extends ComponentBaseWithDefaults<IdsTagGroupDefaultConfig> {
+    protected get _hostName(): string;
+    protected readonly _defaultConfig: Required<IdsTagGroupDefaultConfig>;
+    appearance: _angular_core.InputSignal<IdsTagAppearanceType>;
+    size: _angular_core.InputSignal<IdsSizeType>;
+    protected _hostClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsTagGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IdsTagGroupComponent, "ids-tag-group", never, { "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["ids-tag, a[idsTag]"], true, never>;
+}
+
+declare class IdsTagComponent extends ComponentBaseWithDefaults<IdsTagDefaultConfig> {
+    protected get _hostName(): string;
+    private readonly _tagGroup;
+    protected readonly _defaultConfig: Required<IdsTagDefaultConfig>;
+    private _hostElement;
+    protected _iconLeading: _angular_core.Signal<readonly IdsIconComponent[]>;
+    protected _iconTrailing: _angular_core.Signal<readonly IdsIconComponent[]>;
+    appearance: _angular_core.InputSignal<IdsTagAppearanceType>;
+    size: _angular_core.InputSignal<IdsSizeType>;
+    variant: _angular_core.InputSignal<IdsTagVariantType>;
+    private _parentOrSelfAppearance;
+    private _parentOrSelfSize;
+    protected _hostClasses: _angular_core.Signal<string>;
+    private get _hostType();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsTagComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IdsTagComponent, "ids-tag,a[idsTag]", never, { "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, ["_iconLeading", "_iconTrailing"], ["ids-icon[icon-leading]", "*", "ids-icon[icon-trailing]"], true, never>;
+}
+
+export { IDS_TAG_DEFAULT_CONFIG, IDS_TAG_DEFAULT_CONFIG_FACTORY, IDS_TAG_GROUP_DEFAULT_CONFIG, IDS_TAG_GROUP_DEFAULT_CONFIG_FACTORY, IdsTagAppearance, IdsTagComponent, IdsTagGroupComponent, IdsTagVariant };
+export type { IdsTagAppearanceType, IdsTagDefaultConfig, IdsTagGroupDefaultConfig, IdsTagVariantType };

package/tooltip/index.d.ts

@@ -1,5 +1,96 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@i-cell/ids-angular/tooltip" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, AfterViewInit, OnDestroy } from '@angular/core';
+import { IdsSizeType, DirectiveBaseWithDefaults } from '@i-cell/ids-angular/core';
+
+declare const IdsTooltipPosition: {
+    readonly NORTH: "north";
+    readonly NORTHEAST: "northeast";
+    readonly EAST: "east";
+    readonly SOUTHEAST: "southeast";
+    readonly SOUTH: "south";
+    readonly SOUTHWEST: "southwest";
+    readonly WEST: "west";
+    readonly NORTHWEST: "northwest";
+};
+type IdsTooltipPositionType = (typeof IdsTooltipPosition)[keyof typeof IdsTooltipPosition];
+
+declare const IdsTooltipVariant: {
+    readonly LIGHT: "light";
+    readonly DARK: "dark";
+};
+type IdsTooltipVariantType = (typeof IdsTooltipVariant)[keyof typeof IdsTooltipVariant];
+
+type IdsTooltipTouchGestures = 'auto' | 'on' | 'off';
+type IdsTooltipTextAlign = 'auto' | 'center' | 'left' | 'right';
+
+interface IdsTooltipDefaultConfig {
+    position?: IdsTooltipPositionType;
+    size?: IdsSizeType;
+    variant?: IdsTooltipVariantType;
+    showPointer?: boolean;
+    showDelay?: number;
+    hideDelay?: number;
+    touchLongPressShowDelay?: number;
+    viewPortMargin?: number;
+    touchendHideDelay?: number;
+    scrollDebounceTime?: number;
+}
+declare const IDS_TOOLTIP_DEFAULT_CONFIG: InjectionToken<IdsTooltipDefaultConfig>;
+declare function IDS_TOOLTIP_DEFAULT_CONFIG_FACTORY(): Required<IdsTooltipDefaultConfig>;
+
+declare class IdsTooltipDirective extends DirectiveBaseWithDefaults<IdsTooltipDefaultConfig> implements AfterViewInit, OnDestroy {
+    protected get _hostName(): string;
+    private readonly _focusMonitor;
+    private readonly _platform;
+    private readonly _ngZone;
+    private readonly _elementRef;
+    private readonly _viewContainerRef;
+    private readonly _scrollDispatcher;
+    private readonly _overlay;
+    private readonly _document;
+    protected readonly _defaultConfig: Required<IdsTooltipDefaultConfig>;
+    private readonly _passiveListeners;
+    private _overlayRef;
+    private _portal?;
+    private _componentRef?;
+    private _tooltipInstance;
+    private _touchstartTimeout?;
+    private _showTimeout?;
+    private _pointerExitEventsInitialized;
+    private _viewportMargin;
+    private _currentPosition;
+    message: _angular_core.InputSignalWithTransform<string, string>;
+    position: _angular_core.InputSignal<IdsTooltipPositionType>;
+    size: _angular_core.InputSignal<IdsSizeType>;
+    variant: _angular_core.InputSignal<IdsTooltipVariantType>;
+    showDelay: _angular_core.InputSignal<number>;
+    hideDelay: _angular_core.InputSignal<number>;
+    disabled: _angular_core.InputSignal<boolean>;
+    touchGestures: _angular_core.InputSignal<IdsTooltipTouchGestures>;
+    textAlign: _angular_core.InputSignal<IdsTooltipTextAlign>;
+    tooltipClass: _angular_core.InputSignal<string | undefined>;
+    showPointer: _angular_core.InputSignal<boolean>;
+    protected _hostClasses: _angular_core.Signal<string>;
+    private _tooltipClassEffect;
+    ngAfterViewInit(): void;
+    show(): void;
+    hide(delay?: number): void;
+    toggle(): void;
+    private _createOverlay;
+    private _detach;
+    private _updatePosition;
+    private _updateCurrentPositionClass;
+    private _setTooltipInputs;
+    private _setupPointerEnterEventsIfNeeded;
+    private _wheelListener;
+    private _setupPointerExitEventsIfNeeded;
+    private _addListeners;
+    private _disableNativeGesturesIfNecessary;
+    private _platformSupportsMouseEvents;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IdsTooltipDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IdsTooltipDirective, "[idsTooltip]", never, { "message": { "alias": "idsTooltip"; "required": false; "isSignal": true; }; "position": { "alias": "idsTooltipPosition"; "required": false; "isSignal": true; }; "size": { "alias": "idsTooltipSize"; "required": false; "isSignal": true; }; "variant": { "alias": "idsTooltipVariant"; "required": false; "isSignal": true; }; "showDelay": { "alias": "idsTooltipShowDelay"; "required": false; "isSignal": true; }; "hideDelay": { "alias": "idsTooltipHideDelay"; "required": false; "isSignal": true; }; "disabled": { "alias": "idsTooltipDisabled"; "required": false; "isSignal": true; }; "touchGestures": { "alias": "idsTooltipTouchGestures"; "required": false; "isSignal": true; }; "textAlign": { "alias": "idsTooltipTextAlign"; "required": false; "isSignal": true; }; "tooltipClass": { "alias": "idsTooltipClass"; "required": false; "isSignal": true; }; "showPointer": { "alias": "idsTooltipShowPointer"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { IDS_TOOLTIP_DEFAULT_CONFIG, IDS_TOOLTIP_DEFAULT_CONFIG_FACTORY, IdsTooltipDirective, IdsTooltipPosition, IdsTooltipVariant };
+export type { IdsTooltipDefaultConfig, IdsTooltipPositionType, IdsTooltipTextAlign, IdsTooltipTouchGestures, IdsTooltipVariantType };

package/accordion/accordion-animations.d.ts

@@ -1 +0,0 @@
-export declare const accordionAnimations: import("@angular/animations").AnimationTriggerMetadata;