@i-cell/ids-angular 0.1.0

package/tab/types/tab-group-variant.type.d.ts

@@ -0,0 +1,6 @@
+export declare const IdsTabGroupVariant: {
+    readonly PRIMARY: "primary";
+    readonly SURFACE: "surface";
+    readonly LIGHT: "light";
+};
+export type IdsTabGroupVariantType = (typeof IdsTabGroupVariant)[keyof typeof IdsTabGroupVariant];

package/tab/types/tab-indicator-position.type.d.ts

@@ -0,0 +1,7 @@
+export declare const IdsTabIndicatorPosition: {
+    readonly TOP: "top";
+    readonly BOTTOM: "bottom";
+    readonly LEFT: "left";
+    readonly RIGHT: "right";
+};
+export type IdsTabIndicatorPositionType = (typeof IdsTabIndicatorPosition)[keyof typeof IdsTabIndicatorPosition];

package/table/components/cell-content/cell-content.component.d.ts

@@ -0,0 +1,25 @@
+import { IdsTableCellRenderer } from '../../directives/cell-renderer';
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * This component handles the rendering of a table cell based on the column definition and row data using internal or external cell renderer
+ * templates or components.
+ */
+export declare class IdsCellContentComponent<D> extends IdsTableCellRenderer<D> {
+    private _elementRef;
+    private _intl;
+    private _isHeader;
+    private _numberFormat;
+    externalCellTemplates: import("@angular/core").InputSignal<Map<string, TemplateRef<unknown>> | undefined>;
+    private _cellRendererDef;
+    private _updateCellContent;
+    protected _cellValue: import("@angular/core").Signal<unknown>;
+    protected _stringCellValue: import("@angular/core").Signal<string>;
+    protected _numericCellValue: import("@angular/core").Signal<string>;
+    protected _cellRendererComp: import("@angular/core").Signal<import("@angular/core").Type<IdsTableCellRenderer<D>> | null>;
+    protected _cellTemplateName: import("@angular/core").Signal<string | undefined>;
+    protected _cellTemplate: import("@angular/core").Signal<TemplateRef<unknown> | null>;
+    updateValue(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IdsCellContentComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IdsCellContentComponent<any>, "th[idsCellContent],td[idsCellContent],th[idsHeaderCellContent],td[idsHeaderCellContent]", never, { "externalCellTemplates": { "alias": "externalCellTemplates"; "required": false; "isSignal": true; }; }, {}, never, ["[colStart]", "[colEnd]"], true, never>;
+}

package/table/datasource/server-side-datasource.d.ts

@@ -0,0 +1,37 @@
+import { IdsTablePaginationParams } from '../types/pagination-params';
+import { IdsTableRequestFactory } from '../types/request-factory';
+import { IdsTableSortInfo } from '../types/table-sort-info';
+import { DataSource } from '@angular/cdk/collections';
+import { IdsPaginatorPageChangeEvent } from '@i-cell/ids-angular/paginator';
+import { Observable } from 'rxjs';
+export declare const DEFAULT_DATA_LOAD_DEBOUNCE_TIME = 100;
+export 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;
+}

package/table/directives/cell-renderer.d.ts

@@ -0,0 +1,13 @@
+import { IdsTableColumnDef } from '../types/table-column-def';
+import { Type } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare abstract class IdsTableCellRenderer<D> {
+    private readonly _entities;
+    cellValue: import("@angular/core").InputSignalWithTransform<string, unknown>;
+    colDef: import("@angular/core").InputSignal<IdsTableColumnDef<D>>;
+    rowData: import("@angular/core").InputSignal<D | undefined>;
+    protected _isComponentCellRenderer<C>(cellRendererDef: string | Type<C> | undefined): cellRendererDef is Type<C>;
+    protected _preSanitize(input: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IdsTableCellRenderer<any>, never>;
+    static ɵdir: i0.ɵɵ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>;
+}

package/table/directives/cell-template.d.ts

@@ -0,0 +1,8 @@
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class IdsTableCellTemplateDirective {
+    templateName: import("@angular/core").InputSignal<string>;
+    templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IdsTableCellTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IdsTableCellTemplateDirective, "[idsCellTemplate]", never, { "templateName": { "alias": "idsCellTemplate"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/table/directives/row-info-holder.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+export declare class RowInfoHolderDirective<D> {
+    rowInfo: import("@angular/core").InputSignal<{
+        rowData: D;
+        index: number;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RowInfoHolderDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RowInfoHolderDirective<any>, "[rowInfo]", never, { "rowInfo": { "alias": "rowInfo"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/table/index.d.ts

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

package/table/public-api.d.ts

@@ -0,0 +1,18 @@
+export * from './datasource/server-side-datasource';
+export * from './directives/cell-renderer';
+export * from './directives/cell-template';
+export * from './types/pagination-params';
+export * from './types/request-factory';
+export * from './types/request-pagination-data';
+export * from './types/response-data';
+export * from './types/table-appearance.type';
+export * from './types/table-cell-click-event';
+export * from './types/table-column-def';
+export * from './types/table-row-click-event';
+export * from './types/table-row-keydown-event';
+export * from './types/table-sort-direction';
+export * from './types/table-sort-info';
+export * from './types/table-variant.type';
+export * from './table-defaults';
+export * from './table-intl';
+export * from './table.component';

package/table/table-defaults.d.ts

@@ -0,0 +1,22 @@
+import { IdsTableAppearanceType } from './types/table-appearance.type';
+import { IdsTableVariantType } from './types/table-variant.type';
+import { InjectionToken } from '@angular/core';
+import { IdsSizeType } from '@i-cell/ids-angular/core';
+export declare const DEFAULT_MASTER_DETAIL_TEMPLATE_NAME = "detail";
+export 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;
+}
+export declare const IDS_TABLE_DEFAULT_CONFIG: InjectionToken<IdsTableDefaultConfig>;
+export declare function IDS_TABLE_DEFAULT_CONFIG_FACTORY(): Required<IdsTableDefaultConfig>;

package/table/table-intl.d.ts

@@ -0,0 +1,25 @@
+import { IdsTableColumnDef } from './types/table-column-def';
+import { IdsTableSortDirectionType } from './types/table-sort-direction';
+import { Optional } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export 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: i0.ɵɵFactoryDeclaration<IdsTableIntl<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IdsTableIntl<any>>;
+}
+/** @docs-private */
+export declare function IDS_TABLE_INTL_PROVIDER_FACTORY<D>(parentIntl?: IdsTableIntl<D>): IdsTableIntl<D>;
+/** @docs-private */
+export declare const IDS_TABLE_INTL_PROVIDER: {
+    provide: typeof IdsTableIntl;
+    deps: Optional[][];
+    useFactory: typeof IDS_TABLE_INTL_PROVIDER_FACTORY;
+};

package/table/table.component.d.ts

@@ -0,0 +1,142 @@
+import { IdsTableDefaultConfig } from './table-defaults';
+import { IdsTableIntl } from './table-intl';
+import { IdsTableAppearanceType } from './types/table-appearance.type';
+import { IdsTableCellClickEvent } from './types/table-cell-click-event';
+import { IdsTableColumnDef } from './types/table-column-def';
+import { IdsTableRowClickEvent } from './types/table-row-click-event';
+import { IdsTableRowKeydownEvent } from './types/table-row-keydown-event';
+import { IdsTableSortDirectionType } from './types/table-sort-direction';
+import { IdsTableSortInfo } from './types/table-sort-info';
+import { IdsTableVariantType } from './types/table-variant.type';
+import { SelectionModel } from '@angular/cdk/collections';
+import { CdkTableDataSourceInput } from '@angular/cdk/table';
+import { OnInit, TemplateRef } from '@angular/core';
+import { ComponentBaseWithDefaults, IdsSizeType } from '@i-cell/ids-angular/core';
+import { IdsIconButtonAppearanceType, IdsIconButtonParent, IdsIconButtonVariantType } from '@i-cell/ids-angular/icon-button';
+import * as i0 from "@angular/core";
+export 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: import("@angular/core").InputSignal<IdsTableColumnDef<D>[]>;
+    dataSource: import("@angular/core").InputSignal<CdkTableDataSourceInput<D>>;
+    /** Flag to have sticky header. */
+    fixedHeader: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /** Enable sorting feature */
+    enableSorting: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /** Enable master-detail rows */
+    masterDetail: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /** Name of the detail row renderer template */
+    detailTemplateName: import("@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: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /** Whether to show the master-detail column label or not. */
+    showDetailHeader: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /** Predicate function to decide whether a data row has details or not */
+    hasDetailRow: import("@angular/core").InputSignal<(index: number, data: D) => boolean>;
+    /** Enable row selection feature */
+    enableRowSelection: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /** Clear row selection if the table's content changes */
+    clearSelectionOnChange: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /** Predicate function to decide whether a row can be selected or not */
+    isRowSelectable: import("@angular/core").InputSignal<(index: number, data: D) => boolean>;
+    /** Render "no rows to show" overlay below the table instead of as a row */
+    noRowsToShowOverlayBelow: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /** Whether to show a border around the table or not. */
+    withBorder: import("@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: import("@angular/core").InputSignal<IdsTableAppearanceType>;
+    /** The size type of the table. Affects paddings, margins, gaps, typography, etc. */
+    size: import("@angular/core").InputSignal<IdsSizeType>;
+    /** The color variant of the table. Availabla options: "primary", "secondary", "surface" */
+    variant: import("@angular/core").InputSignal<IdsTableVariantType>;
+    /** Emits if the column sorting has changed */
+    sortChange: import("@angular/core").OutputEmitterRef<IdsTableSortInfo | null>;
+    /** Emits if the user clicked a cell */
+    cellClick: import("@angular/core").OutputEmitterRef<IdsTableCellClickEvent<D>>;
+    /** Emits if the user clicked a row */
+    rowClick: import("@angular/core").OutputEmitterRef<IdsTableRowClickEvent<D>>;
+    /** Emits if the user hits a key while a row is in focus */
+    rowKeydown: import("@angular/core").OutputEmitterRef<IdsTableRowKeydownEvent<D>>;
+    /** Emits if the table's contents have changed */
+    contentChanged: import("@angular/core").OutputEmitterRef<void>;
+    embeddedIconButtonVariant: import("@angular/core").Signal<IdsIconButtonVariantType>;
+    embeddedIconButtonAppearance: import("@angular/core").WritableSignal<IdsIconButtonAppearanceType>;
+    disabled: import("@angular/core").WritableSignal<boolean>;
+    /** Signal that holds the current table contents as an array of objects */
+    rowData: import("@angular/core").Signal<D[]>;
+    /** The row selection model for the table */
+    rowSelection: SelectionModel<D>;
+    protected _expandedRows: Set<D>;
+    protected _allRowsExpanded: import("@angular/core").WritableSignal<boolean>;
+    protected _sortState: import("@angular/core").WritableSignal<IdsTableSortInfo | null>;
+    protected get _hostName(): string;
+    protected _hostClasses: import("@angular/core").Signal<string>;
+    protected _actualColumns: import("@angular/core").Signal<string[]>;
+    protected _hiddenColumns: import("@angular/core").Signal<{
+        visible: boolean;
+        id: string;
+        label?: string;
+        field?: string;
+        value?: ((rowData: D) => unknown) | undefined;
+        headerCellRenderer?: string | import("@angular/core").Type<import("@i-cell/ids-angular/table").IdsTableCellRenderer<D>> | undefined;
+        cellRenderer?: string | import("@angular/core").Type<import("@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: import("@angular/core").Signal<string[]>;
+    protected _detailColSpan: import("@angular/core").Signal<number>;
+    protected _cellTemplatesByName: import("@angular/core").Signal<Map<string, TemplateRef<unknown>>>;
+    protected _defaulDetailTemplate: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+    protected _detailTemplate: import("@angular/core").Signal<TemplateRef<unknown> | undefined>;
+    protected _hasNoRows: import("@angular/core").Signal<boolean>;
+    protected _masterDetailEnabled: import("@angular/core").Signal<boolean>;
+    protected _unselectableRows: import("@angular/core").Signal<Set<D>>;
+    private _rowSelectorCheckboxes;
+    private _selectableRowData;
+    private _rowSelectionChange;
+    protected _isAllSelected: import("@angular/core").Signal<boolean>;
+    protected _isSelectAllDisabled: import("@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: i0.ɵɵFactoryDeclaration<IdsTableComponent<any>, never>;
+    static ɵcmp: i0.ɵɵ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>;
+}

package/table/types/pagination-params.d.ts

@@ -0,0 +1,9 @@
+export 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;
+}

package/table/types/request-factory.d.ts

@@ -0,0 +1,5 @@
+import { IdsTableRequestPaginationData } from './request-pagination-data';
+import { IdsTableResponseData } from './response-data';
+import { IdsTableSortInfo } from './table-sort-info';
+import { Observable } from 'rxjs';
+export type IdsTableRequestFactory<D> = (paginationData: IdsTableRequestPaginationData | null, sortInfo: IdsTableSortInfo | null) => Observable<IdsTableResponseData<D>>;

package/table/types/request-pagination-data.d.ts

@@ -0,0 +1,6 @@
+export interface IdsTableRequestPaginationData {
+    /** The number of requested items per page */
+    rows: number;
+    /** The requested page index (1 based) */
+    page: number;
+}

package/table/types/response-data.d.ts

@@ -0,0 +1,5 @@
+import { IdsTablePaginationParams } from './pagination-params';
+export interface IdsTableResponseData<D> {
+    resultList: D[];
+    paginationParams: IdsTablePaginationParams;
+}

package/table/types/table-appearance.type.d.ts

@@ -0,0 +1,6 @@
+export declare const IdsTableAppearance: {
+    readonly PLAIN: "plain";
+    readonly LINE_DIVISION: "line-division";
+    readonly ZEBRA: "zebra";
+};
+export type IdsTableAppearanceType = (typeof IdsTableAppearance)[keyof typeof IdsTableAppearance];

package/table/types/table-cell-click-event.d.ts

@@ -0,0 +1,6 @@
+import { IdsTableColumnDef } from './table-column-def';
+export interface IdsTableCellClickEvent<D> {
+    event: MouseEvent;
+    colDef: IdsTableColumnDef<D>;
+    rowData: D;
+}

package/table/types/table-column-def.d.ts

@@ -0,0 +1,97 @@
+import { IdsTableCellRenderer } from '../directives/cell-renderer';
+import { Type } from '@angular/core';
+/**
+ * Column definition type for the i-DS table component.
+ */
+export 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;
+};

package/table/types/table-row-click-event.d.ts

@@ -0,0 +1,4 @@
+export interface IdsTableRowClickEvent<D> {
+    event: MouseEvent;
+    rowData: D;
+}

package/table/types/table-row-keydown-event.d.ts

@@ -0,0 +1,4 @@
+export interface IdsTableRowKeydownEvent<D> {
+    event: KeyboardEvent;
+    rowData: D;
+}

package/table/types/table-sort-direction.d.ts

@@ -0,0 +1,6 @@
+export declare const IdsTableSortDirection: {
+    readonly NONE: "";
+    readonly ASC: "asc";
+    readonly DESC: "desc";
+};
+export type IdsTableSortDirectionType = (typeof IdsTableSortDirection)[keyof typeof IdsTableSortDirection];

package/table/types/table-sort-info.d.ts

@@ -0,0 +1,6 @@
+import { IdsTableSortDirectionType } from './table-sort-direction';
+export declare class IdsTableSortInfo {
+    sortBy: string;
+    direction: IdsTableSortDirectionType;
+    constructor(sortBy: string, direction: IdsTableSortDirectionType);
+}

package/table/types/table-variant.type.d.ts

@@ -0,0 +1,6 @@
+export declare const IdsTableVariant: {
+    readonly PRIMARY: "primary";
+    readonly SECONDARY: "secondary";
+    readonly SURFACE: "surface";
+};
+export type IdsTableVariantType = (typeof IdsTableVariant)[keyof typeof IdsTableVariant];

package/tag/index.d.ts

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

package/tag/public-api.d.ts

@@ -0,0 +1,6 @@
+export * from './types/tag-appearance.type';
+export * from './types/tag-variant.type';
+export * from './tag-defaults';
+export * from './tag-group-defaults';
+export * from './tag-group.component';
+export * from './tag.component';

package/tag/tag-defaults.d.ts

@@ -0,0 +1,11 @@
+import { IdsTagAppearanceType } from './types/tag-appearance.type';
+import { IdsTagVariantType } from './types/tag-variant.type';
+import { InjectionToken } from '@angular/core';
+import { IdsSizeType } from '@i-cell/ids-angular/core';
+export interface IdsTagDefaultConfig {
+    appearance?: IdsTagAppearanceType;
+    size?: IdsSizeType;
+    variant?: IdsTagVariantType;
+}
+export declare const IDS_TAG_DEFAULT_CONFIG: InjectionToken<IdsTagDefaultConfig>;
+export declare function IDS_TAG_DEFAULT_CONFIG_FACTORY(): Required<IdsTagDefaultConfig>;

package/tag/tag-group-defaults.d.ts

@@ -0,0 +1,9 @@
+import { IdsTagAppearanceType } from './types/tag-appearance.type';
+import { InjectionToken } from '@angular/core';
+import { IdsSizeType } from '@i-cell/ids-angular/core';
+export interface IdsTagGroupDefaultConfig {
+    appearance?: IdsTagAppearanceType;
+    size?: IdsSizeType;
+}
+export declare const IDS_TAG_GROUP_DEFAULT_CONFIG: InjectionToken<IdsTagGroupDefaultConfig>;
+export declare function IDS_TAG_GROUP_DEFAULT_CONFIG_FACTORY(): Required<IdsTagGroupDefaultConfig>;

package/tag/tag-group.component.d.ts

@@ -0,0 +1,13 @@
+import { IdsTagGroupDefaultConfig } from './tag-group-defaults';
+import { IdsTagAppearanceType } from './types/tag-appearance.type';
+import { ComponentBaseWithDefaults, IdsSizeType } from '@i-cell/ids-angular/core';
+import * as i0 from "@angular/core";
+export declare class IdsTagGroupComponent extends ComponentBaseWithDefaults<IdsTagGroupDefaultConfig> {
+    protected get _hostName(): string;
+    protected readonly _defaultConfig: Required<IdsTagGroupDefaultConfig>;
+    appearance: import("@angular/core").InputSignal<IdsTagAppearanceType>;
+    size: import("@angular/core").InputSignal<IdsSizeType>;
+    protected _hostClasses: import("@angular/core").Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IdsTagGroupComponent, never>;
+    static ɵcmp: i0.ɵɵ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>;
+}

package/tag/tag.component.d.ts

@@ -0,0 +1,23 @@
+import { IdsTagDefaultConfig } from './tag-defaults';
+import { IdsTagAppearanceType } from './types/tag-appearance.type';
+import { IdsTagVariantType } from './types/tag-variant.type';
+import { ComponentBaseWithDefaults, IdsSizeType } from '@i-cell/ids-angular/core';
+import { IdsIconComponent } from '@i-cell/ids-angular/icon';
+import * as i0 from "@angular/core";
+export declare class IdsTagComponent extends ComponentBaseWithDefaults<IdsTagDefaultConfig> {
+    protected get _hostName(): string;
+    private readonly _tagGroup;
+    protected readonly _defaultConfig: Required<IdsTagDefaultConfig>;
+    private _hostElement;
+    iconLeading: import("@angular/core").Signal<readonly IdsIconComponent[]>;
+    iconTrailing: import("@angular/core").Signal<readonly IdsIconComponent[]>;
+    appearance: import("@angular/core").InputSignal<IdsTagAppearanceType>;
+    size: import("@angular/core").InputSignal<IdsSizeType>;
+    variant: import("@angular/core").InputSignal<IdsTagVariantType>;
+    private _parentOrSelfAppearance;
+    private _parentOrSelfSize;
+    protected _hostClasses: import("@angular/core").Signal<string>;
+    private get _hostType();
+    static ɵfac: i0.ɵɵFactoryDeclaration<IdsTagComponent, never>;
+    static ɵcmp: i0.ɵɵ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>;
+}

package/tag/types/tag-appearance.type.d.ts

@@ -0,0 +1,5 @@
+export declare const IdsTagAppearance: {
+    readonly FILLED: "filled";
+    readonly OUTLINED: "outlined";
+};
+export type IdsTagAppearanceType = (typeof IdsTagAppearance)[keyof typeof IdsTagAppearance];

package/tag/types/tag-variant.type.d.ts

@@ -0,0 +1,13 @@
+export 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";
+};
+export type IdsTagVariantType = (typeof IdsTagVariant)[keyof typeof IdsTagVariant];

package/tooltip/index.d.ts

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