@one-grid-core/angular 0.1.0-beta.5

package/lib/core/directives/one-cell-text-expand.directive.d.ts

@@ -0,0 +1,21 @@
+import { AfterViewChecked, AfterViewInit, ElementRef, OnDestroy, Renderer2 } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class OneCellTextExpandDirective implements AfterViewInit, AfterViewChecked, OnDestroy {
+    private cell;
+    private renderer;
+    private overflowing;
+    private timer;
+    private lastText;
+    constructor(cell: ElementRef<HTMLElement>, renderer: Renderer2);
+    ngAfterViewInit(): void;
+    ngAfterViewChecked(): void;
+    ngOnDestroy(): void;
+    private checkOverflow;
+    onResize(): void;
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    private expand;
+    private collapse;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OneCellTextExpandDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OneCellTextExpandDirective, "[oneCellTextExpand]", never, {}, {}, never, never, false, never>;
+}

package/lib/core/instants/one-grid-api.class.d.ts

@@ -0,0 +1,161 @@
+import { OneCellRendererComponent } from '../models/one-tree-data.model';
+import { OneColumnDef } from '../models/one-column-def-types.model';
+import { OneRowNode } from "./one-row-node.class";
+import { OneGridType, OneSortModel } from '../models/one-grid-types.model';
+import { OneGridEventService } from '../services/one-grid-event.service';
+import { OneGridSelectionService } from '../services/one-grid-selection.service';
+import { OneValidationResult } from '../models/one-validation.model';
+import { OneFilterModel } from "../models/one-filter.model";
+import { OneGridExpansionService } from '../services/one-grid-expansion.service';
+import { OneDetailCellRendererParams, OneGetDetailRowDataParams } from "../models/one-master-detail.model";
+import { OneGridRowService } from "../services/one-grid-row.service";
+import { OneGridCellService } from '../services/one-grid-cell.service';
+import { Type } from "@angular/core";
+import { ColumnChangedEvent, RowSelectionMode } from "../models/one-event-types.model";
+import { OneGroupColumnDef } from "../models/one-column-def-types.model";
+import { OgColumnService } from "../services/og-column.service";
+import * as i0 from "@angular/core";
+export declare class OneGridApi<T = any> {
+    private columnService;
+    private rowService;
+    private cellService;
+    private eventService;
+    private selectionService;
+    private expansionService;
+    id: string;
+    context: any;
+    rowSelection: RowSelectionMode;
+    apiType: OneGridType;
+    rowNodes: OneRowNode<T>[];
+    sortModel: OneSortModel<T>[];
+    private rowHeight;
+    private headerRowHeight;
+    private _currentIndex;
+    private _quickFilterValue;
+    private _activeFilters;
+    private _visibleRowNodes;
+    private _originalRowNodes;
+    private _nodeCleanupMap;
+    private _destroyed;
+    private treeData;
+    private treeDataChildrenField;
+    private groupDefaultExpanded;
+    private masterDetail;
+    private detailCellRendererParams;
+    private detailRendererComponent?;
+    getDetailRowData: (params: OneGetDetailRowDataParams) => void;
+    constructor(columnService: OgColumnService, rowService: OneGridRowService, cellService: OneGridCellService, eventService: OneGridEventService, selectionService: OneGridSelectionService, expansionService: OneGridExpansionService);
+    init(gridApiType: OneGridType, rowSelection: RowSelectionMode, columnDefs: OneColumnDef<T>[], defaultColumnDef: OneColumnDef<T>, context: any, masterDetail: boolean, detailCellRendererParams: OneDetailCellRendererParams, detailRendererComponent: Type<OneCellRendererComponent>, treeData: boolean, groupColumnDefs: OneGroupColumnDef[]): void;
+    /**
+     * Create Row Node & Clear All State IDS
+     */
+    setRowData(rowData: T[]): void;
+    /**
+     * Create Row Nodes & Not Clear State IDS
+     */
+    updateRowData(rowData: T[]): void;
+    /**
+     * Recursive Build Row Nodes (Optimized)
+     */
+    private buildRowNodes;
+    /**
+     * Filter Feature
+     */
+    private applyFilters;
+    /**
+     * Update Row Nodes Display
+     */
+    private refreshVisibleNodes;
+    getVisibleRowNodes(): OneRowNode<T>[];
+    /**
+     * Sorting Model Feature
+     */
+    onSortChanged(sortModel: OneSortModel<T>[]): void;
+    private applySorting;
+    private compareValues;
+    /**
+     * Row Selection Feature (Optimized)
+     */
+    selectAll(): void;
+    /**
+     * Deselect all nodes (optimized)
+     */
+    deselectAll(): void;
+    toggleSelection(rowId: string, selected: boolean): void;
+    setSelectedById(rowId: string): void;
+    setSelectedByIds(rowIds: string[], selected?: boolean): void;
+    /**
+     * Get & Set Functions
+     */
+    getAllRowNodes(): OneRowNode<T>[];
+    getRowDataSelected(): T[];
+    getSelectedRowNodes(): OneRowNode<T>[];
+    /**
+     * Column filters
+     */
+    getFilterModel(): OneFilterModel[];
+    setFilterModel(model: OneFilterModel[]): void;
+    filterActive(field: string): boolean;
+    /**
+     * Quick filter
+     */
+    setQuickFilter(value: string): void;
+    /**
+     * Validation Feature
+     */
+    validateRow<T>(row: T, columns: OneColumnDef<T>[]): Record<string, string>;
+    /**
+     * Validate all rows and return both errors and a flag indicating if there are any errors
+     */
+    validateAllRows<T>(rowData: T[], columns: OneColumnDef<T>[]): OneValidationResult<T>;
+    /** Traverse all nodes */
+    forEachNode(callback: (node: OneRowNode<T>, index: number) => void): void;
+    /** Traverse only leaf nodes */
+    forEachLeafNode(callback: (node: OneRowNode<T>, index: number) => void): void;
+    getRowNodeById(rowId: string): OneRowNode<T>;
+    /**
+     * Expand/collapse a node
+     */
+    setTreeDataChildrenField(field: string): void;
+    setGroupDefaultExpanded(defaultExpanded: number): void;
+    toggleExpandAll(expanded: boolean): void;
+    setExpandedById(rowId: string, expanded: boolean): void;
+    setExpandedByIds(rowIds: string[], expanded: boolean): void;
+    getExpandedByIds(): string[];
+    /**
+     * Master Detail Feature
+     */
+    setDetailRowData(node: OneRowNode<T>, detailData: any[]): void;
+    setGetDetailRowData(getDetailRowData: (params: OneGetDetailRowDataParams) => void): void;
+    /**
+     * Columns State
+     */
+    getColumnState(): ColumnChangedEvent;
+    setColumnDefs(columnDefs: OneColumnDef<T>[]): void;
+    updateColumn(id: string, changes: Partial<OneColumnDef<T>>): void;
+    reorderColumnDefs(fromIndex: number, toIndex: number): void;
+    /**
+     * Update checkbox selection features
+     */
+    setNodeAndChildrenSelected(node: OneRowNode, selected: boolean): void;
+    updateNodeStates(node: OneRowNode): void;
+    updateCellState(node: OneRowNode, column: OneColumnDef): void;
+    updateCellStates(node: OneRowNode): void;
+    /**
+     * Handler that Reacts to Detail Changes
+     */
+    private subscribeToDetailChanges;
+    private registerNodeCleanup;
+    private cleanupNode;
+    private pruneRemovedNodes;
+    /**
+     * Resolve Detail Row Height
+     */
+    private _resolvedDetailRowHeight;
+    /**
+     * On Destroy
+     */
+    destroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OneGridApi<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OneGridApi<any>>;
+}

package/lib/core/instants/one-row-node.class.d.ts

@@ -0,0 +1,49 @@
+import { Type } from "@angular/core";
+import { OneCellOptions, OneCellStates } from "../models/one-column-def-types.model";
+import { OneRowNodeEventMap, OneRowNodeListener } from "../models/one-row.model";
+import { OneCellRendererComponent } from "../models/one-tree-data.model";
+export declare class OneRowNode<T = any, D = any> {
+    rowId: string;
+    rowIndex: number;
+    data: T;
+    level: number;
+    leaf: boolean;
+    leafGroup: boolean;
+    visible: boolean;
+    selected: boolean;
+    expandable: boolean;
+    expanded: boolean;
+    group: boolean;
+    submitted: boolean;
+    parent: OneRowNode<T> | null;
+    children: OneRowNode<T>[] | null;
+    editing: {
+        [field: string]: boolean;
+    };
+    cellStates: OneCellStates;
+    cellOptions: OneCellOptions;
+    detailRowData: D[];
+    detailActive: boolean;
+    detailRowHeight: number;
+    detailRendererComponent?: Type<OneCellRendererComponent>;
+    private listeners;
+    constructor(rowId: string, data: T, rowIndex: number);
+    setDataValue(field: string, value: any): void;
+    setSelected(selected: boolean): void;
+    setRowIndex(index: number): void;
+    setCellStates(cellStates: OneCellStates): void;
+    isSelected(): boolean;
+    isExpanded(): boolean;
+    /**
+     * Event System
+     */
+    on<K extends keyof OneRowNodeEventMap<T>>(event: K, listener: OneRowNodeListener<T, K>): () => void;
+    off<K extends keyof OneRowNodeEventMap<T>>(event: K, listener: OneRowNodeListener<T, K>): void;
+    emit<K extends keyof OneRowNodeEventMap<T>>(event: K, payload: OneRowNodeEventMap<T>[K]): void;
+    /**
+      * Mutators that fire events
+      */
+    setDetailRowData(detailRowData: D[]): void;
+    setExpanded(expanded: boolean): void;
+    destroy(): void;
+}

package/lib/core/models/constants/one-pagination.constant.d.ts

@@ -0,0 +1 @@
+export declare const OnePageSizeOption: number[];

package/lib/core/models/one-column-def-types.model.d.ts

@@ -0,0 +1,139 @@
+import { Type } from "@angular/core";
+import type { OneGridApi } from "../instants/one-grid-api.class";
+import type { OneRowNode } from "../instants/one-row-node.class";
+import type { OneValidatorFn } from "./one-validation.model";
+import type { OneCellOptionMenu } from "./one-event-types.model";
+import type { OneCellRendererComponent } from "./one-tree-data.model";
+export interface OneValueGetterParams<T = any> {
+    data: T;
+    rowIndex?: number;
+    rowNode?: OneRowNode;
+    node?: OneRowNode;
+    api?: OneGridApi;
+    context?: any;
+}
+export interface OneCellState {
+    type: 'placeholder' | 'text' | 'html' | 'none';
+    value: any;
+}
+export interface OneCellStates {
+    [field: string]: OneCellState;
+}
+export interface OneCellOptions {
+    [field: string]: boolean;
+}
+export type OneCellStatus = 0 | 1;
+export type OneCellButtonIconType = 'add' | 'option' | 'language';
+export type OneCellInputType = 'text' | 'number' | 'email' | 'date' | 'time' | 'datetime' | 'datetime-local';
+export interface OneCellRendererParams<T = any> {
+    value?: any;
+    rowIndex?: number;
+    data?: T;
+    field?: string;
+    columnDef?: OneColumnDef<T>;
+    api?: OneGridApi<T>;
+    node?: OneRowNode<T>;
+    context?: any;
+    locationStatus?: number;
+    status?: number;
+    gridStatus?: number;
+    inputType?: OneCellInputType;
+    placeholder?: string;
+    required?: boolean;
+    detailActiveButtonStatus?: OneCellStatus;
+    detailActiveExcludeLevels?: number[];
+    gotoDetailButtonStatus?: OneCellStatus;
+    gotoDetailExcludeLevels?: number[];
+    addNewButtonStatus?: OneCellStatus;
+    addNewExcludeLevels?: number[];
+    viewButtonStatus?: OneCellStatus;
+    locationButtonStatus?: OneCellStatus;
+    documentButtonStatus?: OneCellStatus;
+    copyButtonStatus?: OneCellStatus;
+    deleteButtonStatus?: OneCellStatus;
+    gotoListButtonStatus?: OneCellStatus;
+    optionButtonStatus?: OneCellStatus;
+    languageButtonStatus?: OneCellStatus;
+    editButtonStatus?: OneCellStatus;
+    printButtonStatus?: OneCellStatus;
+    historyButtonStatus?: OneCellStatus;
+    cellOptionButtonStatus?: OneCellStatus;
+    validateSelectedRowOnly?: boolean;
+    forceMarkedAsCellValue?: boolean;
+}
+/**
+ * Header Group Column Def
+ */
+export interface OneGroupColumnDef {
+    id: string;
+    headerName: string;
+    colSpan?: number;
+    width?: number;
+    groupStyle?: {
+        [key: string]: string;
+    } | ((row: any) => {
+        [key: string]: string;
+    });
+    groupClass?: string | string[] | ((row: any) => string | string[]);
+    _resolvedGroupClass?: string | string[];
+    _resolvedGroupStyle?: Record<string, string>;
+}
+/**
+ * Cell Column Def
+ */
+export interface OneColumnDef<T = any> {
+    id?: string;
+    groupId?: string;
+    field?: keyof T & string;
+    masterGroupField?: boolean;
+    autoGroupField?: boolean;
+    editableLevels?: number[];
+    rowActionLevels?: number[];
+    headerName?: string;
+    checkboxSelection?: boolean;
+    headerCheckboxSelection?: boolean;
+    flex?: number;
+    width?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    validationRules?: OneValidatorFn[];
+    headerStyle?: {
+        [key: string]: string;
+    } | ((params: OneCellRendererParams<T>) => {
+        [key: string]: string;
+    });
+    cellStyle?: {
+        [key: string]: string;
+    } | ((params: OneCellRendererParams<T>) => {
+        [key: string]: string;
+    });
+    headerClass?: string | string[] | ((params: OneCellRendererParams<T>) => string | string[]);
+    cellClass?: string | string[] | ((params: OneCellRendererParams<T>) => string | string[]);
+    _resolvedHeaderClass?: string | string[];
+    _resolvedCellClass?: string | string[];
+    _resolvedHeaderStyle?: Record<string, string>;
+    _resolvedCellStyle?: Record<string, string>;
+    cellRendererParams?: OneCellRendererParams<T>;
+    cellOptionMenu?: OneCellOptionMenu[];
+    alignContent?: 'left' | 'center' | 'right';
+    pinned?: 'left' | 'right';
+    sortable?: boolean | ((params: OneCellRendererParams<T>) => boolean);
+    resizable?: boolean | ((params: OneCellRendererParams<T>) => boolean);
+    filterable?: boolean | ((params: OneCellRendererParams<T>) => boolean);
+    editable?: boolean | ((params: OneCellRendererParams<T>) => boolean);
+    updatable?: boolean | ((params: OneCellRendererParams<T>) => boolean);
+    disable?: boolean | ((params: OneCellRendererParams<T>) => boolean);
+    dragable?: boolean | ((params: OneCellRendererParams<T>) => boolean);
+    hideActionButton?: boolean | ((params: OneCellRendererParams<T>) => boolean);
+    suppressHeaderMenuButton?: boolean | ((params: OneCellRendererParams<T>) => boolean);
+    cellRendererComponent?: Type<OneCellRendererComponent>;
+    cellRenderer?: (params: OneCellRendererParams<T>) => string;
+    valueGetter?: (params: OneValueGetterParams<T>) => any;
+    valueSetter?: (value: any, rowIndex: number) => void;
+    valueFormatter?: (params: OneCellRendererParams<T>) => string;
+}
+export type OneCellValidationType = 'disabled' | 'integer' | 'number' | 'code' | 'title' | 'phone' | 'email' | 'description' | 'regex' | 'none';
+export interface CellSelection {
+    rowId: string;
+    field: string;
+}

package/lib/core/models/one-event-types.model.d.ts

@@ -0,0 +1,78 @@
+import type { OneColumnDef, OneGroupColumnDef } from "./one-column-def-types.model";
+import type { OneGridApi } from "../instants/one-grid-api.class";
+import type { OneRowNode } from "../instants/one-row-node.class";
+export interface RowSelectedEvent {
+    rowId: string;
+    selected: boolean;
+}
+export interface CellClickedEvent {
+    rowId: string;
+    columnId: string;
+    value: any;
+}
+export interface ColumnMovedEvent {
+    columnId: string;
+    toIndex: number;
+}
+export interface RowDataChangedEvent<T> {
+    nodes: OneRowNode<T>[];
+}
+export interface OneCellOptionMenu {
+    text: string;
+    value: any;
+}
+export interface SelectionChangedEvent<T = any> {
+    selectedRowIds?: string[];
+    rowIndex?: number;
+    data?: T;
+    allNodesSelected?: boolean;
+    allNodesNotSelected?: boolean;
+    selected?: boolean;
+    node: OneRowNode<T>;
+}
+export interface ExpansionChangedEvent<T = any> {
+    rowIndex?: number;
+    data: T;
+    node: OneRowNode<T>;
+    api?: OneGridApi<T>;
+}
+export interface StatesChangedEvent<T = any> {
+    rowIndex?: number;
+    data: T;
+    node: OneRowNode<T>;
+}
+export interface CellOptionMenuSelectedEvent<T = any> {
+    option: OneCellOptionMenu;
+    node: OneRowNode<T>;
+    column: OneColumnDef<T>;
+}
+export interface SortChangedEvent<T = any> {
+    nodes: OneRowNode<T>[];
+}
+export interface ColumnResizedEvent {
+    columnId: string;
+    newWidth: number;
+}
+export interface ColumnChangedEvent {
+    columns?: OneColumnDef[];
+    groups?: OneGroupColumnDef[];
+}
+export interface CellStateChangedEvent<T> {
+    data: T;
+    node: OneRowNode<T>;
+    column: OneColumnDef<T>;
+}
+export interface EventPayloadMap<T = any> {
+    rowSelected: RowSelectedEvent;
+    cellClicked: CellClickedEvent;
+    columnMoved: ColumnMovedEvent;
+    columnResized: ColumnResizedEvent;
+    columnChanged: ColumnChangedEvent;
+    rowDataChanged: RowDataChangedEvent<T>;
+    selectionChanged: SelectionChangedEvent<T>;
+    sortChanged: SortChangedEvent<T>;
+    cellStateChanged: CellStateChangedEvent<T>;
+}
+export type OneCheckboxState = 'checked' | 'unchecked' | 'indeterminate';
+export type RowSelectionMode = 'single' | 'multiple' | null;
+export type EventType = keyof EventPayloadMap;

package/lib/core/models/one-filter.model.d.ts

@@ -0,0 +1,15 @@
+/**
+ * A single filter applied to a column/field.
+ */
+export interface OneFilterModel {
+    field: string;
+    conditions: OneFilterCondition[];
+    logicOperator: 'AND' | 'OR';
+}
+/**
+ * A single condition inside a filter.
+ */
+export interface OneFilterCondition {
+    operator: 'equals' | 'contains' | 'startsWith' | 'endsWith' | 'greaterThan' | 'lessThan';
+    value?: string | number;
+}

package/lib/core/models/one-grid-types.model.d.ts

@@ -0,0 +1,48 @@
+import type { OneGridApi } from "../instants/one-grid-api.class";
+import type { OneRowNode } from "../instants/one-row-node.class";
+import type { OneColumnDef } from "./one-column-def-types.model";
+export type OneGridType = 'simple' | 'master' | 'detail' | 'tree' | null;
+export interface OneGridReadyEvent<T = any> {
+    api: OneGridApi<T>;
+}
+export interface OneGridRowActionEvent<T = any> {
+    rowIndex: number;
+    data: T;
+    api?: OneGridApi<T>;
+    column?: OneColumnDef;
+    node: OneRowNode<T>;
+    masterNode?: OneRowNode<T>;
+    gridType?: OneGridType;
+    selected?: boolean;
+}
+export interface OneGridGetRowIdParams<T = any> {
+    data: T;
+    rowIndex: number;
+}
+export interface OneSortModel<T = any> {
+    colId: keyof T;
+    sort: 'asc' | 'desc';
+}
+export interface GridRowData {
+    rowId: string;
+    [key: string]: any;
+}
+export interface GridRowDataOperation<T extends GridRowData = GridRowData> {
+    /**
+     * Move a row from one index to another
+     * @param sourceIndex - the current index of the row
+     * @param targetIndex - the new index to move to
+     */
+    moveRow(sourceIndex: number, targetIndex: number): void;
+    /**
+     * Remove a row by its unique ID
+     * @param rowId - the ID of the row to remove
+     */
+    removeRow(rowId: string): void;
+    /**
+     * Insert a new row at the given index
+     * @param row - the row data
+     * @param index - where to insert
+     */
+    insertRow(row: T, index: number): void;
+}

package/lib/core/models/one-master-detail.model.d.ts

@@ -0,0 +1,18 @@
+import { OneRowNode } from "../instants/one-row-node.class";
+import { OneColumnDef } from "./one-column-def-types.model";
+import { OneDetailRowHeightOption } from "./one-row.model";
+export interface OneDetailGridOptions {
+    defaultColumnDef: OneColumnDef;
+    columnDefs: OneColumnDef[];
+    rowNumber?: boolean;
+    detailRowHeightOptions: OneDetailRowHeightOption;
+}
+export interface OneGetDetailRowDataParams<T = any, D = any> {
+    data: T;
+    node: OneRowNode<T>;
+    successCallback: (detailRowData: D[]) => void;
+}
+export interface OneDetailCellRendererParams<T = any, D = any> {
+    detailGridOptions: OneDetailGridOptions;
+    getDetailRowData: (params: OneGetDetailRowDataParams<T, D>) => void;
+}

package/lib/core/models/one-pagination-types.model.d.ts

@@ -0,0 +1,9 @@
+export interface OnePaginationParams {
+    total?: number;
+    currentPage?: number;
+    lastPage?: number;
+    perPage?: number;
+    firstRowIndex?: number;
+    lastRowIndex?: number;
+    pageSizeOptions?: number[];
+}

package/lib/core/models/one-row.model.d.ts

@@ -0,0 +1,38 @@
+import type { OneGridApi } from "../instants/one-grid-api.class";
+import type { OneRowNode } from "../instants/one-row-node.class";
+export interface OneGetRowHeightParams<T = any> {
+    node?: OneRowNode<T>;
+    api?: OneGridApi<T>;
+    context?: any;
+}
+export type OneGetRowHeight<T = any> = (params: OneGetRowHeightParams<T>) => number | null | undefined;
+export declare function resolveRowHeight<T>(params: OneGetRowHeightParams<T>, getRowHeight: OneGetRowHeight, rowHeight?: number): number;
+export type OneDetailRowHeightOption = {
+    minRows: number;
+    maxRows: number;
+};
+/**
+ * Handle One Row Node Event
+ */
+export interface OneRowNodeEventMap<T> {
+    rowDataChanged: {
+        node: OneRowNode<T>;
+        data: T;
+        previousData: T;
+    };
+    detailRowDataChanged: {
+        node: OneRowNode<T>;
+        detailRowData: any[];
+        previousDetailRowData: any[] | null;
+    };
+    expandedChanged: {
+        node: OneRowNode<T>;
+        expanded: boolean;
+    };
+    childrenChanged: {
+        node: OneRowNode<T>;
+        children: OneRowNode<T>[];
+        source: 'masterDetail' | 'treeData';
+    };
+}
+export type OneRowNodeListener<T, K extends keyof OneRowNodeEventMap<T>> = (event: OneRowNodeEventMap<T>[K]) => void;

package/lib/core/models/one-tree-data.model.d.ts

@@ -0,0 +1,9 @@
+import type { OneCellRendererParams } from "./one-column-def-types.model";
+export type TreeNode<T> = {
+    id: string;
+    children?: TreeNode<T>[];
+} & T;
+export interface OneCellRendererComponent {
+    oneInit(params: OneCellRendererParams): void;
+    refresh(params: OneCellRendererParams): boolean;
+}

package/lib/core/models/one-validation.model.d.ts

@@ -0,0 +1,9 @@
+export interface OneValidationResult<T> {
+    valid: boolean;
+    invalid: boolean;
+    errors: Record<string, string>[];
+}
+export type OneValidatorFn<T = any> = (value: any, row?: T) => string | null;
+export type OneValidationRules<T = any> = {
+    [K in keyof T]?: OneValidatorFn[];
+};

package/lib/core/pipes/cell-action-button-enable.pipe.d.ts

@@ -0,0 +1,8 @@
+import { PipeTransform } from '@angular/core';
+import { OneCellRendererParams } from '../models/one-column-def-types.model';
+import * as i0 from "@angular/core";
+export declare class CellActionButtonEnablePipe<T> implements PipeTransform {
+    transform(params: OneCellRendererParams<T> | null): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CellActionButtonEnablePipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CellActionButtonEnablePipe<any>, "cellActionButtonEnable", false>;
+}

package/lib/core/pipes/cell-action-button-visible.pipe.d.ts

@@ -0,0 +1,9 @@
+import { PipeTransform } from '@angular/core';
+import { OneColumnDef } from '../models/one-column-def-types.model';
+import { OneRowNode } from '../instants/one-row-node.class';
+import * as i0 from "@angular/core";
+export declare class CellActionButtonVisiblePipe implements PipeTransform {
+    transform(column: OneColumnDef, node: OneRowNode): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CellActionButtonVisiblePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CellActionButtonVisiblePipe, "cellActionButtonVisible", false>;
+}

package/lib/core/pipes/cell-disable-resolver.pipe.d.ts

@@ -0,0 +1,9 @@
+import { PipeTransform } from '@angular/core';
+import { OneRowNode } from '../instants/one-row-node.class';
+import { OneColumnDef } from '../models/one-column-def-types.model';
+import * as i0 from "@angular/core";
+export declare class CellDisableResolverPipe implements PipeTransform {
+    transform(node: OneRowNode, column: OneColumnDef, context: any, allowedEdit: boolean): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CellDisableResolverPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CellDisableResolverPipe, "cellDisableResolver", false>;
+}

package/lib/core/pipes/cell-editable.pipe.d.ts

@@ -0,0 +1,9 @@
+import { PipeTransform } from '@angular/core';
+import { OneCellStates, OneColumnDef } from '../models/one-column-def-types.model';
+import { OneRowNode } from '../instants/one-row-node.class';
+import * as i0 from "@angular/core";
+export declare class CellEditablePipe implements PipeTransform {
+    transform(cellStates: OneCellStates, column: OneColumnDef, node: OneRowNode, editable: (column: OneColumnDef, node: OneRowNode) => boolean, updatable: (column: OneColumnDef, node: OneRowNode) => boolean, allowedEdit: boolean): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CellEditablePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CellEditablePipe, "cellEditable", false>;
+}

package/lib/core/pipes/cell-field-value-empty.pipe.d.ts

@@ -0,0 +1,7 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class CellFieldValueEmptyPipe<T> implements PipeTransform {
+    transform(data: T, field: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CellFieldValueEmptyPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CellFieldValueEmptyPipe<any>, "cellFieldValueEmpty", false>;
+}

package/lib/core/pipes/cell-field-value.pipe.d.ts

@@ -0,0 +1,7 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class CellFieldValuePipe<T = any> implements PipeTransform {
+    transform(data: T, field: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CellFieldValuePipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CellFieldValuePipe<any>, "cellFieldValue", false>;
+}