@sd-angular/core 1.3.146 → 1.3.148

package/table/src/lib/components/popup-filter/popup-filter.component.d.ts

@@ -0,0 +1,27 @@
+import { ChangeDetectorRef } from '@angular/core';
+import { SdModal } from '@sd-angular/core/modal';
+import { SdTableColumn } from '../../models/table-column.model';
+import { SdTableExternalFilter, SdGridMaterialFilterRegister } from '../../services/table-filter/table-filter.model';
+import { SdMaterialFilterDefDirective } from '../../directives/sd-material-filter-def.directive';
+export declare class SdPopupFilter {
+    #private;
+    private cdRef;
+    modal: SdModal;
+    set filterRegister(value: SdGridMaterialFilterRegister);
+    externalFilters: SdTableExternalFilter[];
+    externalFilter: Record<string, any>;
+    inlineExternal: Record<string, boolean>;
+    columns: SdTableColumn[];
+    columnFilter: Record<string, any>;
+    inlineColumn: Record<string, boolean>;
+    filterDefs: SdMaterialFilterDefDirective[];
+    filterDef: Record<string, any>;
+    inlineFilterDef: Record<string, boolean>;
+    constructor(cdRef: ChangeDetectorRef);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    open: () => void;
+    close: () => void;
+    onApply: () => void;
+    onClear(): void;
+}

package/table/src/lib/components/popup-grid-configuration/popup-grid-configuration.component.d.ts

@@ -0,0 +1,39 @@
+import { OnInit, EventEmitter, ChangeDetectorRef } from '@angular/core';
+import { SdModal } from '@sd-angular/core/modal';
+import { SdNotifyService } from '@sd-angular/core/notify';
+import { SdTranslateService } from '@sd-angular/core/translate';
+import { SdTableOption } from '../../models/table-option.model';
+import { SdGridConfigurationResult, SdGridConfiguration } from '../../models/table-option-config.model';
+import { SdTableConfigurationService } from '../../services/table-configuration.service';
+import { MatTable } from '@angular/material/table';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import { SdTableColumn } from '../../models/table-column.model';
+export declare class SdPopupGridConfiguration implements OnInit {
+    #private;
+    private ref;
+    private notifyService;
+    private translateService;
+    private gridConfigurationService;
+    gridOption: SdTableOption;
+    key: string;
+    modal: SdModal;
+    table: MatTable<SdTableColumn>;
+    readonly changes: EventEmitter<SdGridConfigurationResult>;
+    configuration: SdGridConfiguration;
+    isCreatingColumn: boolean;
+    selected: {
+        [key: string]: boolean;
+    };
+    disabledDrag: boolean;
+    constructor(ref: ChangeDetectorRef, notifyService: SdNotifyService, translateService: SdTranslateService, gridConfigurationService: SdTableConfigurationService);
+    ngOnInit(): void;
+    mouseUp(event: any): void;
+    open: () => Promise<void>;
+    onSave: () => void;
+    onReset: () => Promise<void>;
+    createColumn: () => Promise<void>;
+    confirm: () => Promise<void>;
+    dropTable(event: CdkDragDrop<SdTableColumn[]>): void;
+    handleMouseDown(): void;
+    handleMouseUp(): void;
+}

package/table/src/lib/components/quick-action/quick-action.component.d.ts

@@ -0,0 +1,9 @@
+import { EventEmitter } from '@angular/core';
+import { SdTableOption } from '../../models/table-option.model';
+export declare class SdGridQuickAction {
+    gridOption: SdTableOption;
+    selectedItems: any[];
+    clear: EventEmitter<any>;
+    constructor();
+    onClear: () => void;
+}

package/table/src/lib/directives/sd-material-cell-def.directive.d.ts

@@ -0,0 +1,6 @@
+import { TemplateRef } from '@angular/core';
+export declare class SdMaterialCellDefDirective {
+    templateRef: TemplateRef<any>;
+    sdMaterialCellDef: string;
+    constructor(templateRef: TemplateRef<any>);
+}

package/table/src/lib/directives/sd-material-empty-data-def.directive.d.ts

@@ -0,0 +1,5 @@
+import { TemplateRef } from '@angular/core';
+export declare class SdMaterialEmptyDataDefDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+}

package/table/src/lib/directives/sd-material-filter-def.directive.d.ts

@@ -0,0 +1,8 @@
+import { TemplateRef } from '@angular/core';
+export declare class SdMaterialFilterDefDirective {
+    templateRef: TemplateRef<any>;
+    sdMaterialFilterDef: string;
+    set showing(val: boolean | '');
+    defaultShowing: boolean;
+    constructor(templateRef: TemplateRef<any>);
+}

package/table/src/lib/directives/sd-material-footer-def.directive.d.ts

@@ -0,0 +1,6 @@
+import { TemplateRef } from '@angular/core';
+export declare class SdMaterialFooterDefDirective {
+    templateRef: TemplateRef<any>;
+    sdMaterialFooterDef: string;
+    constructor(templateRef: TemplateRef<any>);
+}

package/table/src/lib/directives/sd-material-sub-information-def.directive.d.ts

@@ -0,0 +1,5 @@
+import { TemplateRef } from '@angular/core';
+export declare class SdMaterialSubInformationDefDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+}

package/table/src/lib/models/grid-cell.model.d.ts

@@ -0,0 +1,16 @@
+import { SdBadgeColor } from "@sd-angular/core/badge";
+export interface SdCellView {
+    badge?: {
+        type: 'round' | 'circle' | 'icon';
+        color: SdBadgeColor;
+        icon: string;
+    };
+    tooltip?: string;
+    display: {
+        align: 'center' | 'left' | 'right';
+        value: string;
+        hasHtml?: boolean;
+        html?: string;
+    };
+    click?: () => void;
+}

package/table/src/lib/models/index.d.ts

@@ -0,0 +1,3 @@
+export * from './table-option.model';
+export * from './table-column.model';
+export * from './table-command.model';

package/table/src/lib/models/table-column.model.d.ts

@@ -0,0 +1,125 @@
+import { SdBadgeColor } from '@sd-angular/core/badge';
+export declare type SdTableColumn<T = any> = SdTableColumnText<T> | SdTableColumnNumber<T> | SdTableColumnBool<T> | SdTableColumnDate<T> | SdTableColumnValues<T> | SdTableColumnChildren<T>;
+export declare type SdFilterOperator = 'EQUAL' | 'NOT_EQUAL' | 'CONTAIN' | 'NOT_CONTAIN' | 'IN' | 'NOT_IN' | 'START_WITH' | 'END_WITH' | 'GREATER_THAN' | 'LESS_THAN' | 'GREATER_OR_EQUAL' | 'LESS_OR_EQUAL';
+export declare const SdFilterOperators: {
+    value: SdFilterOperator;
+    symbol?: string;
+    display: string;
+}[];
+export declare type SdTableColumnTransformFunc<T = any> = (value: any, rowData: T, args?: {
+    isExport?: boolean;
+}) => string | Promise<string>;
+interface SdTableColumnBase<T = any> {
+    field: string;
+    title: string;
+    titleHtml?: string;
+    description?: string;
+    width?: string;
+    hidden?: boolean;
+    invisible?: boolean;
+    fixed?: boolean;
+    align?: 'center' | 'left' | 'right';
+    htmlTemplate?: (value: any, rowData: T, isMobileOrTablet: boolean) => string;
+    transform?: SdTableColumnTransformFunc<T>;
+    tooltip?: (value: any, rowData: T) => string;
+    click?: (value: any, rowData: T) => void;
+    sortable?: boolean;
+    filter?: {
+        disabled?: boolean;
+        defaultShowing?: boolean;
+        default?: any;
+        operator?: {
+            enable?: boolean;
+            list?: SdFilterOperator[];
+        };
+    };
+    export?: {
+        disabled?: boolean;
+    };
+}
+interface SdTableColumnText<T = any> extends SdTableColumnBase<T> {
+    type: 'string';
+    badge?: (value: any, rowData: T) => SdBadgeColor;
+    badgeIcon?: (value: any, rowData: T) => string;
+    badgeType?: 'circle' | 'icon';
+    editor?: {
+        change?: (rowData: T, selected?: any) => void;
+        hidden?: boolean | ((rowData: T) => boolean);
+        disabled?: boolean | ((rowData: T) => boolean);
+        required?: boolean | ((rowData: T) => boolean);
+        minLength?: number;
+        maxLength?: number;
+        validator?: (rowData: T) => string;
+    };
+}
+interface SdTableColumnNumber<T = any> extends SdTableColumnBase<T> {
+    type: 'number';
+    badge?: (value: any, rowData: T) => SdBadgeColor;
+    badgeIcon?: (value: any, rowData: T) => string;
+    badgeType?: 'circle' | 'icon';
+    editor?: {
+        change?: (rowData: T, selected?: any) => void;
+        hidden?: boolean | ((rowData: T) => boolean);
+        disabled?: boolean | ((rowData: T) => boolean);
+        required?: boolean | ((rowData: T) => boolean);
+        minValue?: number;
+        maxValue?: number;
+        precision?: number;
+        validator?: (rowData: T) => string;
+    };
+}
+interface SdTableColumnBool<T = any> extends SdTableColumnBase<T> {
+    type: 'bool';
+    option?: {
+        displayOnTrue?: string;
+        displayOnFalse?: string;
+    };
+    badgeType?: 'circle';
+    editor?: {
+        change?: (rowData: T, selected?: any) => void;
+        hidden?: boolean | ((rowData: T) => boolean);
+        disabled?: boolean | ((rowData: T) => boolean);
+        required?: boolean | ((rowData: T) => boolean);
+    };
+}
+interface SdTableColumnDate<T = any> extends SdTableColumnBase<T> {
+    type: 'date' | 'datetime' | 'time';
+    option?: {
+        useFilterDate?: boolean;
+        timeDifferent?: 'second' | 'minute' | 'hour' | 'day' | 'month';
+    };
+    transformDate?: (value: any, rowData: T) => string | Date;
+    editor?: {
+        change?: (rowData: T, selected?: any) => void;
+        hidden?: boolean | ((rowData: T) => boolean);
+        disabled?: boolean | ((rowData: T) => boolean);
+        required?: boolean | ((rowData: T) => boolean);
+    };
+}
+export interface SdTableColumnValues<T = any> extends SdTableColumnBase<T> {
+    type: 'values';
+    badge?: (value: any, rowData: T) => SdBadgeColor;
+    badgeIcon?: (value: any, rowData: T) => string;
+    badgeType?: 'circle' | 'icon';
+    option: {
+        items: any[] | ((searchText?: string, isFormValue?: boolean) => Promise<any[]>) | ((searchText?: string[], isFormValue?: boolean) => Promise<any[]>);
+        valueField: string;
+        displayField: string;
+        selection?: 'AUTOCOMPLETE' | 'MULTIPLE' | 'MULTIPLEAUTOCOMPLETE' | 'AUTOCOMPLETE_EDITOR' | 'MULTIPLE_EDITOR' | 'MULTIPLEAUTOCOMPLETE_EDITOR';
+    };
+    editor?: {
+        change?: (rowData: T, selected?: any) => void;
+        add?: (rowData: T) => void;
+        edit?: (option: any, rowData: T) => void;
+        delete?: (option: any, rowData: T) => void;
+        hidden?: boolean | ((rowData: T) => boolean);
+        disabled?: boolean | ((rowData: T) => boolean);
+        required?: boolean | ((rowData: T) => boolean);
+    };
+}
+declare type SdTableColumnNormal<T> = Exclude<SdTableColumn<T>, SdTableColumnChildren<T>>;
+export interface SdTableColumnChildren<T = any> extends SdTableColumnBase<T> {
+    type: 'children';
+    children: SdTableColumnNormal<T>[];
+}
+export {};

package/table/src/lib/models/table-command.model.d.ts

@@ -0,0 +1,19 @@
+export declare type SdTableCommand<T = any> = SdTableCommandNormal<T> | SdTableCommandChildren<T>;
+export interface SdTableCommandNormal<T = any> {
+    icon?: string | ((rowData: T) => string);
+    fontSet?: 'material-icons' | 'material-icons-outlined' | 'material-icons-outlined' | 'material-icons-round' | 'material-icons-sharp';
+    title?: string | ((rowData: T) => string);
+    disabled?: boolean | ((rowData: T) => boolean);
+    hidden?: boolean | ((rowData: T) => boolean | Promise<boolean>);
+    click: (rowData: T) => void;
+    htmlTemplate?: (rowData: T) => string;
+}
+interface SdTableCommandChildren<T = any> {
+    icon?: string | ((rowData: T) => string);
+    fontSet?: 'material-icons' | 'material-icons-outlined' | 'material-icons-outlined' | 'material-icons-round' | 'material-icons-sharp';
+    title?: string | ((rowData: T) => string);
+    disabled?: boolean | ((rowData: T) => boolean);
+    hidden?: boolean | ((rowData: T) => boolean | Promise<boolean>);
+    children: SdTableCommandNormal<T>[];
+}
+export {};

package/table/src/lib/models/table-configuration.model.d.ts

@@ -0,0 +1,20 @@
+import { InjectionToken } from '@angular/core';
+import { SdFilterOperator } from './table-column.model';
+export interface ISdTableConfiguration {
+    filter?: {
+        quickFilter?: boolean;
+        operator?: {
+            defaultListString?: SdFilterOperator[];
+            defaultListNumber?: SdFilterOperator[];
+            defaultListDate?: SdFilterOperator[];
+            defaultListValues?: SdFilterOperator[];
+        };
+    };
+    paginate?: {
+        pageSize?: number;
+        pages?: number[];
+    };
+    translate?: boolean;
+}
+export declare const DEFAULT_TABLE_CONFIG: ISdTableConfiguration;
+export declare const TABLE_CONFIG: InjectionToken<ISdTableConfiguration>;

package/table/src/lib/models/table-item.model.d.ts

@@ -0,0 +1,25 @@
+export interface SdTableMetaSelector {
+    selectable?: boolean;
+    isSelected?: boolean;
+    actions?: string[];
+}
+export interface SdTableMetaExpand {
+    isExpanded?: boolean;
+    isExpanding?: boolean;
+    data?: any;
+}
+export interface SdTableMeta<T> {
+    id?: string;
+    selector?: SdTableMetaSelector;
+    expand?: SdTableMetaExpand;
+    group?: {
+        htmlTemplate?: string;
+        items?: SdTableItem<T>[];
+    };
+}
+export interface SdTableItem<T = any> {
+    meta: SdTableMeta<T>;
+    origin: T;
+    current: T;
+}
+export declare const MapToSdTableItem: <T = any>(item: T) => SdTableItem<T>;

package/table/src/lib/models/table-option-config.model.d.ts

@@ -0,0 +1,62 @@
+import { Observable } from 'rxjs';
+import { SdTableColumn } from './table-column.model';
+export interface SdTableConfigOption<T = any> {
+    key?: string;
+    visible?: boolean;
+    storage?: 'session' | 'server';
+    customColumn?: boolean;
+    args?: {
+        [key: string]: any;
+    };
+    systemColumn?: {
+        permission?: 'READ' | 'CREATE' | 'UPDATE' | 'DELETE';
+        args?: {
+            [key: string]: any;
+        };
+    };
+}
+export interface SdOriginColumn {
+    field: string;
+    title: string;
+    width?: string;
+    invisible?: boolean;
+}
+export interface SdColumnConfiguration {
+    origin: SdOriginColumn;
+    title?: string;
+    width?: string;
+    invisible?: boolean;
+    fixed?: boolean;
+    htmlTemplate?: string;
+}
+export interface SdGridConfiguration {
+    columns?: SdColumnConfiguration[];
+}
+export interface SdGridConfigurationResult {
+    column: {
+        [field: string]: {
+            title?: string;
+            width?: string;
+        };
+    };
+    fixedColumn: {
+        [field: string]: {
+            title?: string;
+            width?: string;
+        };
+    };
+    firstColumns: SdTableColumn[];
+    secondColumns: SdTableColumn[];
+    firstHeaders: string[];
+    secondHeaders: string[];
+    displayedColumns: string[];
+    displayedFooters: string[];
+    multipleHeader: boolean;
+}
+export interface SdGridConfigurationCache {
+    load: () => Promise<void>;
+    get: () => Promise<SdGridConfiguration>;
+    set: (configuration: SdGridConfiguration) => SdGridConfiguration;
+    remove: () => void;
+    observer: Observable<SdGridConfiguration>;
+}

package/table/src/lib/models/table-option-expand.model.d.ts

@@ -0,0 +1,6 @@
+export interface SdTableOptionExpand<T = any> {
+    disabled?: (rowData: T) => boolean;
+    onExpand?: (rowData: T) => Promise<any> | any;
+    multiple?: boolean;
+    always?: boolean;
+}

package/table/src/lib/models/table-option-export.model.d.ts

@@ -0,0 +1,31 @@
+import { SdTableFilterRequest } from '../services/table-filter/table-filter.model';
+export interface SdTableOptionExport<T = any> {
+    key?: string;
+    visible?: 'ALL' | 'EXCEL' | 'CSV';
+    enableUpload?: boolean;
+    fileName?: string;
+    max?: number;
+    maxItemsPerRequest?: number;
+    batch?: number;
+    items?: (filterRequest: SdTableFilterRequest) => T[] | Promise<T[]> | Promise<{
+        items: any[];
+        total: number;
+    }>;
+    mapping?: (items: T[], fileName?: string) => T[] | Promise<T[]>;
+    columns?: SdTableOptionExportColumn<T>[];
+    sheets?: {
+        name: string;
+        items: any[] | ((items?: any[]) => any[] | Promise<any[]>);
+        fields: string[];
+    }[];
+}
+export interface SdTableOptionExportColumn<T = any> {
+    field: string;
+    title: string;
+    description?: string;
+    width?: string;
+    transform?: (value: any, rowData: T) => string;
+    export?: {
+        disabled: boolean;
+    };
+}

package/table/src/lib/models/table-option-group.model.d.ts

@@ -0,0 +1,4 @@
+export interface SdTableOptionGroup<T = any> {
+    fields: string[];
+    htmlTemplate: (rowDatas: T[]) => string;
+}

package/table/src/lib/models/table-option-paginate.model.d.ts

@@ -0,0 +1,6 @@
+export interface SdTableOptionPaginate {
+    pageSize?: number;
+    pages?: number[];
+    showFirstLastButtons?: boolean;
+    hidden?: boolean;
+}

package/table/src/lib/models/table-option-reload.model.d.ts

@@ -0,0 +1,5 @@
+import { SdTableItem } from "./table-item.model";
+export interface SdTableOptionReload<T = any> {
+    visible?: boolean;
+    onReload?: (items: SdTableItem<T>[]) => Promise<void> | void;
+}

package/table/src/lib/models/table-option-selector.model.d.ts

@@ -0,0 +1,32 @@
+export interface SdTableOptionSelector<T = any> {
+    visible?: boolean;
+    single?: boolean;
+    actions?: SdTableAction<T>[];
+    message?: string | ((selectedItems?: T[]) => string);
+    onSelect?: (rowData?: T, selectedItems?: T[]) => void;
+    onSelectAll?: (selectedItems: T[]) => void;
+    disabled?: (rowData?: T, selectedItems?: T[]) => boolean;
+}
+export declare type SdTableAction<T = any> = SdTableActionNormal<T> | SdTableActionChildren<T>;
+export interface SdTableActionNormal<T = any> {
+    icon?: string | ((rowData: T) => string);
+    fontSet?: 'material-icons' | 'material-icons-outlined' | 'material-icons-outlined' | 'material-icons-round' | 'material-icons-sharp';
+    tooltip?: string;
+    title?: string;
+    color?: 'primary' | 'accent' | 'warn' | 'info' | 'success' | 'warning' | 'danger' | 'secondary';
+    type?: 'fill' | 'light' | 'outline' | 'link';
+    hidden?: boolean | ((rowData?: T) => boolean);
+    isGrouped?: boolean;
+    click: (selectedItems?: T[]) => void;
+}
+interface SdTableActionChildren<T = any> {
+    icon?: string | ((rowData: T) => string);
+    fontSet?: 'material-icons' | 'material-icons-outlined' | 'material-icons-outlined' | 'material-icons-round' | 'material-icons-sharp';
+    tooltip?: string;
+    title?: string;
+    color?: 'primary' | 'accent' | 'warn' | 'info' | 'success' | 'warning' | 'danger' | 'secondary';
+    type?: 'fill' | 'light' | 'outline' | 'link';
+    isGrouped?: boolean;
+    children: SdTableActionNormal<T>[];
+}
+export {};

package/table/src/lib/models/table-option-sort.model.d.ts

@@ -0,0 +1,3 @@
+export interface SdTableOptionSort {
+    enable?: boolean;
+}

package/table/src/lib/models/table-option-style.model.d.ts

@@ -0,0 +1,6 @@
+export interface SdTableOptionStyle<T = any> {
+    shadow?: boolean;
+    maxHeight?: string;
+    minHeight?: string;
+    rowCss?: (rowData: T) => Record<string, string>;
+}

package/table/src/lib/models/table-option.model.d.ts

@@ -0,0 +1,44 @@
+import { SdTableColumn } from './table-column.model';
+import { SdTableCommand } from './table-command.model';
+import { SdTableFilterRequest, SdTableOptionFilter } from '../services/table-filter/table-filter.model';
+import { SdTableOptionExport } from './table-option-export.model';
+import { SdTableOptionReload } from './table-option-reload.model';
+import { SdTableOptionExpand } from './table-option-expand.model';
+import { SdTableOptionSelector } from './table-option-selector.model';
+import { SdTableOptionStyle } from './table-option-style.model';
+import { SdTableOptionGroup } from './table-option-group.model';
+import { SdTableOptionSort } from './table-option-sort.model';
+import { SdTableOptionPaginate } from './table-option-paginate.model';
+import { SdTableConfigOption } from './table-option-config.model';
+export declare type SdTableOption<T = any> = SdTableLocalOption<T> | SdTableServerOption<T>;
+interface SdTableBaseOption<T = any> {
+    key?: string;
+    config?: SdTableConfigOption<T>;
+    selector?: SdTableOptionSelector<T>;
+    expand?: SdTableOptionExpand<T>;
+    sort?: SdTableOptionSort;
+    paginate?: SdTableOptionPaginate;
+    reload?: SdTableOptionReload<T>;
+    export?: SdTableOptionExport<T>;
+    group?: SdTableOptionGroup<T>;
+    filter?: SdTableOptionFilter;
+    commands?: SdTableCommand<T>[];
+    columns: SdTableColumn<T>[];
+    style?: SdTableOptionStyle<T>;
+    displayOnEmpty?: boolean | ((rowData: T, column?: SdTableColumn<T>) => string) | {
+        display?: boolean | ((rowData: T, column?: SdTableColumn<T>) => string);
+        emptyValues?: any[];
+    };
+}
+interface SdTableLocalOption<T = any> extends SdTableBaseOption<T> {
+    type: 'local';
+    items: () => T[] | Promise<T[]>;
+}
+interface SdTableServerOption<T = any> extends SdTableBaseOption<T> {
+    type: 'server';
+    items: (filterRequest: SdTableFilterRequest) => Promise<{
+        items: T[];
+        total: number;
+    }>;
+}
+export {};

package/table/src/lib/pipes/cell-view.pipe.d.ts

@@ -0,0 +1,15 @@
+import { PipeTransform } from '@angular/core';
+import { SdUtilityService } from '@sd-angular/core/utility';
+import { DeviceDetectorService } from 'ngx-device-detector';
+import { SdCellView } from '../models/grid-cell.model';
+import { SdTableColumn } from '../models/table-column.model';
+import { SdTableOption } from '../models/table-option.model';
+import { SdColumnValuesPipe } from './column-values.pipe';
+import { SdTableItem } from '../models/table-item.model';
+export declare class SdCellViewPipe implements PipeTransform {
+    #private;
+    private utilityService;
+    private columnValuesPipe;
+    constructor(deviceService: DeviceDetectorService, utilityService: SdUtilityService, columnValuesPipe: SdColumnValuesPipe);
+    transform(value: any, tableItem: SdTableItem, column: SdTableColumn, gridOption: SdTableOption): Promise<SdCellView>;
+}

package/table/src/lib/pipes/column-badge.pipe.d.ts

@@ -0,0 +1,11 @@
+import { PipeTransform } from '@angular/core';
+import { SdBadgeColor } from '@sd-angular/core/badge';
+import { SdTableColumn } from '../models/table-column.model';
+export declare class SdColumnBadgePipe implements PipeTransform {
+    constructor();
+    transform(value: any, rowData: any, column: SdTableColumn): {
+        type: 'round' | 'circle' | 'icon';
+        color: SdBadgeColor;
+        icon: string;
+    };
+}

package/table/src/lib/pipes/column-children-filter.pipe.d.ts

@@ -0,0 +1,8 @@
+import { PipeTransform } from '@angular/core';
+import { DeviceDetectorService } from 'ngx-device-detector';
+import { SdTableColumn } from '../models/table-column.model';
+export declare class SdColumnChildrenFilterPipe implements PipeTransform {
+    #private;
+    constructor(deviceService: DeviceDetectorService);
+    transform(columns: SdTableColumn[], item: any): SdTableColumn[];
+}

package/table/src/lib/pipes/column-html-template.pipe.d.ts

@@ -0,0 +1,8 @@
+import { PipeTransform } from '@angular/core';
+import { DeviceDetectorService } from 'ngx-device-detector';
+import { SdTableColumn } from '../models/table-column.model';
+export declare class SdColumnHtmlTemplatePipe implements PipeTransform {
+    private isMobileOrTablet;
+    constructor(deviceService: DeviceDetectorService);
+    transform(value: any, rowData: any, column: SdTableColumn): string;
+}

package/table/src/lib/pipes/column-tooltip.pipe.d.ts

@@ -0,0 +1,6 @@
+import { PipeTransform } from '@angular/core';
+import { SdTableColumn } from '../models/table-column.model';
+export declare class SdColumnTooltipPipe implements PipeTransform {
+    constructor();
+    transform(value: any, rowData: any, column: SdTableColumn): string;
+}

package/table/src/lib/pipes/column-transform.pipe.d.ts

@@ -0,0 +1,8 @@
+import { PipeTransform } from '@angular/core';
+import { SdTableColumn } from '../models/table-column.model';
+import { SdColumnValuesPipe } from './column-values.pipe';
+export declare class SdColumnTransformPipe implements PipeTransform {
+    private columnValuesPipe;
+    constructor(columnValuesPipe: SdColumnValuesPipe);
+    transform(value: any, rowData: any, column: SdTableColumn, key?: string): Promise<string>;
+}

package/table/src/lib/pipes/column-values.pipe.d.ts

@@ -0,0 +1,6 @@
+import { PipeTransform } from '@angular/core';
+import { SdTableColumn } from '../models/table-column.model';
+export declare class SdColumnValuesPipe implements PipeTransform {
+    #private;
+    transform: (value: any, column: SdTableColumn) => Promise<string>;
+}

package/table/src/lib/pipes/command-disable.pipe.d.ts

@@ -0,0 +1,5 @@
+import { PipeTransform } from '@angular/core';
+import { SdTableCommand } from '../models/table-command.model';
+export declare class SdCommandDisablePipe implements PipeTransform {
+    transform(item: any, command: SdTableCommand): boolean;
+}

package/table/src/lib/pipes/command-filter.pipe.d.ts

@@ -0,0 +1,6 @@
+import { PipeTransform } from '@angular/core';
+import { SdTableCommand } from '../models/table-command.model';
+import { SdTableItem } from '../models/table-item.model';
+export declare class SdCommandFilterPipe implements PipeTransform {
+    transform(item: SdTableItem, commands: SdTableCommand[]): Promise<SdTableCommand[]>;
+}

package/table/src/lib/pipes/command-icon.pipe.d.ts

@@ -0,0 +1,5 @@
+import { PipeTransform } from '@angular/core';
+import { SdTableCommand } from '../models/table-command.model';
+export declare class SdCommandIconPipe implements PipeTransform {
+    transform(command: SdTableCommand, item: any): string;
+}

package/table/src/lib/pipes/command-title.pipe.d.ts

@@ -0,0 +1,5 @@
+import { PipeTransform } from '@angular/core';
+import { SdTableCommand } from '../models/table-command.model';
+export declare class SdCommandTitlePipe implements PipeTransform {
+    transform(command: SdTableCommand, item: any): string;
+}