@inobeta/ui 18.0.1-build.1722007687

package/src/app/inobeta-ui/ui/kai-table/sort-header.d.ts

@@ -0,0 +1,20 @@
+import { MatSort, MatSortHeader } from "@angular/material/sort";
+import * as i0 from "@angular/core";
+/**
+ * Directive to use in combination with `mat-sort-header`
+ *
+ * Since `mat-sort-header` only looks up the `MatSort` instance coming directly
+ * from its parent (usually `mat-table`), it is necessary to substitute it with
+ * the correct `MatSort` attached to the `dataSource`, as well reinitialize
+ * the state changes to properly render the current state of the header.
+ *
+ * This solution is far from optimal and has a high risk of breaking with
+ * a different release of Angular Material
+ */
+export declare class IbSortHeader {
+    matSortHeader: MatSortHeader;
+    set matSort(matSort: MatSort);
+    constructor(matSortHeader: MatSortHeader);
+    static ɵfac: i0.ɵɵFactoryDeclaration<IbSortHeader, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IbSortHeader, "[ib-sort-header-for], [ibSortHeaderFor]", never, { "matSort": { "alias": "ibSortHeaderFor"; "required": false; }; }, {}, never, never, true, never>;
+}

package/src/app/inobeta-ui/ui/kai-table/store/const.d.ts

@@ -0,0 +1 @@
+export declare const kaiTableFeatureKey = "ibKaiTable";

package/src/app/inobeta-ui/ui/kai-table/store/index.d.ts

@@ -0,0 +1,8 @@
+import { ActionReducerMap } from '@ngrx/store';
+import { IUrlStateState } from './url-state/interfaces';
+import { UrlStateEffects } from "./url-state/effects";
+export interface IKaiTableStore {
+    urlState: IUrlStateState;
+}
+export declare const kaiTableReducers: ActionReducerMap<IKaiTableStore>;
+export declare const kaiTableEffects: (typeof UrlStateEffects)[];

package/src/app/inobeta-ui/ui/kai-table/store/url-state/actions.d.ts

@@ -0,0 +1,59 @@
+import { IbFilterSyntaxExtended } from "../../../kai-filter";
+import { Sort } from "@angular/material/sort";
+import { IbKaiTableParams } from "./interfaces";
+export declare const urlStateActions: {
+    setFilters: import("@ngrx/store").ActionCreator<"[KaiTable/UrlState] Set Filters", (props: {
+        tableName: string;
+        params: IbFilterSyntaxExtended;
+    }) => {
+        tableName: string;
+        params: IbFilterSyntaxExtended;
+    } & import("@ngrx/store").Action<"[KaiTable/UrlState] Set Filters">>;
+    setPaginator: import("@ngrx/store").ActionCreator<"[KaiTable/UrlState] Set Paginator", (props: {
+        tableName: string;
+        params: {
+            pageIndex: number;
+            pageSize: number;
+        };
+    }) => {
+        tableName: string;
+        params: {
+            pageIndex: number;
+            pageSize: number;
+        };
+    } & import("@ngrx/store").Action<"[KaiTable/UrlState] Set Paginator">>;
+    setAggregatedColumns: import("@ngrx/store").ActionCreator<"[KaiTable/UrlState] Set Aggregated Columns", (props: {
+        tableName: string;
+        params: Record<string, string>;
+    }) => {
+        tableName: string;
+        params: Record<string, string>;
+    } & import("@ngrx/store").Action<"[KaiTable/UrlState] Set Aggregated Columns">>;
+    setSort: import("@ngrx/store").ActionCreator<"[KaiTable/UrlState] Set Sort", (props: {
+        tableName: string;
+        params: Sort;
+    }) => {
+        tableName: string;
+        params: Sort;
+    } & import("@ngrx/store").Action<"[KaiTable/UrlState] Set Sort">>;
+    setRemoteDatasourceParams: import("@ngrx/store").ActionCreator<"[KaiTable/UrlState] Set Remote Datasource Params", (props: {
+        tableName: string;
+        filters: IbFilterSyntaxExtended;
+        sort: Sort;
+    }) => {
+        tableName: string;
+        filters: IbFilterSyntaxExtended;
+        sort: Sort;
+    } & import("@ngrx/store").Action<"[KaiTable/UrlState] Set Remote Datasource Params">>;
+    handleViewChange: import("@ngrx/store").ActionCreator<"[KaiTable/UrlState] Handle View Change", (props: {
+        tableName: string;
+        params: Omit<IbKaiTableParams, "tableName"> & {
+            view: string;
+        };
+    }) => {
+        tableName: string;
+        params: Omit<IbKaiTableParams, "tableName"> & {
+            view: string;
+        };
+    } & import("@ngrx/store").Action<"[KaiTable/UrlState] Handle View Change">>;
+};

package/src/app/inobeta-ui/ui/kai-table/store/url-state/effects.d.ts

@@ -0,0 +1,15 @@
+import { Actions } from "@ngrx/effects";
+import { IbTableUrlService } from "../../table-url.service";
+import * as i0 from "@angular/core";
+export declare class UrlStateEffects {
+    actions$: Actions<any>;
+    tableUrlService: IbTableUrlService;
+    setFilters$: any;
+    setPaginator$: any;
+    setAggregatedColumns$: any;
+    setSort$: any;
+    handleViewChange$: any;
+    setRemoteDatasourceParams$: any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UrlStateEffects, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UrlStateEffects>;
+}

package/src/app/inobeta-ui/ui/kai-table/store/url-state/interfaces.d.ts

@@ -0,0 +1,16 @@
+import { Sort } from "@angular/material/sort";
+import { IbFilterSyntaxExtended } from "../../../kai-filter";
+export type IUrlStateState = {
+    tables: IbKaiTableNamedParams[];
+};
+export type IbKaiTableParams = {
+    view: string;
+    pageSize: number;
+    page: number;
+    filters: IbFilterSyntaxExtended;
+    aggregatedColumns: Record<string, string>;
+    sort: Sort;
+};
+export type IbKaiTableNamedParams = Partial<IbKaiTableParams> & {
+    tableName: string;
+};

package/src/app/inobeta-ui/ui/kai-table/store/url-state/reducers.d.ts

@@ -0,0 +1,2 @@
+import { IUrlStateState } from "./interfaces";
+export declare const urlStateReducer: import("@ngrx/store").ActionReducer<IUrlStateState, import("@ngrx/store").Action<string>>;

package/src/app/inobeta-ui/ui/kai-table/store/url-state/selectors.d.ts

@@ -0,0 +1,3 @@
+import { IbTableQsParams } from "../../table-url.service";
+export declare const ibTableSelectLastQueryStringRaw: (tableName: string) => import("@ngrx/store").MemoizedSelector<object, IbTableQsParams, (s1: import("./interfaces").IbKaiTableNamedParams) => IbTableQsParams>;
+export declare const ibTableSelectLastQueryString: (tableName: string) => import("@ngrx/store").MemoizedSelector<object, string, (s1: IbTableQsParams) => string>;

package/src/app/inobeta-ui/ui/kai-table/table-data-source.d.ts

@@ -0,0 +1,164 @@
+import { DataSource } from "@angular/cdk/collections";
+import { MatPaginator } from "@angular/material/paginator";
+import { MatSort, Sort } from "@angular/material/sort";
+import { BehaviorSubject, Subject, Subscription } from "rxjs";
+import { IbFilter } from "../kai-filter/filter.component";
+import { IbFilterSyntax } from "../kai-filter/filter.types";
+import { IbTableViewGroup } from "../views/components/table-view-group/table-view-group.component";
+import { IbAggregateResult } from "./cells";
+import { IbColumn, IbSelectionColumn } from "./columns";
+import { Store } from "@ngrx/store";
+/**
+ * Data source that accepts a client-side data array and includes native support of filtering,
+ * sorting (using MatSort), and pagination (using MatPaginator).
+ *
+ * Allows for sort customization by overriding sortingDataAccessor, which defines how data
+ * properties are accessed. Also allows for filter customization by overriding filterPredicate,
+ * which defines how row data is converted to a string for filter matching.
+ */
+export declare class IbTableDataSource<T, P extends MatPaginator = MatPaginator> extends DataSource<T> {
+    /** Stream that emits when a new data array is set on the data source. */
+    protected readonly _data: BehaviorSubject<T[]>;
+    /** Stream emitting render data to the table (depends on ordered data changes). */
+    protected readonly _renderData: BehaviorSubject<T[]>;
+    /** Used to react to internal changes of the paginator that are made by the data source itself. */
+    private readonly _internalPageChanges;
+    /**
+     * Subscription to the changes that should trigger an update to the table's rendered rows, such
+     * as filtering, sorting, pagination, or base data changes.
+     */
+    _renderChangesSubscription: Subscription | null;
+    _viewChangesSubscription: Subscription | null;
+    tableName: string;
+    /**
+     * The filtered set of data that has been matched by the filter string, or all the data if there
+     * is no filter. Useful for knowing the set of data the table represents.
+     * For example, a 'selectAll()' function would likely want to select the set of filtered data
+     * shown to the user rather than all the data.
+     */
+    filteredData: T[];
+    /** Array of data that should be rendered by the table, where each object represents one row. */
+    get data(): T[];
+    set data(data: T[]);
+    /**
+     * Instance of the IbFilter component used by the table to filter its data. Filter changes
+     * emitted by the IbFilter will trigger an update to the table's rendered data.
+     */
+    get filter(): IbFilter | null;
+    set filter(f: IbFilter | null);
+    private _filter;
+    /**
+     * Instance of the MatSort directive used by the table to control its sorting. Sort changes
+     * emitted by the MatSort will trigger an update to the table's rendered data.
+     */
+    get sort(): MatSort | null;
+    set sort(sort: MatSort | null);
+    private _sort;
+    _sortState: Sort;
+    get sortState(): Sort;
+    set sortState(sort: Sort);
+    /**
+     * Instance of the paginator component used by the table to control what page of the data is
+     * displayed. Page changes emitted by the paginator will trigger an update to the
+     * table's rendered data.
+     *
+     * Note that the data source uses the paginator's properties to calculate which page of data
+     * should be displayed. If the paginator receives its properties as template inputs,
+     * e.g. `[pageLength]=100` or `[pageIndex]=1`, then be sure that the paginator's view has been
+     * initialized before assigning it to this data source.
+     */
+    get paginator(): P | null;
+    set paginator(paginator: P | null);
+    private _paginator;
+    get columns(): Record<string, IbColumn<unknown>>;
+    set columns(columns: IbColumn<unknown>[]);
+    private _columns;
+    set view(view: IbTableViewGroup | null);
+    get view(): IbTableViewGroup | null;
+    private _view;
+    /**
+     * Aggregated data by column name.
+     */
+    aggregatedData: Record<string, IbAggregateResult>;
+    /**
+     * Dictionary of columns to aggregate and the function (function id) to apply.
+     * Note: this structure is serialized within a view
+     */
+    aggregatedColumns: Record<string, string>;
+    aggregationFunctions: any;
+    protected store: Store<any>;
+    /**
+     * Used to trigger the aggregation of a column by the user.
+     *
+     * IbTableViewGroup listens to this stream to detect state changes
+     */
+    aggregate: Subject<{
+        columnName: string;
+        function: string;
+    }>;
+    /**
+     * Whether the table should display the aggregation footer.
+     * (this reeks...)
+     */
+    get shouldDisplayAggregationFooter(): boolean;
+    selectionColumn: IbSelectionColumn | null;
+    /**
+     * Gets a sorted copy of the data array based on the state of the MatSort. Called
+     * after changes are made to the filtered data or when sort changes are emitted from MatSort.
+     * By default, the function retrieves the active sort and its direction and compares data
+     * by retrieving data using the sortingDataAccessor.
+     * @param data The array of data that should be sorted.
+     * @param sort The connected MatSort that holds the current sort state.
+     */
+    sortData: (data: T[], sort: MatSort) => T[];
+    /**
+     * Checks if a data object matches the data source's filter.
+     * @param data Data object used to check against the filter.
+     * @param filter Filter that has been set on the data source.
+     * @returns Whether the filter matches against the data
+     */
+    filterPredicate: (data: T, filter: IbFilterSyntax) => boolean;
+    private applySearchBarFilter;
+    constructor(initialData?: T[]);
+    private _initializeFilters;
+    /**
+     * Subscribe to changes that should trigger an update to the table's rendered rows. When the
+     * changes occur, process the current state of the filter, sort, and pagination along with
+     * the provided base data and send it to the table for rendering.
+     */
+    _updateChangeSubscription(): void;
+    private _updateViewChangeSubscription;
+    private handleViewChange;
+    /**
+     * Returns a filtered data array where each row satisfies the filter.
+     * If no filter is set, returns the data array as provided.
+     */
+    _filterData(data: T[]): T[];
+    /**
+     * Returns a sorted copy of the data if MatSort has a sort applied, otherwise just returns the
+     * data array as provided. Uses the default data accessor for data lookup, unless a
+     * sortDataAccessor function is defined.
+     */
+    _orderData(data: T[]): T[];
+    /**
+     * Returns a paged slice of the provided data array according to the provided paginator's page
+     * index and length. If there is no paginator provided, returns the data array as provided.
+     */
+    _pageData(data: T[]): T[];
+    /**
+     * Updates the paginator to reflect the length of the filtered data, and makes sure that the page
+     * index does not exceed the paginator's last page. Values are changed in a resolved promise to
+     * guard against making property changes within a round of change detection.
+     */
+    _updatePaginator(filteredDataLength: number): void;
+    _aggregateData(data: T[]): T[];
+    _aggregatePaginatedData(data: T[]): T[];
+    /**
+     * Used by the MatTable. Called when it connects to the data source.
+     */
+    connect(): BehaviorSubject<T[]>;
+    /**
+     * Used by the MatTable. Called when it disconnects from the data source.
+     */
+    disconnect(): void;
+}

package/src/app/inobeta-ui/ui/kai-table/table-url.service.d.ts

@@ -0,0 +1,51 @@
+import { ActivatedRoute, Router } from '@angular/router';
+import { IbFilterSyntaxExtended } from '../kai-filter/filter.types';
+import { Sort } from '@angular/material/sort';
+import { IbKaiTableParams } from './store/url-state/interfaces';
+import * as i0 from "@angular/core";
+export declare class IbTableUrlService {
+    _emptyFilterSchema: Record<string, IbFilterSyntaxExtended>;
+    get emptyFilterSchema(): Record<string, IbFilterSyntaxExtended>;
+    set emptyFilterSchema(value: Record<string, IbFilterSyntaxExtended>);
+    router: Router;
+    activatedRoute: ActivatedRoute;
+    constructor();
+    getRawParams(tableName: string): IbTableQsParams;
+    getFilters(tableName: string): IbFilterSyntaxExtended;
+    setFilters(tableName: string, params: IbFilterSyntaxExtended): void;
+    getActiveView(tableName: string): string;
+    setPaginator(tableName: string, params: {
+        pageIndex: number;
+        pageSize: number;
+    }): void;
+    getPaginator(tableName: string): {
+        pageIndex: number;
+        pageSize: number;
+    };
+    setAggregatedColumns(tableName: string, params: Record<string, string>): void;
+    getAggregatedColumns(tableName: string): Record<string, string>;
+    setSort(tableName: string, params: Sort): void;
+    getSort(tableName: string): Sort;
+    handleViewChange(tableName: string, params: Omit<IbKaiTableParams, 'tableName'> & {
+        view: string;
+    }): void;
+    getViewState(tableName: string): {
+        view: string;
+        pageSize: number;
+        page: number;
+        filters: IbFilterSyntaxExtended;
+        aggregatedColumns: Record<string, string>;
+        sort: Sort;
+    };
+    setFilterAndSort(tableName: string, ibfilter: IbFilterSyntaxExtended, sort: Sort): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IbTableUrlService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IbTableUrlService>;
+}
+export type IbTableQsParams = {
+    ibpage: number;
+    ibpagesize: number;
+    ibfilter: IbFilterSyntaxExtended;
+    ibaggregatedcolumns: Record<string, string>;
+    ibsort: Sort;
+    ibview: string;
+};

package/src/app/inobeta-ui/ui/kai-table/table.component.d.ts

@@ -0,0 +1,79 @@
+import { Portal } from "@angular/cdk/portal";
+import { OnDestroy, QueryList } from "@angular/core";
+import { MatPaginator } from "@angular/material/paginator";
+import { MatSort } from "@angular/material/sort";
+import { MatTable } from "@angular/material/table";
+import { IbTableDataExportAction } from "../data-export/table-data-export.component";
+import { IbFilter } from "../kai-filter";
+import { IbTableViewGroup } from "../views";
+import { IbColumn } from "./columns/column";
+import { IbSelectionColumn } from "./columns/selection-column";
+import { IbKaiRowGroupDirective } from "./rowgroup";
+import { IbTableDataSource } from "./table-data-source";
+import { IbKaiTableState, IbTableDef } from "./table.types";
+import { IbTableUrlService } from "./table-url.service";
+import * as i0 from "@angular/core";
+export declare class IbTable implements OnDestroy {
+    private _destroyed;
+    columns: QueryList<IbColumn<any>>;
+    selectionColumn: IbSelectionColumn;
+    rowGroup: IbKaiRowGroupDirective;
+    filter: IbFilter;
+    view: IbTableViewGroup;
+    exportAction: IbTableDataExportAction;
+    matTable: MatTable<any>;
+    sort: MatSort;
+    paginator: MatPaginator;
+    expandedElement: any;
+    actionPortals: Portal<any>[];
+    state: IbKaiTableState;
+    set data(data: any[]);
+    dataSource: IbTableDataSource<unknown>;
+    tableName: string;
+    tableUrl: IbTableUrlService;
+    private store;
+    /**
+     * Configuration for the table and its inner components. Currently supports only
+     * `paginator` and `sort` parameters.
+     *
+     * If left empty, the following default is used
+     *
+     * ```
+     * {
+     *   paginator : {
+     *     pageSizeOptions: [5, 10, 25, 100],
+     *     showFirstLastButtons: true,
+     *     pageSize: 10,
+     *     hide: false,
+     *   }
+     * }
+     *
+     * NB: querystring override these values
+     * ```
+     */
+    set tableDef(value: Partial<IbTableDef>);
+    get tableDef(): Partial<IbTableDef>;
+    private _tableDef;
+    /**
+     * Columns to be displayed.
+     *
+     * The order of the columns present in this array is rendered
+     * as is in a language written from left-to-right. It is reversed
+     * in a language written from right-to-left.
+     */
+    set displayedColumns(columns: string[]);
+    get displayedColumns(): string[];
+    private _displayedColumns;
+    stripedRows: boolean;
+    isRemote: boolean;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    setPaginatorState(params: any): void;
+    private setupViewGroup;
+    private setupExportAction;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IbTable, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IbTable, "ib-kai-table", never, { "state": { "alias": "state"; "required": false; }; "data": { "alias": "data"; "required": false; }; "dataSource": { "alias": "dataSource"; "required": false; }; "tableName": { "alias": "tableName"; "required": false; }; "tableDef": { "alias": "tableDef"; "required": false; }; "displayedColumns": { "alias": "displayedColumns"; "required": false; }; "stripedRows": { "alias": "stripedRows"; "required": false; }; }, {}, ["selectionColumn", "rowGroup", "filter", "view", "exportAction", "columns"], ["ib-table-view-group", "ib-table-action-group, [ib-table-action-group]", "ib-filter", "ib-selection-column", "*"], false, never>;
+    static ngAcceptInputType_stripedRows: unknown;
+}

package/src/app/inobeta-ui/ui/kai-table/table.module.d.ts

@@ -0,0 +1,30 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./table.component";
+import * as i2 from "./rowgroup";
+import * as i3 from "./cells";
+import * as i4 from "./columns/selection-column";
+import * as i5 from "./columns/text-column";
+import * as i6 from "./columns/number-column";
+import * as i7 from "./columns/date-column";
+import * as i8 from "./columns/action-column";
+import * as i9 from "@angular/common";
+import * as i10 from "@angular/cdk/portal";
+import * as i11 from "./columns/column";
+import * as i12 from "./sort-header";
+import * as i13 from "@angular/material/table";
+import * as i14 from "@angular/material/sort";
+import * as i15 from "@angular/material/menu";
+import * as i16 from "@angular/material/icon";
+import * as i17 from "@angular/material/button";
+import * as i18 from "@angular/material/tooltip";
+import * as i19 from "@angular/material/checkbox";
+import * as i20 from "@angular/material/paginator";
+import * as i21 from "@angular/material/progress-bar";
+import * as i22 from "@ngx-translate/core";
+import * as i23 from "@ngrx/store";
+import * as i24 from "@ngrx/effects";
+export declare class IbKaiTableModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IbKaiTableModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IbKaiTableModule, [typeof i1.IbTable, typeof i2.IbKaiRowGroupDirective, typeof i3.IbCellDef, typeof i4.IbSelectionColumn, typeof i5.IbTextColumn, typeof i6.IbNumberColumn, typeof i7.IbDateColumn, typeof i8.IbActionColumn, typeof i3.IbAggregateCell], [typeof i9.CommonModule, typeof i10.PortalModule, typeof i11.IbColumn, typeof i12.IbSortHeader, typeof i13.MatTableModule, typeof i14.MatSortModule, typeof i15.MatMenuModule, typeof i16.MatIconModule, typeof i17.MatButtonModule, typeof i18.MatTooltipModule, typeof i19.MatCheckboxModule, typeof i20.MatPaginatorModule, typeof i21.MatProgressBarModule, typeof i22.TranslateModule, typeof i23.StoreFeatureModule, typeof i24.EffectsFeatureModule], [typeof i1.IbTable, typeof i2.IbKaiRowGroupDirective, typeof i3.IbCellDef, typeof i4.IbSelectionColumn, typeof i11.IbColumn, typeof i5.IbTextColumn, typeof i6.IbNumberColumn, typeof i7.IbDateColumn, typeof i12.IbSortHeader, typeof i8.IbActionColumn, typeof i3.IbAggregateCell]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IbKaiTableModule>;
+}

package/src/app/inobeta-ui/ui/kai-table/table.types.d.ts

@@ -0,0 +1,21 @@
+import { MatPaginatorDefaultOptions } from "@angular/material/paginator";
+import { Sort } from "@angular/material/sort";
+export interface IbPaginatorOptions extends MatPaginatorDefaultOptions {
+    hide?: boolean;
+    pageIndex?: number;
+}
+export interface IbTableDef {
+    paginator?: IbPaginatorOptions;
+    initialSort?: Sort;
+}
+export interface IbTableRowEvent<T = any> {
+    tableName: string;
+    type: string;
+    row: T;
+}
+export interface IbTableRowSelectionChange<T = any> {
+    tableName: string;
+    selection: boolean;
+    row: T;
+}
+export type IbKaiTableState = "idle" | "loading" | "no_data" | "http_error";

package/src/app/inobeta-ui/ui/kai-table/tokens.d.ts

@@ -0,0 +1,22 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * Used to provide a table to some of the sub-components without causing a circular dependency.
+ */
+export declare const IB_TABLE: InjectionToken<any>;
+/** Used to provide a column to the aggregate cell of a given column. */
+export declare const IB_COLUMN: InjectionToken<any>;
+/** Configurable options for `IbColumn`. */
+export interface IbColumnOptions<T> {
+    /**
+     * Default function that provides the header text based on the column name if a header
+     * text is not provided.
+     */
+    defaultHeaderTextTransform?: (name: string) => string;
+    /** Default data accessor to use if one is not provided. */
+    defaultDataAccessor?: (data: T, name: string) => string;
+}
+/** Injection token that can be used to specify the text column options. */
+export declare const IB_COLUMN_OPTIONS: InjectionToken<IbColumnOptions<any>>;
+/** Used to provide a list of aggregate funciton to a number column */
+export declare const IB_AGGREGATE: InjectionToken<any>;
+export declare const IB_AGGREGATE_TYPE: InjectionToken<any>;

package/src/app/inobeta-ui/ui/kai-table/translations.d.ts

@@ -0,0 +1,40 @@
+export declare const ibKaiTableTranslations: {
+    it: {
+        aggregate: {
+            sum: {
+                name: string;
+                label: string;
+                help: string;
+            };
+            avg: {
+                name: string;
+                label: string;
+                help: string;
+            };
+            help: string;
+            apply: string;
+            currentPage: string;
+            total: string;
+        };
+        ibTable: {
+            export: string;
+            paginator: {
+                itemsPerPageLabel: string;
+                nextPageLabel: string;
+                previousPageLabel: string;
+                firstPageLabel: string;
+                lastPageLabel: string;
+                rangeLabel1: string;
+                rangeLabel2: string;
+            };
+            exportData: {
+                title: string;
+                export: string;
+                format: string;
+                all: string;
+                currentPage: string;
+                selectedRows: string;
+            };
+        };
+    };
+};